Spring Boot - Gestion de la base de données

Spring Boot fournit un très bon support pour créer une DataSource pour la base de données. Nous n'avons pas besoin d'écrire de code supplémentaire pour créer une DataSource dans Spring Boot. Il suffit d'ajouter les dépendances et de faire les détails de configuration pour créer une source de données et connecter la base de données.

Dans ce chapitre, nous allons utiliser la connexion du pilote Spring Boot JDBC pour connecter la base de données.

Tout d'abord, nous devons ajouter la dépendance JDBC Spring Boot Starter dans notre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter les dépendances suivantes dans le fichier pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

Les utilisateurs Gradle peuvent ajouter les dépendances suivantes dans le fichier build.gradle.

compile('org.springframework.boot:spring-boot-starter-jdbc')

Connectez-vous à la base de données H2

Pour connecter la base de données H2, nous devons ajouter la dépendance de base de données H2 dans notre fichier de configuration de construction.

Pour les utilisateurs Maven, ajoutez la dépendance ci-dessous dans votre fichier pom.xml.

<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
</dependency>

Pour les utilisateurs de Gradle, ajoutez la dépendance ci-dessous dans votre fichier build.gradle.

compile('com.h2database:h2')

Nous devons créer le fichier schema.sql et le fichier data.sql sous le répertoire classpath src / main / resources pour connecter la base de données H2.

Le fichier schema.sql est donné ci-dessous.

CREATE TABLE PRODUCT (ID INT PRIMARY KEY, PRODUCT_NAME VARCHAR(25));

Le fichier data.sql est donné ci-dessous.

INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (1,'Honey');
INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (2,'Almond');

Connectez MySQL

Pour connecter la base de données MySQL, nous devons ajouter la dépendance MySQL dans notre fichier de configuration de construction.

Pour les utilisateurs Maven, ajoutez la dépendance suivante dans votre fichier pom.xml.

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>

Pour les utilisateurs de Gradle, ajoutez la dépendance suivante dans votre fichier build.gradle.

compile('mysql:mysql-connector-java')

Maintenant, créez une base de données et des tables dans MySQL comme indiqué -

Pour les utilisateurs du fichier de propriétés, ajoutez les propriétés suivantes dans le fichier application.properties.

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.testOnBorrow = true
spring.datasource.testWhileIdle = true
spring.datasource.timeBetweenEvictionRunsMillis = 60000
spring.datasource.minEvictableIdleTimeMillis = 30000
spring.datasource.validationQuery = SELECT 1
spring.datasource.max-active = 15
spring.datasource.max-idle = 10
spring.datasource.max-wait = 8000

Pour les utilisateurs YAML, ajoutez les propriétés suivantes dans le fichier application.yml.

spring:
   datasource: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect=true"
      username: "root"
      password: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000

Connectez Redis

Redis est une base de données open source utilisée pour stocker la structure de données en mémoire. Pour connecter la base de données Redis dans l'application Spring Boot, nous devons ajouter la dépendance Redis dans notre fichier de configuration de construction.

Les utilisateurs Maven doivent ajouter la dépendance suivante dans votre fichier pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-redis</artifactId>
</dependency>

Les utilisateurs Gradle doivent ajouter la dépendance suivante dans votre fichier build.gradle.

compile('org.springframework.boot:spring-boot-starter-data-redis')

Pour la connexion Redis, nous devons utiliser RedisTemplate. Pour RedisTemplate, nous devons fournir les détails de JedisConnectionFactory.

@Bean
JedisConnectionFactory jedisConnectionFactory() {
   JedisConnectionFactory jedisConFactory = new JedisConnectionFactory();
   jedisConFactory.setHostName("localhost");
   jedisConFactory.setPort(6000);
   jedisConFactory.setUsePool(true);
   return jedisConFactory;
}
@Bean
public RedisTemplate<String, Object> redisTemplate() {
   RedisTemplate<String, Object> template = new RedisTemplate<>();
   template.setConnectionFactory(jedisConnectionFactory());
   template.setKeySerializer(new StringRedisSerializer());
   template.setHashKeySerializer(new StringRedisSerializer());
   template.setHashValueSerializer(new StringRedisSerializer());
   template.setValueSerializer(new StringRedisSerializer());
   return template;
}

