动态数据源配置

一、动态数据源上下文

package tv.zhongchi.base.common.datasource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @ClassName DBContextHolder
 * @Author ZhangRF
 * @CreateDate 2020/6/17
 * @Decription 动态数据源上下文
 */
public class DBContextHolder {
    private final static Logger log = LoggerFactory.getLogger(DBContextHolder.class);
    // 对当前线程的操作-线程安全的
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();

    // 调用此方法，切换数据源
    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
    }

    // 获取数据源
    public static String getDataSource() {
        return contextHolder.get();
    }

    // 删除数据源
    public static void clearDataSource() {
        contextHolder.remove();
    }

}

二、动态数据源设置DruidDBConfig 

package tv.zhongchi.base.common.datasource;

import com.alibaba.druid.pool.DruidDataSource;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldStrategy;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.autoconfigure.ConfigurationCustomizer;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.config.GlobalConfig;
import com.baomidou.mybatisplus.extension.MybatisMapWrapperFactory;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import org.apache.ibatis.logging.stdout.StdOutImpl;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.type.JdbcType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import tv.zhongchi.base.common.handler.MyMetaObjectHandler;

import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @ClassName DruidDBConfig
 * @Author ZhangRF
 * @CreateDate 2020/6/17
 * @Decription DruidDBConfig类被@Configuration标注，用作配置信息； DataSource对象被@Bean声明，为Spring容器所管理，表示这里定义的DataSource将覆盖其他来源的DataSource。
 */
@Configuration
@EnableTransactionManagement
public class DruidDBConfig {
    private final Logger log = LoggerFactory.getLogger(getClass());

    // adi数据库连接信息
    @Value("${spring.datasource.url}")
    private String dbUrl;
    @Value("${spring.datasource.username}")
    private String username;
    @Value("${spring.datasource.password}")
    private String password;
    @Value("${spring.datasource.driverClassName}")
    private String driverClassName;
    // 连接池连接信息
    @Value("${spring.datasource.initialSize}")
    private int initialSize;
    @Value("${spring.datasource.minIdle}")
    private int minIdle;
    @Value("${spring.datasource.maxActive}")
    private int maxActive;
    @Value("${spring.datasource.maxWait}")
    private int maxWait;
    @Value("${spring.profiles.active}")
    private String profile;

