Spring Boot - manipulação de banco de dados

Spring Boot fornece um suporte muito bom para criar uma fonte de dados para banco de dados. Não precisamos escrever nenhum código extra para criar um DataSource no Spring Boot. Basta adicionar as dependências e fazer os detalhes da configuração para criar um DataSource e conectar o Banco de Dados.

Neste capítulo, usaremos a conexão do driver JDBC Spring Boot para conectar o banco de dados.

Primeiro, precisamos adicionar a dependência Spring Boot Starter JDBC em nosso arquivo de configuração de construção.

Os usuários do Maven podem adicionar as seguintes dependências no arquivo pom.xml.

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

Os usuários do Gradle podem adicionar as seguintes dependências no arquivo build.gradle.

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

Conecte-se ao banco de dados H2

Para conectar o banco de dados H2, precisamos adicionar a dependência do banco de dados H2 em nosso arquivo de configuração de construção.

Para usuários Maven, adicione a dependência abaixo em seu arquivo pom.xml.

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

Para usuários do Gradle, adicione a dependência abaixo em seu arquivo build.gradle.

compile('com.h2database:h2')

Precisamos criar o arquivo schema.sql e o arquivo data.sql no diretório classpath src / main / resources para conectar o banco de dados H2.

O arquivo schema.sql é fornecido abaixo.

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

O arquivo data.sql é fornecido abaixo.

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

Conecte o MySQL

Para conectar o banco de dados MySQL, precisamos adicionar a dependência do MySQL em nosso arquivo de configuração de construção.

Para usuários do Maven, adicione a seguinte dependência em seu arquivo pom.xml.

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

Para usuários do Gradle, adicione a seguinte dependência ao arquivo build.gradle.

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

Agora, crie banco de dados e tabelas no MySQL, conforme mostrado -

Para usuários do arquivo de propriedades, inclua as propriedades a seguir no arquivo 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 usuários YAML, adicione as seguintes propriedades no arquivo 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 é um banco de dados de código aberto usado para armazenar a estrutura de dados na memória. Para conectar o banco de dados Redis no aplicativo Spring Boot, precisamos adicionar a dependência do Redis em nosso arquivo de configuração de construção.

Os usuários do Maven devem adicionar a seguinte dependência em seu arquivo pom.xml.

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

Os usuários do Gradle devem adicionar a seguinte dependência ao arquivo build.gradle.

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

Para conexão Redis, precisamos usar RedisTemplate. Para RedisTemplate, precisamos fornecer os detalhes 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;
}

Agora conecte automaticamente a classe RedisTemplate e acesse os dados do banco de dados Redis.

@Autowired

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

JDBCTemplate

Para acessar o Banco de Dados Relacional usando JdbcTemplate no aplicativo Spring Boot, precisamos adicionar a dependência JDBC do Spring Boot Starter em nosso arquivo de configuração de construção.

Então, se você @Autowired a classe JdbcTemplate, Spring Boot conecta automaticamente o banco de dados e define a fonte de dados para o objeto JdbcTemplate.

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

A anotação @Repository deve ser adicionada ao arquivo de classe. A anotação @Repository é usada para criar um repositório de banco de dados para seu aplicativo Spring Boot.

@Repository
public class ProductServiceDAO {
}

Multiple DataSource

Podemos manter 'n' número de fontes de dados em um único aplicativo Spring Boot. O exemplo fornecido aqui mostra como criar mais de 1 fonte de dados no aplicativo Spring Boot. Agora, inclua os dois detalhes de configuração da origem de dados no arquivo de propriedades do aplicativo.

Para usuários do arquivo de propriedades, inclua as propriedades a seguir em seu arquivo 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

Os usuários Yaml devem adicionar as seguintes propriedades em seu arquivo 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

Agora, crie uma classe de configuração para criar um DataSource e JdbcTemplate para várias fontes de dados.

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

Em seguida, conecte automaticamente o objeto JDBCTemplate usando a anotação @Qualifier.

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

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