Spring Boot - Penanganan Database

Spring Boot memberikan dukungan yang sangat baik untuk membuat Sumber Data untuk Database. Kita tidak perlu menulis kode tambahan untuk membuat Sumber Data di Spring Boot. Hanya menambahkan dependensi dan melakukan detail konfigurasi sudah cukup untuk membuat Sumber Data dan menghubungkan Database.

Dalam bab ini, kita akan menggunakan koneksi driver JDBC Spring Boot untuk menghubungkan database.

Pertama, kita perlu menambahkan dependensi JDBC Spring Boot Starter di file konfigurasi build kita.

Pengguna Maven dapat menambahkan dependensi berikut di file pom.xml.

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

Pengguna Gradle dapat menambahkan dependensi berikut dalam file build.gradle.

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

Hubungkan ke database H2

Untuk menghubungkan database H2, kita perlu menambahkan dependensi database H2 di file konfigurasi build kita.

Untuk pengguna Maven, tambahkan dependensi di bawah ini ke file pom.xml Anda.

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

Untuk pengguna Gradle, tambahkan dependensi di bawah ini dalam file build.gradle Anda.

compile('com.h2database:h2')

Kita perlu membuat file schema.sql dan file data.sql di bawah direktori classpath src / main / resources untuk menghubungkan database H2.

File schema.sql diberikan di bawah ini.

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

File data.sql diberikan di bawah ini.

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

Hubungkan MySQL

Untuk menghubungkan database MySQL, kita perlu menambahkan dependensi MySQL ke file konfigurasi build kita.

Untuk pengguna Maven, tambahkan dependensi berikut di file pom.xml Anda.

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

Untuk pengguna Gradle, tambahkan dependensi berikut di file build.gradle Anda.

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

Sekarang, buat database dan tabel di MySQL seperti yang ditunjukkan -

Untuk pengguna file properti, tambahkan properti berikut di 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

Untuk pengguna YAML, tambahkan properti berikut di 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

Hubungkan Redis

Redis adalah database open source yang digunakan untuk menyimpan struktur data dalam memori. Untuk menghubungkan database Redis di aplikasi Spring Boot, kita perlu menambahkan dependensi Redis di file konfigurasi build kita.

Pengguna Maven harus menambahkan dependensi berikut di file pom.xml Anda.

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

Pengguna Gradle harus menambahkan dependensi berikut dalam file build.gradle Anda.

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

Untuk koneksi Redis, kita perlu menggunakan RedisTemplate. Untuk RedisTemplate, kami perlu memberikan detail 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;
}

Sekarang transfer otomatis kelas RedisTemplate dan akses data dari database Redis.

@Autowired

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

Template JDBCT

Untuk mengakses Relational Database dengan menggunakan JdbcTemplate di aplikasi Spring Boot, kita perlu menambahkan dependensi JDBC Spring Boot Starter di file konfigurasi build kita.

Kemudian, jika Anda @Autowired kelas JdbcTemplate, Spring Boot secara otomatis menghubungkan Database dan menetapkan Sumber Data untuk objek JdbcTemplate.

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

Anotasi @Repository harus ditambahkan ke dalam file kelas. Anotasi @Repositori digunakan untuk membuat repositori database untuk aplikasi Spring Boot Anda.

@Repository
public class ProductServiceDAO {
}

Beberapa Sumber Data

Kita dapat menyimpan 'n' number Datasources dalam satu aplikasi Spring Boot. Contoh yang diberikan di sini menunjukkan cara membuat lebih dari 1 sumber data di aplikasi Spring Boot. Sekarang, tambahkan dua detail konfigurasi sumber data di file properti aplikasi.

Untuk pengguna file properti, tambahkan properti berikut ke dalam file application.properties Anda.

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

Pengguna Yaml harus menambahkan properti berikut di file application.yml Anda.

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

Sekarang, buat kelas Konfigurasi untuk membuat DataSource dan JdbcTemplate untuk beberapa sumber data.

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

Kemudian, kawat otomatis objek template JDBCT dengan menggunakan anotasi @Qualifier.

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

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