Spring Boot - Xử lý cơ sở dữ liệu
Spring Boot hỗ trợ rất tốt để tạo DataSource cho Database. Chúng ta không cần viết thêm bất kỳ mã nào để tạo một DataSource trong Spring Boot. Chỉ cần thêm các phụ thuộc và thực hiện chi tiết cấu hình là đủ để tạo Nguồn dữ liệu và kết nối Cơ sở dữ liệu.
Trong chương này, chúng ta sẽ sử dụng kết nối trình điều khiển Spring Boot JDBC để kết nối cơ sở dữ liệu.
Đầu tiên, chúng ta cần thêm phần phụ thuộc Spring Boot Starter JDBC vào tệp cấu hình xây dựng của chúng tôi.
Người dùng Maven có thể thêm các phần phụ thuộc sau vào tệp pom.xml.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
Người dùng Gradle có thể thêm các phần phụ thuộc sau vào tệp build.gradle.
compile('org.springframework.boot:spring-boot-starter-jdbc')
Kết nối với cơ sở dữ liệu H2
Để kết nối cơ sở dữ liệu H2, chúng ta cần thêm phần phụ thuộc cơ sở dữ liệu H2 vào tệp cấu hình bản dựng của chúng tôi.
Đối với người dùng Maven, hãy thêm phần phụ thuộc bên dưới vào tệp pom.xml của bạn.
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
</dependency>
Đối với người dùng Gradle, hãy thêm phần phụ thuộc bên dưới vào tệp build.gradle của bạn.
compile('com.h2database:h2')
Chúng ta cần tạo tệp schema.sql và tệp data.sql trong thư mục classpath src / main / resources để kết nối cơ sở dữ liệu H2.
Tệp schema.sql được cung cấp bên dưới.
CREATE TABLE PRODUCT (ID INT PRIMARY KEY, PRODUCT_NAME VARCHAR(25));
Tệp data.sql được đưa ra bên dưới.
INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (1,'Honey');
INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (2,'Almond');
Kết nối MySQL
Để kết nối cơ sở dữ liệu MySQL, chúng ta cần thêm phần phụ thuộc MySQL vào tệp cấu hình xây dựng của chúng tôi.
Đối với người dùng Maven, hãy thêm phần phụ thuộc sau vào tệp pom.xml của bạn.
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
Đối với người dùng Gradle, hãy thêm phần phụ thuộc sau vào tệp build.gradle của bạn.
compile('mysql:mysql-connector-java')
Bây giờ, tạo cơ sở dữ liệu và bảng trong MySQL như được hiển thị:
Đối với người dùng tệp thuộc tính, hãy thêm các thuộc tính sau vào tệp 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
Đối với người dùng YAML, hãy thêm các thuộc tính sau vào tệp 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
Kết nối Redis
Redis là một cơ sở dữ liệu mã nguồn mở được sử dụng để lưu trữ cấu trúc dữ liệu trong bộ nhớ. Để kết nối cơ sở dữ liệu Redis trong ứng dụng Spring Boot, chúng ta cần thêm phần phụ thuộc Redis vào tệp cấu hình bản dựng của mình.
Người dùng Maven nên thêm phần phụ thuộc sau vào tệp pom.xml của bạn.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-redis</artifactId>
</dependency>
Người dùng Gradle nên thêm phần phụ thuộc sau vào tệp build.gradle của bạn.
compile('org.springframework.boot:spring-boot-starter-data-redis')
Đối với kết nối Redis, chúng ta cần sử dụng RedisTemplate. Đối với RedisTemplate, chúng tôi cần cung cấp thông tin chi tiết về 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;
}
Bây giờ tự động nối lớp RedisTemplate và truy cập dữ liệu từ cơ sở dữ liệu Redis.
@Autowired
RedisTemplate<String, Object> redis;
Map<Object,Object> datalist = redis.opsForHash().entries(“Redis_code_index_key”);
JDBCTemplate
Để truy cập Cơ sở dữ liệu quan hệ bằng cách sử dụng JdbcTemplate trong ứng dụng Spring Boot, chúng ta cần thêm phần phụ thuộc Spring Boot Starter JDBC vào tệp cấu hình bản dựng của chúng tôi.
Sau đó, nếu bạn @ Không mong muốn lớp JdbcTemplate, Spring Boot sẽ tự động kết nối Cơ sở dữ liệu và đặt Nguồn dữ liệu cho đối tượng JdbcTemplate.
@Autowired
JdbcTemplate jdbcTemplate;
Collection<Map<String, Object>> rows = jdbc.queryForList("SELECT QUERY");
Chú thích @Repository phải được thêm vào tệp lớp. Chú thích @Repository được sử dụng để tạo kho cơ sở dữ liệu cho ứng dụng Spring Boot của bạn.
@Repository
public class ProductServiceDAO {
}
Nhiều nguồn dữ liệu
Chúng ta có thể giữ các Nguồn dữ liệu số 'n' trong một ứng dụng Spring Boot. Ví dụ đưa ra ở đây cho thấy cách tạo nhiều hơn 1 nguồn dữ liệu trong ứng dụng Spring Boot. Bây giờ, hãy thêm hai chi tiết cấu hình nguồn dữ liệu trong tệp thuộc tính ứng dụng.
Đối với người dùng tệp thuộc tính, hãy thêm các thuộc tính sau vào tệp application.properties của bạn.
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
Người dùng Yaml nên thêm các thuộc tính sau vào tệp application.yml của bạn.
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
Bây giờ, hãy tạo một lớp Cấu hình để tạo một DataSource và JdbcTemplate cho nhiều nguồn dữ liệu.
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);
}
}
Sau đó, tự động nối dây đối tượng JDBCTemplate bằng cách sử dụng chú thích @Qualifier.
@Qualifier("jdbcProductService")
@Autowired
JdbcTemplate jdbcTemplate;
@Qualifier("jdbcUserService")
@Autowired
JdbcTemplate jdbcTemplate;