tzy-admin/py-base/src/main/java/com/poyee/datasource/DataSourceConfig.java

package com.poyee.datasource;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.core.config.GlobalConfig;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import com.github.yulichang.injector.MPJSqlInjector;
import com.github.yulichang.interceptor.MPJInterceptor;
import com.poyee.datasource.common.DbInitUtil;
import com.poyee.datasource.modal.DbConfigModal;
import com.poyee.util.ParseUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.io.VFS;
import org.apache.ibatis.session.SqlSessionFactory;
import org.jetbrains.annotations.Nullable;
import org.mybatis.spring.annotation.MapperScan;
import org.mybatis.spring.boot.autoconfigure.SpringBootVFS;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.util.ClassUtils;
import org.springframework.util.CollectionUtils;

import javax.sql.DataSource;
import java.io.IOException;
import java.sql.SQLException;
import java.util.*;

/**
 * 多数据源配置
 */
@Slf4j
@Configuration
@MapperScan(basePackages = {"com.poyee.mapper","com.poyee.**.mapper"}, sqlSessionFactoryRef = "sqlSessionFactory")
public class DataSourceConfig {

    @Value("${spring.datasource.dynamic.datasource.master.url}")
    private String url;
    // 连接池连接信息
    @Value("${spring.datasource.druid.initialSize}")
    private int initialSize;
    @Value("${spring.datasource.druid.minIdle}")
    private int minIdle;
    @Value("${spring.datasource.druid.maxActive}")
    private int maxActive;
    @Value("${spring.datasource.druid.maxWait}")
    private int maxWait;
    @Value("${spring.profiles.active:dev}")
    private String version;
    static final String DEFAULT_RESOURCE_PATTERN = "**/*.class";
    @Autowired
    private Environment env;

