记录springboot及项目中的一些集成（2）springboot 自定义注解实现动态切换多数据源配置

第一步肯定是引入jar包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.0.26</version>
</dependency>

第二步配置数据源连接池信息,在这我配置了两个连接，jdbcUrl，jdbcUrl1

#连接池的配置信息
## 初始化大小，最小，最大
spring.druid.jdbcUrl=jdbc:mysql://xxx/order1?useUnicode=true&useSSL=false&characterEncoding=utf8
spring.druid.jdbcUrl1=jdbc:mysql://xxx/order2?useUnicode=true&useSSL=false&characterEncoding=utf8
spring.druid.username=root
spring.druid.password=znj123456
spring.druid.driver-class-name=org.gjt.mm.mysql.Driver
spring.druid.initialSize=2
spring.druid.minIdle=2
spring.druid.maxActive=2
## 配置获取连接等待超时的时间
spring.druid.maxWait=60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.druid.timeBetweenEvictionRunsMillis=60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
spring.druid.minEvictableIdleTimeMillis=300000
spring.druid.validationQuery=SELECT 1 FROM DUAL
spring.druid.testWhileIdle=true
spring.druid.testOnBorrow=false
spring.druid.testOnReturn=false
spring.druid.poolPreparedStatements=true
spring.druid.maxPoolPreparedStatementPerConnectionSize=20
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
spring.druid.filters=stat,wall
# 通过connectProperties属性来打开mergeSql功能；慢SQL记录
spring.druid.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

第三步配置DruidConfig

@Data
@Configuration
@ConfigurationProperties(prefix = "spring.druid",ignoreInvalidFields = true)
public class DruidConfig {

private String driverClassName;
private String jdbcUrl1;
private String username;
private String jdbcUrl;
private String password;
private int maxActive;
private int minIdle;
private int initialSize;
private Long timeBetweenEvictionRunsMillis;
private Long minEvictableIdleTimeMillis;
private String validationQuery;
private boolean testWhileIdle;
private boolean testOnBorrow;
private boolean testOnReturn;
private boolean poolPreparedStatements;
private Integer maxPoolPreparedStatementPerConnectionSize;
private String filters;
private String connectionProperties;

//这里需要注意默认是读取的application.properties配置文件。
//如果你的配置文件不在默认文件中。
//需要在类中引入配置文件例如：@PropertySource(value = "classpath:druid.properties")
//@Bean(destroyMethod = "close",initMethod = "init")
public DataSource getDs1(){
    DruidDataSource druidDataSource = new DruidDataSource();
    druidDataSource.setDriverClassName(driverClassName);
    druidDataSource.setUrl(jdbcUrl);
    druidDataSource.setUsername(username);
    druidDataSource.setPassword(password);
    druidDataSource.setMaxActive(maxActive);
    druidDataSource.setInitialSize(initialSize);
    druidDataSource.setTimeBetweenConnectErrorMillis(timeBetweenEvictionRunsMillis);
    druidDataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
    druidDataSource.setValidationQuery(validationQuery);
    druidDataSource.setTestWhileIdle(testWhileIdle);
    druidDataSource.setTestOnBorrow(testOnBorrow);
    druidDataSource.setTestOnReturn(testOnReturn);
    druidDataSource.setPoolPreparedStatements(poolPreparedStatements);
    druidDataSource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);

    try {
        druidDataSource.setFilters(filters);
    } catch (SQLException e) {
        e.printStackTrace();
    }

    return druidDataSource;
}

//@Bean(destroyMethod = "close",initMethod = "init")
public DataSource getDs2(){
    DruidDataSource druidDataSource = new DruidDataSource();
    druidDataSource.setDriverClassName(driverClassName);
    druidDataSource.setUrl(jdbcUrl1);
    druidDataSource.setUsername(username);
    druidDataSource.setPassword(password);
    druidDataSource.setMaxActive(maxActive);
    druidDataSource.setInitialSize(initialSize);
    druidDataSource.setTimeBetweenConnectErrorMillis(timeBetweenEvictionRunsMillis);
    druidDataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
    druidDataSource.setValidationQuery(validationQuery);
    druidDataSource.setTestWhileIdle(testWhileIdle);
    druidDataSource.setTestOnBorrow(testOnBorrow);
    druidDataSource.setTestOnReturn(testOnReturn);
    druidDataSource.setPoolPreparedStatements(poolPreparedStatements);
    druidDataSource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);

    try {
        druidDataSource.setFilters(filters);
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return druidDataSource;
}