    @Bean // 声明其为Bean实例
    @Primary // 在同样的DataSource中，首先使用被标注的DataSource
    @Qualifier("adiDataSource")
    public DataSource dataSource() throws SQLException {
        DruidDataSource datasource = new DruidDataSource();
        // 基础连接信息
        datasource.setUrl(this.dbUrl);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);
        // 连接池连接信息
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource.setPoolPreparedStatements(true); //是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
        datasource.setMaxPoolPreparedStatementPerConnectionSize(50);
        datasource.setConnectionProperties("oracle.net.CONNECT_TIMEOUT=6000;oracle.jdbc.ReadTimeout=60000");//对于耗时长的查询sql，会受限于ReadTimeout的控制，单位毫秒
        datasource.setTestOnBorrow(true); //申请连接时执行validationQuery检测连接是否有效，这里建议配置为TRUE，防止取到的连接不可用
        datasource.setTestWhileIdle(true);//建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
        String validationQuery = "select 1 from dual";
        datasource.setValidationQuery(validationQuery); //用来检测连接是否有效的sql，要求是一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。
        datasource.setFilters("stat,wall");//属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall
        datasource.setTimeBetweenEvictionRunsMillis(60000); //配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
        datasource.setMinEvictableIdleTimeMillis(180000); //配置一个连接在池中最小生存的时间，单位是毫秒，这里配置为3分钟180000
        datasource.setKeepAlive(true); //打开druid.keepAlive之后，当连接池空闲时，池中的minIdle数量以内的连接，空闲时间超过minEvictableIdleTimeMillis，则会执行keepAlive操作，即执行druid.validationQuery指定的查询SQL，一般为select * from dual，只要minEvictableIdleTimeMillis设置的小于防火墙切断连接时间，就可以保证当连接空闲时自动做保活检测，不会被防火墙切断
        datasource.setRemoveAbandoned(true); //是否移除泄露的连接/超过时间限制是否回收。
        datasource.setRemoveAbandonedTimeout(3600); //泄露连接的定义时间(要超过最大事务的处理时间)；单位为秒。这里配置为1小时
        datasource.setLogAbandoned(true); ////移除泄露连接发生是是否记录日志
        return datasource;
    }

    @Bean(name = "dynamicDataSource")
    @Qualifier("dynamicDataSource")
    public DynamicDataSource dynamicDataSource() throws SQLException {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        //配置缺省的数据源
        dynamicDataSource.setDefaultTargetDataSource(dataSource());
        Map<Object, Object> targetDataSources = new HashMap<Object, Object>(1);
        targetDataSources.put("adiDataSource", dataSource());
        dynamicDataSource.setTargetDataSources(targetDataSources);
        return dynamicDataSource;
    }


    /**
     * 注入驼峰命名
     *
     * @return
     */
    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return i -> i.setObjectWrapperFactory(new MybatisMapWrapperFactory());
    }

    @Bean
    public EasySqlInjector easySqlInjector() {
        return new EasySqlInjector();
    }

    /**
     * 动态据源事务
     *
     * @return
     */
    @Bean
    public PlatformTransactionManager transactionManager() {
        try {
            return new DataSourceTransactionManager(dynamicDataSource());
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }

    /**
     * 动态数据源切换配置
     *
     * @return
     * @throws Exception
     */
    @Bean("sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();
        sqlSessionFactory.setDataSource(dynamicDataSource());
        sqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:/mapper/**/*.xml"));
        sqlSessionFactory.setTypeAliasesPackage("tv.zhongchi.*.*.po");

        MybatisConfiguration configuration = new MybatisConfiguration();
        configuration.setJdbcTypeForNull(JdbcType.NULL);
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setCacheEnabled(false);
        if ("test".equals(profile) || "dev".equals(profile)) {
            configuration.setLogImpl(StdOutImpl.class);
        }
        sqlSessionFactory.setConfiguration(configuration);

        //全局配置
        GlobalConfig globalConfig = new GlobalConfig();
        GlobalConfig.DbConfig dbConfig = new GlobalConfig.DbConfig();
        dbConfig.setIdType(IdType.AUTO);
        dbConfig.setTableUnderline(true);
        dbConfig.setCapitalMode(false);
        dbConfig.setUpdateStrategy(FieldStrategy.NOT_EMPTY);
        globalConfig.setDbConfig(dbConfig);
        globalConfig.setSqlInjector(easySqlInjector());

        globalConfig.setMetaObjectHandler(new MyMetaObjectHandler());
        sqlSessionFactory.setGlobalConfig(globalConfig);

        //分页插件
        List<Interceptor> interceptors = new ArrayList<>();
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置数据库
        paginationInterceptor.setDialectType(DbType.MYSQL.getDb());
        interceptors.add(paginationInterceptor);
        sqlSessionFactory.setPlugins(interceptors.toArray(new Interceptor[0]));
        return sqlSessionFactory.getObject();
    }

}

三、 动态数据源

package tv.zhongchi.base.common.datasource;


import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.stat.DruidDataSourceStatManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.util.StringUtils;
import tv.zhongchi.common.exception.BizException;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;


