Exemple de Spring JdbcTemplate

Tutoriels
Spring

JdbcTemplate de Spring est la classe la plus importante dans le package Spring JDBC.

Spring JdbcTemplate

  • Le JDBC produit beaucoup de code redondant, comme l’ouverture/fermeture d’une connexion à une base de données, la gestion des exceptions SQL, etc. Cela rend le code extrêmement encombrant et difficile à lire.
  • En implémentant le JDBC dans le framework Spring, nous nous occupons de nombreuses opérations de bas niveau (ouverture/fermeture des connexions, exécution des requêtes SQL, etc.).
  • Grâce à cela, lorsque nous travaillons avec la base de données dans le framework Spring, nous n’avons besoin que de définir les paramètres de connexion à la base de données et d’enregistrer la requête SQL, le reste du travail est effectué par Spring pour nous.
  • Le JDBC dans Spring dispose de plusieurs classes (plusieurs approches) pour interagir avec la base de données. La plus courante est l’utilisation de la classe JdbcTemplate. C’est la classe de base qui gère le traitement de tous les événements et les connexions à la base de données.
  • La classe JdbcTemplate exécute les requêtes SQL, itère sur le ResultSet et récupère les valeurs appelées, met à jour les instructions et appels de procédures, « attrape » les exceptions et les traduit en exceptions définies dans le package org.springframework.dao.
  • Instances de la classe JdbcTemplate sont thread-safe. Cela signifie qu’en configurant une seule instance de la classe JdbcTemplate, nous pouvons ensuite l’utiliser pour plusieurs objets DAO.
  • Lors de l’utilisation de JdbcTemplate, il est le plus souvent configuré dans le fichier de configuration Spring. Ensuite, il est implémenté en utilisant un bean dans les classes DAO.

Exemple de Spring JdbcTemplate

Jetons un coup d’œil à l’exemple de programme Spring JdbcTemplate. J’utilise ici la base de données Postgresql, mais vous pouvez également utiliser toute autre base de données relationnelle, telle que MySQL et Oracle. Tout ce dont vous avez besoin, c’est de changer les configurations de la base de données et cela devrait fonctionner. Tout d’abord, nous avons besoin de quelques données d’échantillon sur lesquelles travailler. Les requêtes SQL ci-dessous créeront une table et la rempliront avec quelques données pour que nous puissions les utiliser.

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’image ci-dessous montre la structure finale du projet dans Eclipse.

Dépendances Maven de Spring JDBC

Nous avons besoin des dépendances suivantes – `spring-core`, `spring-context`, `spring-jdbc` et `postgresql`. Si vous utilisez une autre base de données relationnelle comme MySQL, ajoutez les dépendances correspondantes du pilote java. Voici notre fichier pom.xml final. 

<?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>

Configuration de la source de données Spring

La prochaine étape consiste à créer une classe de configuration Spring pour définir le bean DataSource. J’utilise une configuration basée sur Java, vous pouvez également le faire en utilisant un fichier de configuration xml de 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 – indique que cette classe est une configuration pour le contexte Spring.
  • @ComponentScan (« com.journaldev.spring ») – spécifie le package à analyser pour les classes de composants.
  • @PropertySource (« classpath:database.properties ») – indique que les propriétés seront lues à partir du fichier database.properties.

Le contenu du fichier database.properties est affiché ci-dessous. 

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

Si vous utilisez MySQL ou une autre base de données relationnelle, modifiez les configurations ci-dessus en conséquence.

Classes de modèle JDBC Spring

La prochaine étape consiste à créer des classes de modèle pour mapper notre table de base de données.

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
				+ '\'' + '}';
	}
}

Pour récupérer des données de la base de données, nous devons implémenter l’interface RowMapper. Cette interface n’a qu’une seule méthode mapRow(ResultSet resultSet, int i), qui renverra une instance de notre classe de modèle (c’est-à-dire 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;
	}
}

Classes DAO JDBC Spring

La dernière étape consiste à créer des classes DAO pour mapper notre classe de modèle à la table de base de données à l’aide de requêtes SQL. Nous configurerons également le DataSource à l’aide de l’annotation @Autowired et exposerons certaines 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 est annotée avec l’annotation @Component et dans cette classe, nous avons un champ de type JdbcTemplate. Lorsque le constructeur de cette classe sera invoqué, une instance de DataSource lui sera injectée et nous pourrons créer une instance de JdbcTemplate. Ensuite, nous pouvons l’utiliser dans nos méthodes.

Programme de test Spring JdbcTemplate

Notre projet d’exemple Spring JdbcTemplate est prêt, testons-le avec une classe de 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’image ci-dessous montre la sortie produite lorsque nous exécutons le programme ci-dessus. La sortie variera en fonction des données d’exemple et des exécutions multiples, l’idée est d’apprendre ici comment utiliser Spring JdbcTemplate à travers un programme d’exemple. C’est tout sur Spring JdbcTemplate, vous pouvez télécharger le projet final à partir du lien ci-dessous.

Télécharger le projet d’exemple Spring JdbcTemplate

Référence : Documentation de l’API

Source:
https://www.digitalocean.com/community/tutorials/spring-jdbctemplate-example