    /**
     * @param typeAliasesPackage
     * @return
     */
    private static String setTypeAliasesPackage(String typeAliasesPackage) {
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resolver);
        List<String> allResult = new ArrayList<>();
        try {
            for (String aliasesPackage : typeAliasesPackage.split(",")) {
                List<String> result = new ArrayList<>();
                aliasesPackage =
                        ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + ClassUtils.convertClassNameToResourcePath(aliasesPackage.trim()) + "/" + DEFAULT_RESOURCE_PATTERN;
                Resource[] resources = resolver.getResources(aliasesPackage);
                if (resources != null && resources.length > 0) {
                    MetadataReader metadataReader = null;
                    for (Resource resource : resources) {
                        if (resource.isReadable()) {
                            metadataReader = metadataReaderFactory.getMetadataReader(resource);
                            try {
                                result.add(Class.forName(metadataReader.getClassMetadata()
                                                                       .getClassName())
                                                .getPackage()
                                                .getName());
                            } catch (ClassNotFoundException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
                if (result.size() > 0) {
                    HashSet<String> hashResult = new HashSet<String>(result);
                    allResult.addAll(hashResult);
                }
            }
            if (allResult.size() > 0) {
                typeAliasesPackage = String.join(",", (String[]) allResult.toArray(new String[0]));
            } else {
                throw new RuntimeException("mybatis typeAliasesPackage 路径扫描错误,参数typeAliasesPackage:" + typeAliasesPackage + "未找到任何包");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return typeAliasesPackage;
    }

    /**
     * 创建数据源
     * @return
     */
    @Bean("masterDataSource")
    @Primary
    @Qualifier("masterDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.master")
    public DruidDataSource dataSource() {
        //注册时 使用多数据源中 的master数据源 配置
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        return dataSource;
    }

    /**
     * 动态数据源配置 sqlSessionFactory
     * @return
     * @throws Exception
     */
    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        String typeAliasesPackage = env.getProperty("mybatis.typeAliasesPackage");
        String mapperLocations = env.getProperty("mybatis.mapperLocations");
        String configLocation = env.getProperty("mybatis.configLocation");
        typeAliasesPackage = setTypeAliasesPackage(typeAliasesPackage);
        VFS.addImplClass(SpringBootVFS.class);
        final MybatisSqlSessionFactoryBean sessionFactory = new MybatisSqlSessionFactoryBean();
        sessionFactory.setDataSource(dynamicDataSource());
        sessionFactory.setTypeAliasesPackage(typeAliasesPackage);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapperLocations));
        sessionFactory.setConfigLocation(new DefaultResourceLoader().getResource(configLocation));
        GlobalConfig globalConfig = new GlobalConfig();
//        globalConfig.setMetaObjectHandler(new MybatisMetaObjectHandler());
        globalConfig.setSqlInjector(new MPJSqlInjector());
        sessionFactory.setGlobalConfig(globalConfig);
        //加载插件
        sessionFactory.setPlugins(mybatisPlusInterceptor(), new MPJInterceptor());
        return sessionFactory.getObject();
    }
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.POSTGRE_SQL));
        return interceptor;
    }

    /**
     * 动态数据源配置
     * @return
     */
    @Bean(name = "dynamicDataSource")
    @Qualifier("dynamicDataSource")
    public DynamicDataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        //配置缺省的数据源
        // 默认数据源配置 DefaultTargetDataSource
        dynamicDataSource.setDefaultTargetDataSource(dataSource());
        Map<Object, Object> targetDataSources = new HashMap<>();
        //额外数据源配置 TargetDataSources
        targetDataSources.put("master", dataSource());
        try {
            List<DbConfigModal> dbConfigModals = new ArrayList<>();
            dbConfigModals = DbInitUtil.checkDbConfig(new DbConfigModal(), "application-"+version+".yml");
            if(!CollectionUtils.isEmpty(dbConfigModals)){
                dbConfigModals.forEach(tableConfigDto -> {
                    //解析处理数据连接参数
                    Map<String, String> env = System.getenv();
                    String dataSource = tableConfigDto.getDataSource().toUpperCase();
                    String url = ParseUtil.parse(ParseUtil.mathStr_1, tableConfigDto.getDbUrl());
                    String username = ParseUtil.parse(ParseUtil.mathStr_1, tableConfigDto.getDbUsername());
                    String pwd = ParseUtil.parse(ParseUtil.mathStr_1, tableConfigDto.getDbPwd());
                    if(!Objects.isNull(env)){
                        url = StringUtils.isBlank(env.get(dataSource + "_DATASOURCE_URL")) ? url : env.get(dataSource + "_DATASOURCE_URL");
                        username = StringUtils.isBlank(env.get(dataSource + "_DATASOURCE_USERNAME")) ? username : env.get(dataSource + "_DATASOURCE_USERNAME");
                        pwd = StringUtils.isBlank(env.get(dataSource + "_DATASOURCE_PASSWORD")) ? pwd : env.get(dataSource + "_DATASOURCE_PASSWORD");
                    }
                    tableConfigDto.setDbUrl(getDbParams("DATASOURCE_URL:",url));
                    tableConfigDto.setDbUsername(getDbParams("DATASOURCE_USERNAME:",username));
                    tableConfigDto.setDbPwd(getDbParams("DATASOURCE_PASSWORD:",pwd));
                    if(StringUtils.isNotBlank(tableConfigDto.getDataSource())){
                        dynamicDataSource.testDatasource(tableConfigDto.getDataSource(),tableConfigDto.getDriverClassName(), tableConfigDto.getDbUrl(), tableConfigDto.getDbUsername(), tableConfigDto.getDbPwd());
                        try {
                            targetDataSources.put(tableConfigDto.getDataSource(), initDataSource(tableConfigDto));
                        } catch (SQLException e) {
                            log.info(" 注册数据源 SLAVE 失败 ");
                        }
                    }
                });
            }
        } catch (Exception e) {
            log.info(" 注册数据源 SLAVE 失败 ");
            e.printStackTrace();
        }
        dynamicDataSource.setTargetDataSources(targetDataSources);
        return dynamicDataSource;
    }

    @Nullable
    private static String getDbParams(String formatStr , String url) {
        if(StringUtils.isNotBlank(url)){
            String[] urls = url.split(formatStr);
            if(urls.length>1){
                url = urls[1];
            }
        }
        return url;
    }


    /**
     * 初始化数据源
     * @param config
     * @return
     * @throws SQLException
     */
    private DataSource initDataSource(DbConfigModal config) throws SQLException{
        DruidDataSource datasource = new DruidDataSource();
        // 基础连接信息
        datasource.setUrl(config.getDbUrl());
        datasource.setUsername(config.getDbUsername());
        datasource.setPassword(config.getDbPwd());
        datasource.setDriverClassName(config.getDriverClassName());
        // 连接池连接信息
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource.setConnectionErrorRetryAttempts(3);//失败后重试次数
        datasource.setBreakAfterAcquireFailure(true);//请求失败之后中断
        datasource.setPoolPreparedStatements(true); //是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
        datasource.setMaxPoolPreparedStatementPerConnectionSize(20);
        datasource.setConnectionProperties("druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000");//对于耗时长的查询sql，会受限于ReadTimeout的控制，单位毫秒
        datasource.setTestOnBorrow(true); //申请连接时执行validationQuery检测连接是否有效，这里建议配置为TRUE，防止取到的连接不可用
        datasource.setTestWhileIdle(true);//建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
        String validationQuery = "select 1 ";
        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;
    }

    // =================== 事务管理器配置 ===================

    /**
     * 主数据源事务管理器
     * 用于显式指定 master 数据源的事务
     */
    @Bean("masterTransactionManager")
    @Primary
    public PlatformTransactionManager masterTransactionManager(@Qualifier("masterDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     * 动态数据源事务管理器
     * 推荐与 @DS 注解配合使用，能感知数据源切换
     */
    @Bean("dynamicTransactionManager")
    public PlatformTransactionManager dynamicTransactionManager( @Qualifier("dynamicDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

}