/**
 * @ClassName DynamicDataSource
 * @Author ZhangRF
 * @CreateDate 2020/6/17
 * @Decription 动态数据源
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    private final Logger log = LoggerFactory.getLogger(getClass());
    private static Map<Object, Object> dynamicTargetDataSources = new ConcurrentHashMap<>();
    private static Map<Object, DynamicDataSourceTimer> timerMap = new ConcurrentHashMap<>();

    /**
     * 通过定时任务周期性清除不使用的数据源
     */
    @Scheduled(initialDelay = 10 * 60 * 1000, fixedRate = 10 * 60 * 1000)
    public void clearTask() {
        // 遍历timetMap，判断
        clearIdleDDS();
    }

    /**
     * 设置当前数据源
     *
     * @return
     */
    @Override
    protected Object determineCurrentLookupKey() {
        String datasource = DBContextHolder.getDataSource();
        if (datasource != null) {
            updateTimer(datasource);
        } else {
            datasource = "adiDataSource";
        }

        return datasource;
    }

    @Override
    public void setTargetDataSources(Map<Object, Object> targetDataSources) {

        super.setTargetDataSources(targetDataSources);
        this.dynamicTargetDataSources = targetDataSources;
        targetDataSources.forEach((k, v) -> {
            DruidDataSource dataSource = (DruidDataSource) v;
            timerMap.put(k, new DynamicDataSourceTimer(dataSource));
        });

    }

    /**
     * 动态增加数据源
     *
     * @param dataSourceVO
     * @return
     */
    public synchronized boolean addDataSource(DataSourceVO dataSourceVO) throws Exception {
        try {
            Connection connection = null;
            try { // 排除连接不上的错误
                Class.forName(dataSourceVO.getDatasourceDriver());
                // 相当于连接数据库
                connection = DriverManager.getConnection(dataSourceVO.getDatasourceUrl(), dataSourceVO.getDatasourceUsername(), dataSourceVO.getDatasourcePassword());

            } catch (Exception e) {
                throw new BizException(401L, "数据源异常，请联系管理员");
            } finally {
                if (connection != null && !connection.isClosed()) {
                    connection.close();
                }
            }
            Map<Object, Object> dynamicTargetDataSources2 = this.dynamicTargetDataSources;
            if (dynamicTargetDataSources2.containsKey(String.valueOf(dataSourceVO.getTenantId()))) {
                return true;
            }
            //添加数据源
            Long tenantId = dataSourceVO.getTenantId();
            if (StringUtils.isEmpty(tenantId)) {
                throw new BizException(401L, "数据源异常，请联系管理员");
            }
            DruidDataSource druidDataSource = new DruidDataSource();
            druidDataSource.setName(String.valueOf(dataSourceVO.getTenantId()));
            druidDataSource.setDriverClassName(dataSourceVO.getDatasourceDriver());
            druidDataSource.setUrl(dataSourceVO.getDatasourceUrl());
            druidDataSource.setUsername(dataSourceVO.getDatasourceUsername());
            druidDataSource.setPassword(dataSourceVO.getDatasourcePassword());
            druidDataSource.setTestOnBorrow(true); //申请连接时执行validationQuery检测连接是否有效，这里建议配置为TRUE，防止取到的连接不可用
            druidDataSource.setTestWhileIdle(true);//建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
            druidDataSource.setFilters("stat");//属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall
            druidDataSource.setTimeBetweenEvictionRunsMillis(4000); //配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
            druidDataSource.setMinEvictableIdleTimeMillis(2000); //配置一个连接在池中最小生存的时间，单位是毫秒，
            druidDataSource.setKeepAlive(true); //打开druid.keepAlive之后，当连接池空闲时，池中的minIdle数量以内的连接，空闲时间超过minEvictableIdleTimeMillis，则会执行keepAlive操作，即执行druid.validationQuery指定的查询SQL，一般为select * from dual，只要minEvictableIdleTimeMillis设置的小于防火墙切断连接时间，就可以保证当连接空闲时自动做保活检测，不会被防火墙切断
            druidDataSource.setRemoveAbandoned(true); //是否移除泄露的连接/超过时间限制是否回收。
            druidDataSource.setRemoveAbandonedTimeout(600); //泄露连接的定义时间(要超过最大事务的处理时间)；单位为秒。这里配置为10分钟
            druidDataSource.setLogAbandoned(true); ////移除泄露连接发生是是否记录日志
            druidDataSource.init();
            this.dynamicTargetDataSources.put(tenantId, druidDataSource);
            this.setTargetDataSources(this.dynamicTargetDataSources);// 将map赋值给父类的TargetDataSources
            super.afterPropertiesSet();// 将TargetDataSources中的连接信息放入resolvedDataSources管理
            log.info(tenantId + "数据源初始化成功");
            return true;
        } catch (Exception e) {
            log.error(e + "");
            throw new BizException(401L, "数据源异常，请联系管理员");
        }
    }

    // 删除数据源
    public boolean delDatasources(String datasourceid) {
        Map<Object, Object> dynamicTargetDataSources2 = this.dynamicTargetDataSources;
        if (dynamicTargetDataSources2.containsKey(datasourceid)) {
            Set<DruidDataSource> druidDataSourceInstances = DruidDataSourceStatManager.getDruidDataSourceInstances();
            for (DruidDataSource l : druidDataSourceInstances) {
                if (datasourceid.equals(l.getName())) {
                    dynamicTargetDataSources2.remove(datasourceid);
                    DruidDataSourceStatManager.removeDataSource(l);
                    setTargetDataSources(dynamicTargetDataSources2);// 将map赋值给父类的TargetDataSources
                    super.afterPropertiesSet();// 将TargetDataSources中的连接信息放入resolvedDataSources管理
                    return true;
                }
            }
            return false;
        } else {
            return false;
        }
    }

    // 测试数据源连接是否有效
    public boolean testDatasource(DataSourceVO dataSourceVO) throws SQLException {
        Connection connection = null;
        try { // 排除连接不上的错误
            Class.forName(dataSourceVO.getDatasourceDriver());
            // 相当于连接数据库
            connection = DriverManager.getConnection(dataSourceVO.getDatasourceUrl(), dataSourceVO.getDatasourceUsername(), dataSourceVO.getDatasourcePassword());
            return true;
        } catch (Exception e) {
            return false;
        } finally {
            if (connection != null && !connection.isClosed()) {
                connection.close();
            }
        }
    }

    /**
     * 创建数据源
     *
     * @param dataSourceVO
     * @throws Exception
     */
    public void createDataSourceWithCheck(DataSourceVO dataSourceVO) throws Exception {
        String datasourceId = String.valueOf(dataSourceVO.getTenantId());
        DBContextHolder.setDataSource(datasourceId);
        Map<Object, Object> dynamicTargetDataSources2 = this.dynamicTargetDataSources;
        if (!dynamicTargetDataSources2.containsKey(datasourceId)) {
            //测试连接
            if (!testDatasource(dataSourceVO)) {
                this.addDataSource(dataSourceVO);
            }
        }

    }

    private void clearIdleDDS() {
        timerMap.forEach((k, v) -> {
            if (v.checkAndClose()) {
                delDatasources(k.toString());
            }
        });
    }

    private void updateTimer(String lookupKey) {
        // 更新时间戳
        DynamicDataSourceTimer timer = timerMap.get(lookupKey);
        if (timer != null) {
            timer.refreshTime();
        }
    }

}

