Spring Boot - Manejo de bases de datos

Spring Boot proporciona un muy buen soporte para crear una fuente de datos para la base de datos. No necesitamos escribir ningún código adicional para crear un DataSource en Spring Boot. Simplemente agregando las dependencias y haciendo los detalles de configuración es suficiente para crear una fuente de datos y conectar la base de datos.

En este capítulo, usaremos la conexión del controlador Spring Boot JDBC para conectar la base de datos.

Primero, necesitamos agregar la dependencia JDBC de Spring Boot Starter en nuestro archivo de configuración de compilación.

Los usuarios de Maven pueden agregar las siguientes dependencias en el archivo pom.xml.

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

Los usuarios de Gradle pueden agregar las siguientes dependencias en el archivo build.gradle.

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

Conectarse a la base de datos H2

Para conectar la base de datos H2, necesitamos agregar la dependencia de la base de datos H2 en nuestro archivo de configuración de compilación.

Para los usuarios de Maven, agregue la siguiente dependencia en su archivo pom.xml.

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

Para los usuarios de Gradle, agregue la siguiente dependencia en su archivo build.gradle.

compile('com.h2database:h2')

Necesitamos crear el archivo schema.sql y el archivo data.sql en el directorio classpath src / main / resources para conectar la base de datos H2.

El archivo schema.sql se muestra a continuación.

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

El archivo data.sql se muestra a continuación.

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

Conectar MySQL

Para conectar la base de datos MySQL, necesitamos agregar la dependencia MySQL en nuestro archivo de configuración de compilación.

Para los usuarios de Maven, agregue la siguiente dependencia en su archivo pom.xml.

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

Para los usuarios de Gradle, agregue la siguiente dependencia en su archivo build.gradle.

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

Ahora, cree una base de datos y tablas en MySQL como se muestra:

Para los usuarios del archivo de propiedades, agregue las siguientes propiedades en el archivo 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

Para los usuarios de YAML, agregue las siguientes propiedades en el archivo 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

Conectar Redis

Redis es una base de datos de código abierto que se utiliza para almacenar la estructura de datos en memoria. Para conectar la base de datos de Redis en la aplicación Spring Boot, necesitamos agregar la dependencia de Redis en nuestro archivo de configuración de compilación.

Los usuarios de Maven deben agregar la siguiente dependencia en su archivo pom.xml.

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

Los usuarios de Gradle deben agregar la siguiente dependencia en su archivo build.gradle.

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

Para la conexión de Redis, necesitamos usar RedisTemplate. Para RedisTemplate, debemos proporcionar los detalles 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;
}

Ahora conecte automáticamente la clase RedisTemplate y acceda a los datos de la base de datos de Redis.

@Autowired

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

JDBCTemplate

Para acceder a la base de datos relacional usando JdbcTemplate en la aplicación Spring Boot, necesitamos agregar la dependencia Spring Boot Starter JDBC en nuestro archivo de configuración de compilación.

Luego, si @Autowired la clase JdbcTemplate, Spring Boot conecta automáticamente la base de datos y establece la fuente de datos para el objeto JdbcTemplate.

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

La anotación @Repository debe agregarse al archivo de clase. La anotación @Repository se utiliza para crear un repositorio de base de datos para su aplicación Spring Boot.

@Repository
public class ProductServiceDAO {
}

Fuente de datos múltiple

Podemos mantener 'n' números de fuentes de datos en una sola aplicación Spring Boot. El ejemplo que se muestra aquí muestra cómo crear más de una fuente de datos en la aplicación Spring Boot. Ahora, agregue los dos detalles de configuración de la fuente de datos en el archivo de propiedades de la aplicación.

Para los usuarios del archivo de propiedades, agregue las siguientes propiedades en su archivo 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

Los usuarios de Yaml deben agregar las siguientes propiedades en su archivo 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

Ahora, cree una clase de configuración para crear un DataSource y JdbcTemplate para múltiples fuentes de datos.

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

Luego, cablee automáticamente el objeto JDBCTemplate usando la anotación @Qualifier.

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

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