Spring Boot - Gestione database

Spring Boot fornisce un ottimo supporto per creare un'origine dati per database. Non è necessario scrivere codice aggiuntivo per creare un DataSource in Spring Boot. Basta aggiungere le dipendenze e fare i dettagli di configurazione per creare un DataSource e connettere il Database.

In questo capitolo, utilizzeremo la connessione del driver JDBC Spring Boot per connettere il database.

Innanzitutto, dobbiamo aggiungere la dipendenza JDBC di Spring Boot Starter nel nostro file di configurazione della build.

Gli utenti Maven possono aggiungere le seguenti dipendenze nel file pom.xml.

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

Gli utenti Gradle possono aggiungere le seguenti dipendenze nel file build.gradle.

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

Connettiti al database H2

Per connettere il database H2, dobbiamo aggiungere la dipendenza del database H2 nel nostro file di configurazione della build.

Per gli utenti Maven, aggiungi la seguente dipendenza nel tuo file pom.xml.

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

Per gli utenti Gradle, aggiungi la seguente dipendenza nel tuo file build.gradle.

compile('com.h2database:h2')

Dobbiamo creare il file schema.sql e il file data.sql nella directory classpath src / main / resources per connettere il database H2.

Il file schema.sql è fornito di seguito.

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

Il file data.sql è fornito di seguito.

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

Connetti MySQL

Per connettere il database MySQL, dobbiamo aggiungere la dipendenza MySQL nel nostro file di configurazione della build.

Per gli utenti Maven, aggiungi la seguente dipendenza nel tuo file pom.xml.

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

Per gli utenti Gradle, aggiungi la seguente dipendenza nel tuo file build.gradle.

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

Ora, crea database e tabelle in MySQL come mostrato -

Per gli utenti del file delle proprietà, aggiungere le seguenti proprietà nel file 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

Per gli utenti YAML, aggiungi le seguenti proprietà nel file 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

Connetti Redis

Redis è un database open source utilizzato per archiviare la struttura dei dati in memoria. Per connettere il database Redis nell'applicazione Spring Boot, dobbiamo aggiungere la dipendenza Redis nel nostro file di configurazione della build.

Gli utenti Maven dovrebbero aggiungere la seguente dipendenza nel file pom.xml.

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

Gli utenti Gradle dovrebbero aggiungere la seguente dipendenza nel file build.gradle.

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

Per la connessione Redis, dobbiamo usare RedisTemplate. Per RedisTemplate dobbiamo fornire i dettagli di 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;
}

Ora collega automaticamente la classe RedisTemplate e accedi ai dati dal database Redis.

@Autowired

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

JDBCTemplate

Per accedere al database relazionale utilizzando JdbcTemplate nell'applicazione Spring Boot, è necessario aggiungere la dipendenza JDBC Spring Boot Starter nel file di configurazione della build.

Quindi, se hai @Autowired la classe JdbcTemplate, Spring Boot connette automaticamente il database e imposta l'origine dati per l'oggetto JdbcTemplate.

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

L'annotazione @Repository dovrebbe essere aggiunta al file di classe. L'annotazione @Repository viene utilizzata per creare un repository di database per l'applicazione Spring Boot.

@Repository
public class ProductServiceDAO {
}

Più DataSource

Possiamo mantenere un numero 'n' di origini dati in una singola applicazione Spring Boot. L'esempio fornito qui mostra come creare più di 1 origine dati nell'applicazione Spring Boot. Ora aggiungi i due dettagli di configurazione dell'origine dati nel file delle proprietà dell'applicazione.

Per gli utenti del file delle proprietà, aggiungere le seguenti proprietà nel file 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

Gli utenti Yaml dovrebbero aggiungere le seguenti proprietà nel file 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

Ora, crea una classe Configuration per creare un DataSource e un JdbcTemplate per più origini dati.

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);
   }
}

Quindi, cablare automaticamente l'oggetto JDBCTemplate utilizzando l'annotazione @Qualifier.

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

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