四、动态数据源切面拦截

package tv.zhongchi.base.common.datasource;

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.AuthorizationException;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.BeanUtils;
import org.springframework.core.annotation.Order;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import tv.zhongchi.base.user.mapper.DatasourceMapper;
import tv.zhongchi.base.user.po.DatasourcePO;
import tv.zhongchi.common.constants.RedisConstants;
import tv.zhongchi.common.enums.ClientEnum;
import tv.zhongchi.common.exception.BizException;
import tv.zhongchi.common.util.HttpRequestUtil;
import tv.zhongchi.common.util.JsonUtil;
import tv.zhongchi.common.util.JwtUtil;
import tv.zhongchi.common.util.StringUtil;
import tv.zhongchi.common.vo.ResultVO;
import tv.zhongchi.common.vo.query.EConditionOperator;
import tv.zhongchi.common.vo.query.QueryConditions;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.concurrent.TimeUnit;

/**
 * @ClassName DynamicDataSource
 * @Author ZhangRF
 * @CreateDate 2020/6/17
 * @Decription 动态数据源切面拦截
 */
@Aspect
@Component
@Order(1)
@Slf4j
@RestControllerAdvice
public class DynamicDataSourceAspect {
    @Resource
    private DynamicDataSource dynamicDataSource;
    @Resource
    private DatasourceMapper datasourceMapper;
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    private static final String TENANTID = "tenantId";

