Esempio di Spring JdbcTemplate

Spring JdbcTemplate è la classe più importante nel pacchetto Spring JDBC.

Spring JdbcTemplate

• Il JDBC produce molto codice boilerplate, come l’apertura/chiusura di una connessione al database, la gestione delle eccezioni SQL, ecc. Rende il codice estremamente ingombrante e difficile da leggere.
• L’implementazione del JDBC nel Framework Spring si occupa di lavorare con molte operazioni di basso livello (apertura/chiusura connessioni, esecuzione di query SQL, ecc.).
• Grazie a questo, quando si lavora con il database nel Framework Spring, è sufficiente definire i parametri di connessione al database e registrare la query SQL, il resto del lavoro viene svolto da Spring.
• Il JDBC in Spring ha diverse classi (diversi approcci) per interagire con il database. Il più comune di questi è l’utilizzo della classe JdbcTemplate. Questa è la classe base che gestisce l’elaborazione di tutti gli eventi e le connessioni al database.
• La classe JdbcTemplate esegue query SQL, itera sul ResultSet e recupera i valori richiamati, aggiorna le istruzioni e le chiamate di procedura, “cattura” le eccezioni e le traduce nelle eccezioni definite nel pacchetto org.springframwork.dao.
• Le istanze della classe JdbcTemplate sono thread-safe. Ciò significa che configurando una singola istanza della classe JdbcTemplate, possiamo poi utilizzarla per diversi oggetti DAO.
• Quando si utilizza JdbcTemplate, più spesso, viene configurato nel file di configurazione di Spring. Dopo di che, viene implementato utilizzando bean nelle classi DAO.

Esempio di Spring JdbcTemplate

Vediamo un esempio di programma Spring JdbcTemplate. Sto utilizzando il database Postgresql qui, ma puoi utilizzare anche qualsiasi altro database relazionale, come MySQL e Oracle. Tutto ciò di cui hai bisogno è modificare le configurazioni del database e dovrebbe funzionare. Prima di tutto abbiamo bisogno di alcuni dati di esempio su cui lavorare. Le query SQL seguenti creeranno una tabella e la popoleranno con alcuni dati per noi da utilizzare.

create table people (
id serial not null primary key,
first_name varchar(20) not null,
last_name varchar(20) not null,
age integer not null
);

insert into people (id, first_name, last_name, age) values
(1, 'Vlad', 'Boyarskiy', 21),
(2,'Oksi', ' Bahatskaya', 30),
(3,'Vadim', ' Vadimich', 32);

L’immagine seguente mostra la struttura finale del progetto in Eclipse.

Dipendenze Maven di Spring JDBC

Abbiamo bisogno delle seguenti dipendenze – `spring-core`, `spring-context`, `spring-jdbc` e `postgresql`. Se stai utilizzando un altro database relazionale come MySQL, aggiungi le relative dipendenze per il driver java. Ecco il nostro file pom.xml finale.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.journaldev.spring</groupId>
	<artifactId>JdbcTemplate</artifactId>
	<version>1.0-SNAPSHOT</version>
	<properties>
		<spring.framework>4.3.0.RELEASE</spring.framework>
		<postgres.version>42.1.4</postgres.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.postgresql</groupId>
			<artifactId>postgresql</artifactId>
			<version>${postgres.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.framework}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.framework}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring.framework}</version>
		</dependency>
	</dependencies>

</project>

Configurazione della fonte dati di Spring

Il prossimo passo è creare una classe di configurazione Spring per definire il bean `DataSource`. Sto utilizzando la configurazione basata su Java, puoi anche farlo utilizzando un file di configurazione XML dei bean Spring.

package com.journaldev.spring.config;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

@Configuration
@ComponentScan("com.journaldev.spring")
@PropertySource("classpath:database.properties")
public class AppConfig {

	@Autowired
	Environment environment;

	private final String URL = "url";
	private final String USER = "dbuser";
	private final String DRIVER = "driver";
	private final String PASSWORD = "dbpassword";

	@Bean
	DataSource dataSource() {
		DriverManagerDataSource driverManagerDataSource = new DriverManagerDataSource();
		driverManagerDataSource.setUrl(environment.getProperty(URL));
		driverManagerDataSource.setUsername(environment.getProperty(USER));
		driverManagerDataSource.setPassword(environment.getProperty(PASSWORD));
		driverManagerDataSource.setDriverClassName(environment.getProperty(DRIVER));
		return driverManagerDataSource;
	}
}

• @Configuration – indica che questa classe è una configurazione per il contesto di Spring.
• @ComponentScan(“com.journaldev.spring”)- specifica il pacchetto da esaminare per le classi dei componenti.
• @PropertySource(“classpath:database.properties”)- indica che le proprietà saranno lette dal file database.properties.

Il contenuto del file `database.properties` è mostrato di seguito.

driver=org.postgresql.Driver
url=jdbc:postgresql://127.0.0.1:5432/school
dbuser=postgres
dbpassword=postgres

Se stai utilizzando MySQL o un altro database relazionale, modifica le configurazioni sopra di conseguenza.

Spring JDBC Model Classes

Il passo successivo è creare classi modello per mappare la nostra tabella del database.

package com.journaldev.model;

public class Person {
	private Long id;
	private Integer age;
	private String firstName;
	private String lastName;

	public Person() {
	}

