Spring Boot - Datenbankbehandlung

Spring Boot bietet eine sehr gute Unterstützung beim Erstellen einer DataSource für die Datenbank. Wir müssen keinen zusätzlichen Code schreiben, um eine DataSource in Spring Boot zu erstellen. Das Hinzufügen der Abhängigkeiten und das Ausführen der Konfigurationsdetails reicht aus, um eine DataSource zu erstellen und die Datenbank zu verbinden.

In diesem Kapitel verwenden wir die Spring Boot JDBC-Treiberverbindung, um die Datenbank zu verbinden.

Zuerst müssen wir die Spring Boot Starter JDBC-Abhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Maven-Benutzer können der Datei pom.xml die folgenden Abhängigkeiten hinzufügen.

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

Gradle-Benutzer können der Datei build.gradle die folgenden Abhängigkeiten hinzufügen.

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

Stellen Sie eine Verbindung zur H2-Datenbank her

Um die H2-Datenbank zu verbinden, müssen wir die H2-Datenbankabhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Fügen Sie für Maven-Benutzer die folgende Abhängigkeit in Ihre pom.xml-Datei ein.

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

Fügen Sie für Gradle-Benutzer die folgende Abhängigkeit in Ihre build.gradle-Datei ein.

compile('com.h2database:h2')

Wir müssen die Datei schema.sql und die Datei data.sql im Verzeichnis classpath src / main / resources erstellen, um die H2-Datenbank zu verbinden.

Die Datei schema.sql ist unten angegeben.

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

Die Datei data.sql ist unten angegeben.

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

Verbinden Sie MySQL

Um die MySQL-Datenbank zu verbinden, müssen wir die MySQL-Abhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Fügen Sie für Maven-Benutzer die folgende Abhängigkeit in Ihre pom.xml-Datei ein.

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

Fügen Sie für Gradle-Benutzer die folgende Abhängigkeit in Ihre build.gradle-Datei ein.

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

Erstellen Sie nun wie gezeigt eine Datenbank und Tabellen in MySQL.

Fügen Sie für Benutzer von Eigenschaftendateien die folgenden Eigenschaften in die Datei application.properties ein.

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

Fügen Sie für YAML-Benutzer die folgenden Eigenschaften in die Datei application.yml ein.

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

Verbinden Sie Redis

Redis ist eine Open-Source-Datenbank, in der die speicherinterne Datenstruktur gespeichert wird. Um die Redis-Datenbank in der Spring Boot-Anwendung zu verbinden, müssen wir die Redis-Abhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Maven-Benutzer sollten der Datei pom.xml die folgende Abhängigkeit hinzufügen.

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

Gradle-Benutzer sollten der build.gradle-Datei die folgende Abhängigkeit hinzufügen.

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

Für die Redis-Verbindung müssen wir RedisTemplate verwenden. Für RedisTemplate müssen wir die JedisConnectionFactory-Details bereitstellen.

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

Verbinden Sie nun die RedisTemplate-Klasse automatisch und greifen Sie auf die Daten aus der Redis-Datenbank zu.

@Autowired

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

JDBCTemplate

Um mithilfe von JdbcTemplate in der Spring Boot-Anwendung auf die relationale Datenbank zuzugreifen, müssen Sie die Spring Boot Starter-JDBC-Abhängigkeit in unsere Build-Konfigurationsdatei aufnehmen.

Wenn Sie dann die JdbcTemplate-Klasse @Autowired haben, verbindet Spring Boot automatisch die Datenbank und legt die Datenquelle für das JdbcTemplate-Objekt fest.

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

Die Annotation @Repository sollte der Klassendatei hinzugefügt werden. Die Annotation @Repository wird verwendet, um ein Datenbank-Repository für Ihre Spring Boot-Anwendung zu erstellen.

@Repository
public class ProductServiceDAO {
}

Mehrere DataSource

Wir können 'n' Anzahl Datenquellen in einer einzigen Spring Boot-Anwendung behalten. Das hier gegebene Beispiel zeigt, wie Sie mehr als eine Datenquelle in der Spring Boot-Anwendung erstellen. Fügen Sie nun die beiden Datenquellen-Konfigurationsdetails in die Anwendungseigenschaftendatei ein.

Fügen Sie für Benutzer von Eigenschaftendateien die folgenden Eigenschaften zu Ihrer Datei application.properties hinzu.

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

Yaml-Benutzer sollten der Datei application.yml die folgenden Eigenschaften hinzufügen.

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

Erstellen Sie jetzt eine Konfigurationsklasse, um eine DataSource und eine JdbcTemplate für mehrere Datenquellen zu erstellen.

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

Verdrahten Sie dann das JDBCTemplate-Objekt mithilfe der Annotation @Qualifier automatisch.

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

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