SpringBoot之集成数据库

一、集成 MySQL 数据库

1.1 配置 MySQL

添加依赖

<dependencies>
    <!--Spring 数据库相关依赖-->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-data-jpa</artifactId>
	</dependency>
	<!--mysql 驱动依赖-->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<scope>runtime</scope>
	</dependency>
</dependencies>

设置配置文件

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?characterEncoding=utf8
    username: root
    password: sa000

1.2 测试数据库连接

添加测试依赖

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

在 test/java 目录下新建测试类

@SpringBootTest
public class DataBaseTest {

    @Autowired
    private DataSource dataSource;

    @Test
    public void testConnection() {
        try {
            Connection connection = dataSource.getConnection();
            Assert.assertNotNull(connection);
        } catch (SQLException e) {
            fail("数据库连接获取失败,错误原因:" + e);
        }
    }
}

执行测试，发现绿条说明测试通过。

1.3 设置连接池

SpringBoot 在我们引入 spring-boot-starter-jdbc或spring-boot-starter-data-jpa 依赖后就会默认启用连接池功能，它的连接池默认创建选择规则如下：

• 优先寻找创建 HikariCP 连接池

• 如果没有 HikariCP 连接池，会查找创建 Tomcat

• 如果没有 Tomcat 连接池，会查找创建 dbcp

• 如果没有 dbcp 连接池，会查找创建 dbcp2

• 也可以使用 spring.datasource.type 属性指定连接池类型

  spring.datasource.type= com.zaxxer.hikari.HikariDataSource
  

我们来通过一个测试方法验证下：

@SpringBootTest
public class DataBaseTest {

    @Autowired
    private DataSource dataSource;

    @Test
    public void testDataSourceType(){
        Assert.assertEquals(HikariDataSource.class,dataSource.getClass());
    }
}

执行测试，发现绿条说明测试通过。

常用连接池配置如下：

#验证连接的有效性
spring.datasource.primary.test-while-idle=true
#获取连接时候验证，会影响性能
spring.datasource.primary.test-on-borrow=false
#在连接归还到连接池时是否测试该连接
spring.datasource.primary.test-on-return=false
spring.datasource.primary.validation-query=SELECT 1 FROM DUAL
#空闲连接回收的时间间隔，与test-while-idle一起使用，设置5分钟
spring.datasource.primary.time-between-eviction-runs-millis=300000
#连接池空闲连接的有效时间 ，设置30分钟
spring.datasource.primary.min-evictable-idle-time-millis=1800000
spring.datasource.primary.initial-size=5
#指定连接池中最大的活跃连接数.
spring.datasource.primary.max-active=50
#指定连接池等待连接返回的最大等待时间，毫秒单位.
spring.datasource.primary.max-wait=60000
#指定必须保持连接的最小值
spring.datasource.primary.min-idle=5

更多配置请参考 SprignBoot文档。

1.4 JDBC 使用

配置好数据库之后，我们就来使用一下最基本的数据库操作。

在数据库 test 新建一个用户表：

CREATE TABLE `sys_user` (
  `user_id` int(21) NOT NULL COMMENT '用户编码',
  `user_name` varchar(50) DEFAULT NULL COMMENT '用户名',
  `age` int(3) DEFAULT NULL COMMENT '年龄',
  `email` varchar(100) DEFAULT NULL COMMENT '邮箱',
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

在 test/java 目录下新建测试类

@SpringBootTest
public class JdbcTest {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Test
    public void test() {
        delete();
        Assert.assertEquals(0,count());
        add();
        Assert.assertEquals(1,count());
    }

    private int count() {
        String sql = "select count(user_id) from sys_user ";
        Integer result = jdbcTemplate.queryForObject(sql, Integer.class);
        return result;
    }

    private void add() {
        String sql = "insert into sys_user " +
                "values('1','marklogzhu','26','marklogzhu@163.com')";
        jdbcTemplate.execute(sql);
    }

    private void delete() {
        String sql = "delete from sys_user ";
        jdbcTemplate.execute(sql);
    }

}

执行测试，发现绿条说明测试通过。

二、集成 Redis 数据库

2.1 配置 Redis

添加依赖

<dependencies>
	......
	<!--Spring redis 依赖-->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-data-redis</artifactId>
	</dependency>
	<!--redis 连接池依赖-->
	<dependency>
		<groupId>org.apache.commons</groupId>
		<artifactId>commons-pool2</artifactId>
		<version>2.7.0</version>
	</dependency>
</dependencies>

设置配置文件

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    # 连接超时时间
    timeout: 1000ms
    jedis:
      pool:
        # 最大连接数
        max-active: 8
        # 最大阻塞等待时间(负数表示没限制)
        max-wait: -1ms
        # 最大空闲
        max-idle: 8
        # 最小空闲
        min-idle: 0

测试

@SpringBootTest
public class RedisTest {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    public void testSimpleValue(){
        String key = "name";
        String name ="MarkLogZhu";
        stringRedisTemplate.opsForValue().set(key,name);
        String result = stringRedisTemplate.opsForValue().get(key);
        Assert.assertEquals(name,result);
    }

}

执行测试，发现绿条说明测试通过。

2.2 实现序列化功能

添加依赖

<dependencies>
	......
	<!--JSON工具类依赖-->
	<dependency>
		<groupId>com.google.code.gson</groupId>
		<artifactId>gson</artifactId>
		<version>2.8.6</version>
	</dependency>
</dependencies>

设置序列化功能

@Configuration
public class RedisConfig {

    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(
            RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer());
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    @Bean
    public Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer() {
        final Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(
                Object.class);
        final ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().build();
        objectMapper.disable(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES);
        objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        return jackson2JsonRedisSerializer;
    }

}

测试

@SpringBootTest
public class RedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testObjectValue(){
        String key = "obj";
        SysUser user = new SysUser(1,"MarkLogZhu");
        redisTemplate.opsForValue().set(key,user);
        SysUser result = (SysUser)redisTemplate.opsForValue().get(key);
        Assert.assertEquals(user,result);
    }

}

执行测试，发现绿条说明测试通过。