第二章 SpringBoot快速开发框架 - Mysql数据源配置

作者简介：
🌹 作者：暗夜91
🤟 个人主页：暗夜91的主页
📝 如果感觉文章写的还有点帮助，请帮忙点个关注，我会持续输出高质量技术博文。

---

专栏文章:
1、集成Swagger，生成API文档
2、Mysql数据源配置
3、集成Redis
4、Spring Security + JWT实现登录权限认证
5、跨域配置

专栏源码：
针对该专栏功能，对源码进行整理，可以直接下载运行。
源码下载请移步：SpringBoot快速开发框架

---

一、数据源配置

这里针对MySQL数据库，通过JPA和Jdbc对数据库进行 *** 作。

1、集成方法 （1）引入依赖

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

（2）在application.yml中配置数据库连接

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/framework?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2b8
    password: Abc,123.
    username: root
    driver-class-name: com.mysql.cj.jdbc.Driver
    hikari:
      max-lifetime: 660000
      maximum-pool-size: 100
      minimum-idle: 10
      idle-timeout: 600000
      connection-timeout: 30000
      connection-test-query: SELECT 1
  jpa:
    hibernate:
      ddl-auto: update
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect
        format_sql: true
    show-sql: true
    open-in-view: false

针对MySQL单数据源的配置到这里就完成了，在业务模块可以通过JPA和Jdbctemplate对数据库进行 *** 作了。

2、连接池说明

数据库连接池用来管理、分配和释放数据库连接，允许服务重复使用一个现有的数据库连接，极大的提高了对数据库 *** 作的性能。

在上面的配置中，使用的是SpringBoot默认的HikariCP连接池，是一个高性能的JDBC连接池，基于BoneCP做了不少的改进和优化，号称“史上最快连接池”。

HikariCP速度快的原因：

1.字节码更加精简，所以可以加载更多代码到缓存。

2.实现了一个无锁的集合类型，来减少并发造成的资源竞争。

3.使用了自定义的数组类型，相对与ArrayList极大地提升了性能。

4.针对CPU的时间片算法进行优化，尽可能在一个时间片里面完成各种 *** 作。

HikariCP常用配置：

ame	描述	构造器默认值	默认配置validate之后的值	validate重置
autoCommit	自动提交从池中返回的连接	TRUE	TRUE	–
connectionTimeout	等待来自池的连接的最大毫秒数	SECONDS.toMillis(30) = 30000	30000	如果小于250毫秒，则被重置回30秒
idleTimeout	连接允许在池中闲置的最长时间	MINUTES.toMillis(10) = 600000	600000	如果idleTimeout+1秒>maxLifetime 且 maxLifetime>0，则会被重置为0（代表永远不会退出）；如果idleTimeout!=0且小于10秒，则会被重置为10秒
maxLifetime	池中连接最长生命周期	MINUTES.toMillis(30) = 1800000	1800000	如果不等于0且小于30秒则会被重置回30分钟
connectionTestQuery	如果您的驱动程序支持JDBC4，我们强烈建议您不要设置此属性	null	null	–
minimumIdle	池中维护的最小空闲连接数	-1	10	minIdle<0或者minIdle>maxPoolSize,则被重置为maxPoolSize
maximumPoolSize	池中最大连接数，包括闲置和使用中的连接	-1	10	如果maxPoolSize小于1，则会被重置。当minIdle<=0被重置为DEFAULT_POOL_SIZE则为10;如果minIdle>0则重置为minIdle的值
metricRegistry	该属性允许您指定一个 Codahale / Dropwizard MetricRegistry 的实例，供池使用以记录各种指标	null	null	–
healthCheckRegistry	该属性允许您指定池使用的Codahale / Dropwizard HealthCheckRegistry的实例来报告当前健康信息	null	null	–
poolName	连接池的用户定义名称，主要出现在日志记录和JMX管理控制台中以识别池和池配置	null	HikariPool-1	–
initializationFailTimeout	如果池无法成功初始化连接，则此属性控制池是否将 fail fast	1	1	–
isolateInternalQueries	是否在其自己的事务中隔离内部池查询，例如连接活动测试	FALSE	FALSE	–
allowPoolSuspension	控制池是否可以通过JMX暂停和恢复	FALSE	FALSE	–
readOnly	从池中获取的连接是否默认处于只读模式	FALSE	FALSE	–
registerMbeans	是否注册JMX管理Bean（MBeans）	FALSE	FALSE	–
catalog	为支持 catalog 概念的数据库设置默认 catalog	driver default	null	–
connectionInitSql	该属性设置一个SQL语句，在将每个新连接创建后，将其添加到池中之前执行该语句。	null	null	–
driverClassName	HikariCP将尝试通过仅基于jdbcUrl的DriverManager解析驱动程序，但对于一些较旧的驱动程序，还必须指定driverClassName	null	null	–
transactionIsolation	控制从池返回的连接的默认事务隔离级别	null	null	–
validationTimeout	连接将被测试活动的最大时间量	SECONDS.toMillis(5) = 5000	5000	如果小于250毫秒，则会被重置回5秒
leakDetectionThreshold	记录消息之前连接可能离开池的时间量，表示可能的连接泄漏	0	0	如果大于0且不是单元测试，则进一步判断：(leakDetectionThreshold < SECONDS.toMillis(2) or (leakDetectionThreshold > maxLifetime && maxLifetime > 0)，会被重置为0 . 即如果要生效则必须>0，而且不能小于2秒，而且当maxLifetime > 0时不能大于maxLifetime
dataSource	这个属性允许你直接设置数据源的实例被池包装，而不是让HikariCP通过反射来构造它	null	null	–
schema	该属性为支持模式概念的数据库设置默认模式	driver default	null	–
threadFactory	此属性允许您设置将用于创建池使用的所有线程的java.util.concurrent.ThreadFactory的实例。	null	null	–
scheduledExecutor	此属性允许您设置将用于各种内部计划任务的java.util.concurrent.ScheduledExecutorService实例	null	null	–

二、集成Redis

本项目使用Redis作为服务的缓存管理，用来存储用户登录的token及相关的用户信息。

Redis相关知识这里不做太多赘述，如需学习Redis相关的知识，可以关注本人的另一篇专栏：
Redis技术学习及开发运维

1、集成方法 （1）引入依赖

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-data-redisartifactId>
dependency>

（2）添加Redis配置文件

package com.lll.framework.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    private RedisSerializer<Object> valueSerializer() {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        return jackson2JsonRedisSerializer;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        // 配置序列化
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        RedisCacheConfiguration redisCacheConfiguration =
                config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer((valueSerializer())));

        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(redisCacheConfiguration)
                .build();
        return cacheManager;
    }
}