    @Around("execution(* tv.zhongchi.*.*..controller..*(..)) || execution(* tv.zhongchi.*.*.*(..))")
    public Object doAround(ProceedingJoinPoint jp) throws Throwable {
        ServletRequestAttributes sra = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        Object result = null;
        ResultVO resultVO = ResultVO.fail();
        String key = RedisConstants.DATA_SOURCE_INFO_KEY_PREFIX;
        try {
            HttpServletRequest request = sra.getRequest();
            HttpSession session = sra.getRequest().getSession(true);
            String tenantId = (String) session.getAttribute("tenantId");
            if (StringUtil.isEmpty(tenantId)) {
                tenantId = request.getParameter("tenantId");
            }

            if (!StringUtil.isEmpty(tenantId) && !tenantId.equals(String.valueOf(0))) {
                //创建数据源
                key = key + tenantId;
                DataSourceVO dataSourceVO = (DataSourceVO) redisTemplate.opsForValue().get(key);
                if (dataSourceVO == null || dataSourceVO.getTenantId() == null) {
                    QueryConditions<DatasourcePO> datasourcePOQueryConditions = new QueryConditions<>();
                    datasourcePOQueryConditions.addCondition("tenant_id", EConditionOperator.EQULS, tenantId);
                    DatasourcePO datasourcePO = datasourceMapper.selectOne(datasourcePOQueryConditions.getQueryWrapper());
                    if (datasourcePO == null || datasourcePO.getId() == null) {
                        resultVO.setCode(401);
                        resultVO.setMessage("数据源不存在，请重新登陆");
                        result = resultVO;
                        return result;
                    } else {
                        dataSourceVO = new DataSourceVO();
                        BeanUtils.copyProperties(datasourcePO, dataSourceVO);
                        redisTemplate.opsForValue().set(key + datasourcePO.getTenantId(), dataSourceVO, 1, TimeUnit.DAYS);
                    }
                }

                try {
                    dynamicDataSource.createDataSourceWithCheck(dataSourceVO);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                //切换数据源
                DBContextHolder.setDataSource(String.valueOf(dataSourceVO.getTenantId()));
                result = jp.proceed();
            } else {
                try {
                    //根据token查询用户租户Id
                    String token = HttpRequestUtil.getToken();
                    String loginCode = JwtUtil.getLoginCode(token);
                    ClientEnum clientEnum = JwtUtil.getClientEnum(token);
                    Object o = redisTemplate.opsForValue().get(RedisConstants.USER_LOGIN_TOKEN_KEY_PREFIX + loginCode + clientEnum);
                    String s = JsonUtil.toJSONString(o);
                    JSONObject parse = (JSONObject) JSONObject.parse(s);
                    tenantId = parse.getString("tenantId");
                } catch (Exception e) {
                }

                if (StringUtils.isEmpty(tenantId) || tenantId.equals(String.valueOf(0)) || tenantId.equals(String.valueOf(1))) {
                    //当租户Id为空时或者为0，不切换数据源
                    result = jp.proceed();
                } else {
                    //创建数据源
                    key = key + tenantId;
                    DataSourceVO dataSourceVO = (DataSourceVO) redisTemplate.opsForValue().get(key);
                    if (dataSourceVO == null || dataSourceVO.getTenantId() == null) {
                        QueryConditions<DatasourcePO> datasourcePOQueryConditions = new QueryConditions<>();
                        datasourcePOQueryConditions.addCondition("tenant_id", EConditionOperator.EQULS, tenantId);
                        DatasourcePO datasourcePO = datasourceMapper.selectOne(datasourcePOQueryConditions.getQueryWrapper());
                        if (datasourcePO == null || datasourcePO.getId() == null) {
                            resultVO.setCode(401);
                            resultVO.setMessage("数据源不存在，请重新登陆");
                            result = resultVO;
                            return result;
                        } else {
                            dataSourceVO = new DataSourceVO();
                            BeanUtils.copyProperties(datasourcePO, dataSourceVO);
                            redisTemplate.opsForValue().set(key + datasourcePO.getTenantId(), dataSourceVO, 1, TimeUnit.DAYS);
                        }
                    }

                    try {
                        dynamicDataSource.createDataSourceWithCheck(dataSourceVO);
                    } catch (Exception e) {
                        e.printStackTrace();
                        throw new BizException(401L, "数据源异常，请联系管理员");
                    }
                    //切换数据源
                    DBContextHolder.setDataSource(String.valueOf(dataSourceVO.getTenantId()));
                    result = jp.proceed();
                }
            }
        } catch (BizException bizException) {
            throw bizException;
        } catch (AuthorizationException authorizationException) {
            authorizationException.printStackTrace();
            log.error("没有权限异常", authorizationException);
            throw new BizException(402L, "没有权限，请联系管理员");
        } catch (Exception ex) {
            ex.printStackTrace();
            Throwable cause = ex.getCause();
            if (!StringUtils.isEmpty(cause) && !StringUtils.isEmpty(cause.getMessage())) {
                String message = cause.getMessage();
                if (message.equals("没有权限，请联系管理员") || message.equals("token失效，请重新登录") ||
                        message.equals("数据源异常，请联系管理员")) {
                    throw cause;
                }
            }
            log.error("sql异常", ex);
            result = ResultVO.fail("系统异常，请联系管理员！");
        }
        return result;
    }

}

五、配置动态数据源定时器

package tv.zhongchi.base.common.datasource;

import javax.sql.DataSource;

/**
 * @ClassName DynamicDataSourceTimer
 * @Author ZhangRF
 * @CreateDate 2020/7/16
 * @Decription 动态数据源定时器
 */
public class DynamicDataSourceTimer {