Connectez maintenant automatiquement la classe RedisTemplate et accédez aux données de la base de données Redis.

@Autowired

RedisTemplate<String, Object> redis;
Map<Object,Object> datalist = redis.opsForHash().entries(“Redis_code_index_key”);

JDBCTemplate

Pour accéder à la base de données relationnelle à l'aide de JdbcTemplate dans l'application Spring Boot, nous devons ajouter la dépendance JDBC Spring Boot Starter dans notre fichier de configuration de construction.

Ensuite, si vous @Autowired la classe JdbcTemplate, Spring Boot connecte automatiquement la base de données et définit la source de données pour l'objet JdbcTemplate.

@Autowired
JdbcTemplate jdbcTemplate;
Collection<Map<String, Object>> rows = jdbc.queryForList("SELECT QUERY");

L'annotation @Repository doit être ajoutée dans le fichier de classe. L'annotation @Repository est utilisée pour créer un référentiel de base de données pour votre application Spring Boot.

@Repository
public class ProductServiceDAO {
}

Source de données multiple

Nous pouvons conserver les sources de données à nombre «n» dans une seule application Spring Boot. L'exemple donné ici montre comment créer plus d'une source de données dans l'application Spring Boot. Maintenant, ajoutez les deux détails de configuration de la source de données dans le fichier de propriétés de l'application.

Pour les utilisateurs du fichier de propriétés, ajoutez les propriétés suivantes dans votre fichier application.properties.

spring.dbProductService.driverClassName = com.mysql.jdbc.Driver
spring.dbProductService.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.dbProductService.username = root
spring.dbProductService.password = root
spring.dbProductService.testOnBorrow = true
spring.dbProductService.testWhileIdle = true
spring.dbProductService.timeBetweenEvictionRunsMillis = 60000
spring.dbProductService.minEvictableIdleTimeMillis = 30000
spring.dbProductService.validationQuery = SELECT 1
spring.dbProductService.max-active = 15
spring.dbProductService.max-idle = 10
spring.dbProductService.max-wait = 8000

spring.dbUserService.driverClassName = com.mysql.jdbc.Driver
spring.dbUserService.url = jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect = true
spring.dbUserService.username = root
spring.dbUserService.password = root
spring.dbUserService.testOnBorrow = true
spring.dbUserService.testWhileIdle = true
spring.dbUserService.timeBetweenEvictionRunsMillis = 60000
spring.dbUserService.minEvictableIdleTimeMillis = 30000
spring.dbUserService.validationQuery = SELECT 1
spring.dbUserService.max-active = 15
spring.dbUserService.max-idle = 10
spring.dbUserService.max-wait = 8000

Les utilisateurs de Yaml doivent ajouter les propriétés suivantes dans votre fichier application.yml.

spring:
   dbProductService: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000
   dbUserService: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1    
      max-active: 15
      max-idle: 10
      max-wait: 8000

Maintenant, créez une classe de configuration pour créer un DataSource et un JdbcTemplate pour plusieurs sources de données.

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;

@Configuration
public class DatabaseConfig {
   @Bean(name = "dbProductService")
   @ConfigurationProperties(prefix = "spring.dbProductService")
   @Primary
   public DataSource createProductServiceDataSource() {
      return DataSourceBuilder.create().build();
   }
   @Bean(name = "dbUserService")
   @ConfigurationProperties(prefix = "spring.dbUserService")
   public DataSource createUserServiceDataSource() {
      return DataSourceBuilder.create().build();
   }
   @Bean(name = "jdbcProductService")
   @Autowired
   public JdbcTemplate createJdbcTemplate_ProductService(@Qualifier("dbProductService") DataSource productServiceDS) {
      return new JdbcTemplate(productServiceDS);
   }
   @Bean(name = "jdbcUserService")
   @Autowired
   public JdbcTemplate createJdbcTemplate_UserService(@Qualifier("dbUserService") DataSource userServiceDS) {
      return new JdbcTemplate(userServiceDS);
   }
}

Ensuite, connectez automatiquement l'objet JDBCTemplate à l'aide de l'annotation @Qualifier.

@Qualifier("jdbcProductService")
@Autowired
JdbcTemplate jdbcTemplate;

@Qualifier("jdbcUserService")
@Autowired
JdbcTemplate jdbcTemplate;