@Bean
public DataSource dynamicDataSource() {
    Map<Object, Object> targetDataSources = new HashMap<>();
    DataSource ds1 = getDs1();
    targetDataSources.put("ds1", ds1);
    targetDataSources.put("ds2", getDs2());
    DynamicDataSource dynamicDataSource = new DynamicDataSource();
    dynamicDataSource.setTargetDataSources(targetDataSources);
    //设置默认数据源
    dynamicDataSource.setDefaultTargetDataSource(ds1);

    DynamicDataSourceContextHolder.dataSourceIds.add("ds1");
    DynamicDataSourceContextHolder.dataSourceIds.add("ds2");
    return dynamicDataSource;
}

/**
 * 配置访问druid监控
 * @return
 */
@Bean
public ServletRegistrationBean druidStateViewServlet(){
    ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(),"/druid/*");
    //初始化参数initParams
    //添加白名单
    servletRegistrationBean.addInitParameter("allow","");
    //添加ip黑名单
    servletRegistrationBean.addInitParameter("deny","192.168.16.111");
    //登录查看信息的账号密码
    servletRegistrationBean.addInitParameter("loginUsername","admin");
    servletRegistrationBean.addInitParameter("loginPassword","123");
    //是否能够重置数据
    servletRegistrationBean.addInitParameter("resetEnable","false");
    return servletRegistrationBean;
}

/**
 * 过滤不需要监控的后缀
 * @return
 */
@Bean
public FilterRegistrationBean druidStatFilter(){
    FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
    //添加过滤规则
    filterRegistrationBean.addUrlPatterns("/*");
    //添加不需要忽略的格式信息
    filterRegistrationBean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
    return filterRegistrationBean;
}

第四步自定义注解，TargetDataSource

/**
 * 注解在类或者方法上都行
 * @author znj
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TargetDataSource {
    String name();
}

第五步：创建一个ThreadLocal DynamicDataSourceContextHolder，存放当前用户操作线程和数据源标识的映射关系

/** 
 *  建立映射关系，建立当前用户操作线程和数据源标识的映射关系
 */
public class DynamicDataSourceContextHolder {
    
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();

    public static ThreadLocal<String> getContextHolder() {
        return contextHolder;
    }

    public static List<String> dataSourceIds = new ArrayList<String>();
    
    public static void setDataSourceType(String dataSourceType) {
        contextHolder.set(dataSourceType);
    }
    
    public static String getDataSourceType() {
        return contextHolder.get();
    }
    
    public static boolean containsDataSource(String dataSourceId) {
        return dataSourceIds.contains(dataSourceId);
    }
}

第六步：切面DynamicDataSourceAspect

@Aspect
@Component
public class DynamicDataSourceAspect {
    private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceAspect.class);
    
    /**
     * 在方法执行执行会先拦截注解@TargetDataSource这个的方法
     * @param point
     * @param ds
     */
    @Before("@annotation(ds)")
    public void changeDataSource(JoinPoint point, TargetDataSource ds) {
        //这个就是数据源标识
        String dsId = ds.name();
        if (!DynamicDataSourceContextHolder.containsDataSource(dsId)) {
            logger.error("数据源【{}】不存在，使用默认数据源 > {}",
                    ds.name(),
                    point.getSignature());
        }
        else {
            logger.debug("Use dataSource : {} > {}",
                    ds.name(),
                    point.getSignature());
            //如果容器中有数据源，那么就把数据源标识设置到ThreadLocal中
            DynamicDataSourceContextHolder.setDataSourceType(dsId);
        }
    }

    @After("@annotation(ds)")
    public void releaseLocal(JoinPoint point, TargetDataSource ds) {
        logger.info("==释放ds：" + ds.name() + "的ThreadLocal绑定==");
        if(DynamicDataSourceContextHolder.getDataSourceType() != null) {
            DynamicDataSourceContextHolder.getContextHolder().remove();
        }
    }
}

第七步：扩展AbstractRoutingDataSource类 DynamicDataSource

public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        try {
            Field targetF = this.getClass().getSuperclass().getDeclaredField("targetDataSources");
            targetF.setAccessible(true);
            Map<Object, Object> targetV = (Map<Object, Object>) targetF.get(this);

            String ds = DynamicDataSourceContextHolder.getDataSourceType();

            if (ds != null)
                System.out.println("操作的数据源是： "
                        + ds + "->url:" + ((DruidDataSource) targetV.get(ds)).getUrl());
            return DynamicDataSourceContextHolder.getDataSourceType();

        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return "ds1";
    }
}

以上就完成了对动态切换数据源的所有配置，
测试一下 在方法上加入自定义注解切换：

@TargetDataSource(name = "ds1")
public List<Customer> getCustomers(){
	List<Customer> selectAll = customerDao.selectAll();
	return selectAll;
}
@TargetDataSource(name = "ds2")
public List<Customer> getCustomers2(){
	List<Customer> selectAll = customerDao.selectAll();
	return selectAll;
}

到此就算配置未完成；源码在更新完基本集成基础使用后更新出来！