    /**
     * 空闲时间周期。超过这个时长没有访问的数据库连接将被释放。默认为5分钟。
     */
    private static long idlePeriodTime = 5 * 60 * 1000;

    /**
     * 动态数据源
     */
    private DataSource dds;

    /**
     * 上一次访问的时间
     */
    private long lastUseTime;

    public DynamicDataSourceTimer(DataSource dds) {
        this.dds = dds;
        this.lastUseTime = System.currentTimeMillis();
    }

    /**
     * 更新最近访问时间
     */
    public void refreshTime() {
        lastUseTime = System.currentTimeMillis();
    }

    /**
     * 检测数据连接是否超时关闭。
     *
     * @return true-已超时关闭; false-未超时
     */
    public boolean checkAndClose() {

        if (System.currentTimeMillis() - lastUseTime > idlePeriodTime) {
            return true;
        }

        return false;
    }

}

六、DataSourceVO 

package tv.zhongchi.base.common.datasource;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * @ClassName DatasiurcePO
 * @CreateDate 2020-06-16 09:26:26
 * @Author ZhangRF
 * @Decription 租户数据源
 */
@Data
public class DataSourceVO implements Serializable {
    private static final long serialVersionUID = 1L;

    /**
     *
     */
    private Long id;
    /**
     * 租户id
     */
    private Long tenantId;
    /**
     * 数据源url
     */
    private String datasourceUrl;
    /**
     * 数据源用户名
     */
    private String datasourceUsername;
    /**
     * 数据源密码
     */
    private String datasourcePassword;
    /**
     * 数据源驱动
     */
    private String datasourceDriver;
    /**
     * 是否启用（1是0否）
     */
    private Integer statusId;
    /**
     * 是否删除：0否，1是
     */
    private Integer isDelete;
    /**
     * 备注
     */
    private String remark;
    /**
     * 创建人
     */
    private String createUser;
    /**
     * 创建时间
     */
    private Date gmtCreate;
    /**
     * 更新人
     */
    private String modifiedUser;
    /**
     * 更新时间
     */
    private Date gmtModified;

}