（3）封装Redis工具类

package com.reach.dv.common.service;

import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @ClassName RedisTemplateService
 * @Date 2019/5/16
 * @Version 1.0
 **/
@Service
public class RedisTemplateService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 数据写入redis
     *
     * @param key
     * @param value
     * @param 
     * @return
     */
    public <T> boolean set(String key, T value) {
        String val = beanToString(value);
        if (val == null || val.length() <= 0) {
            return false;
        }
        redisTemplate.opsForValue().set(key, val);
        return true;
    }

    /**
     * 写入hash类型的数据
     * @param key
     * @param value
     * @return
     */
    public boolean set(String key, Map<String,Object> value) {
        redisTemplate.opsForHash().putAll(key,value);
        return true;
    }

    /**
     * 数据写入redis
     * @param key
     * @param value
     * @param timeout 超时时长(S) >0时设置
     * @param 
     * @return
     */
    public <T> boolean set(String key, T value,int timeout) {
        String val = beanToString(value);
        if (val == null || val.length() <= 0) {
            return false;
        }
        redisTemplate.opsForValue().set(key, val);
        if (timeout>0){
            redisTemplate.expire(key,timeout, TimeUnit.SECONDS);
        }
        return true;
    }

    private <T> String beanToString(T value) {
        String result = "";
        if (value == null) {
            return null;
        }
        Class clazz = value.getClass();
        if (clazz == int.class || clazz == Integer.class) {
            result = String.valueOf(value);
        } else if (clazz == long.class || clazz == Long.class) {
            result = String.valueOf(value);
        } else if (clazz == String.class) {
            result = String.valueOf(value);
        } else {
            result = JSON.toJSONString(value);
        }
        return result;
    }

    /**
     * 查询数据，返回序列化数据
     * @param key
     * @param 
     * @return
     */
    public <T> T get(String key, Class<T> clazz) {
        String value = redisTemplate.opsForValue().get(key);
        if(key.equals("vin")){
            value = value.toUpperCase();
        }
        return stringToBean(value, clazz);
    }

    /**
     * 查询hash数据，返回序列化数据
     * @param key
     * @param mkey
     * @param clazz
     * @param 
     * @return
     */
    public <T> T get(String key,String mkey, Class<T> clazz){
        String value = String.valueOf(redisTemplate.opsForHash().get(key,mkey));
        if(key.equals("vin")){
            value = value.toUpperCase();
        }
        return stringToBean(value, clazz);
    }

    private <T> T stringToBean(String value, Class<T> clazz) {
        T result;
        if (value == null || value.length() <= 0 || clazz == null) {
            return null;
        }
        if (clazz == int.class || clazz == Integer.class) {
            result = (T) Integer.valueOf(value);
        } else if (clazz == long.class || clazz == Long.class) {
            result = (T) Long.valueOf(value);
        } else if (clazz == String.class) {
            result = (T) value;
        } else {
            result = JSON.parseObject(value,clazz);
//            result = JSON.toJavaObject(value,clazz);
        }
        return result;
    }

    public boolean delete(String key){
        redisTemplate.delete(key);
        return true;
    }

    public Set<String> getKeys(String prefix){
        Set<String> keys = redisTemplate.keys(prefix);
        return keys;
    }

    /**
     * 判断key是否存在
     * @param key
     * @return
     */
    public boolean hasKey(String key){
        return redisTemplate.hasKey(key);
    }

    /**
     * 更新key的过期时间
     * @param key
     * @param newTimeOut
     * @return
     */
    public Boolean expireKey(String key,int newTimeOut){
        return redisTemplate.expire(key, newTimeOut, TimeUnit.SECONDS);
    }
}

到这里，我们就完成了对Redis的集成，可以在业务模块通过Redis的工具类对Redis进行 *** 作了。