	public Person(Long id, Integer age, String firstName, String lastName) {
		this.id = id;
		this.age = age;
		this.firstName = firstName;
		this.lastName = lastName;
	}

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	@Override
	public String toString() {
		return "Person{" + "id=" + id + ", age=" + age + ", firstName='" + firstName + '\'' + ", lastName='" + lastName
				+ '\'' + '}';
	}
}

Per recuperare i dati dal database, dobbiamo implementare l’interfaccia RowMapper. Questa interfaccia ha solo un metodo mapRow(ResultSet resultSet, int i), che restituirà un’istanza della nostra classe modello (cioè Person).

package com.journaldev.model;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

public class PersonMapper implements RowMapper<Person> {

	public Person mapRow(ResultSet resultSet, int i) throws SQLException {

		Person person = new Person();
		person.setId(resultSet.getLong("id"));
		person.setFirstName(resultSet.getString("first_name"));
		person.setLastName(resultSet.getString("last_name"));
		person.setAge(resultSet.getInt("age"));
		return person;
	}
}

Spring JDBC DAO Classes

Il passo finale è creare classi DAO per mappare la nostra classe modello alla tabella del database usando query SQL. Configureremo anche il DataSource utilizzando l’annotazione @Autowired ed esporremo alcune API.

package com.journaldev.spring.dao;

import java.util.List;

import com.journaldev.model.Person;

public interface PersonDAO {
	Person getPersonById(Long id);

	List<Person> getAllPersons();

	boolean deletePerson(Person person);

	boolean updatePerson(Person person);

	boolean createPerson(Person person);
}

package com.journaldev.spring.dao;

import java.util.List;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

import com.journaldev.model.Person;
import com.journaldev.model.PersonMapper;

@Component
public class PersonDAOImpl implements PersonDAO {

	JdbcTemplate jdbcTemplate;

	private final String SQL_FIND_PERSON = "select * from people where id = ?";
	private final String SQL_DELETE_PERSON = "delete from people where id = ?";
	private final String SQL_UPDATE_PERSON = "update people set first_name = ?, last_name = ?, age  = ? where id = ?";
	private final String SQL_GET_ALL = "select * from people";
	private final String SQL_INSERT_PERSON = "insert into people(id, first_name, last_name, age) values(?,?,?,?)";

	@Autowired
	public PersonDAOImpl(DataSource dataSource) {
		jdbcTemplate = new JdbcTemplate(dataSource);
	}

	public Person getPersonById(Long id) {
		return jdbcTemplate.queryForObject(SQL_FIND_PERSON, new Object[] { id }, new PersonMapper());
	}

	public List<Person> getAllPersons() {
		return jdbcTemplate.query(SQL_GET_ALL, new PersonMapper());
	}

	public boolean deletePerson(Person person) {
		return jdbcTemplate.update(SQL_DELETE_PERSON, person.getId()) > 0;
	}

	public boolean updatePerson(Person person) {
		return jdbcTemplate.update(SQL_UPDATE_PERSON, person.getFirstName(), person.getLastName(), person.getAge(),
				person.getId()) > 0;
	}

	public boolean createPerson(Person person) {
		return jdbcTemplate.update(SQL_INSERT_PERSON, person.getId(), person.getFirstName(), person.getLastName(),
				person.getAge()) > 0;
	}
}

La classe PersonDAOImpl è annotata con @Component e in questa classe abbiamo un campo di tipo JdbcTemplate. Quando il costruttore di questa classe viene invocato, le verrà iniettata un’istanza di DataSource e possiamo creare un’istanza di JdbcTemplate. Successivamente, possiamo utilizzarla nei nostri metodi.

Programma di test Spring JdbcTemplate

Il nostro progetto di esempio Spring JdbcTemplate è pronto, testiamolo con una classe di test.

package com.journaldev;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.journaldev.model.Person;
import com.journaldev.spring.config.AppConfig;
import com.journaldev.spring.dao.PersonDAO;

public class Main {
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

		PersonDAO personDAO = context.getBean(PersonDAO.class);

		System.out.println("List of person is:");

		for (Person p : personDAO.getAllPersons()) {
			System.out.println(p);
		}

		System.out.println("\nGet person with ID 2");

		Person personById = personDAO.getPersonById(2L);
		System.out.println(personById);

		System.out.println("\nCreating person: ");
		Person person = new Person(4L, 36, "Sergey", "Emets");
		System.out.println(person);
		personDAO.createPerson(person);
		System.out.println("\nList of person is:");

		for (Person p : personDAO.getAllPersons()) {
			System.out.println(p);
		}

		System.out.println("\nDeleting person with ID 2");
		personDAO.deletePerson(personById);

		System.out.println("\nUpdate person with ID 4");

		Person pperson = personDAO.getPersonById(4L);
		pperson.setLastName("CHANGED");
		personDAO.updatePerson(pperson);

		System.out.println("\nList of person is:");
		for (Person p : personDAO.getAllPersons()) {
			System.out.println(p);
		}

		context.close();
	}
}

L’immagine qui sotto mostra l’output prodotto quando eseguiamo il programma sopra. L’output varierà in base ai dati di esempio e alle esecuzioni multiple, l’idea è imparare qui come utilizzare Spring JdbcTemplate attraverso un programma di esempio. Questo è tutto riguardo a Spring JdbcTemplate, puoi scaricare il progetto finale dal link sottostante.

Scarica il progetto di esempio di Spring JdbcTemplate

Riferimento: Documentazione API