springboot+mysql数据源切换

数据源切换

一.这 里我做的是mysql读写分离，我是建立了两个链接，分别用了不同的端口号来分开（当然也可以区分数据库，这个根据自己所需 ）

 

spring.datasource.select.jdbc-url=jdbc:mysql://localhost:3308/product
spring.datasource.select.username=root
spring.datasource.select.password=
spring.datasource.select.driver-class-name=com.mysql.jdbc.Driver


spring.datasource.update.jdbc-url=jdbc:mysql://localhost:3307/product
spring.datasource.update.username=root
spring.datasource.update.password=
spring.datasource.update.driver-class-name=com.mysql.jdbc.Driver
#加载mapper文件
mybatis.mapper-locations=classpath*:mapper/*.xml
#修改访问端口
server.port=8099

 

这个是在springboot项目中的，application.properties文件中连接的

二.接下来我们添加工具包

package com.fh.datademo.datasoucedynamic;

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 javax.sql.DataSource;

/**
 * @author yuchunqiang
 * @Title: DataSourceConfig
 * @Package com.fh.datademo.datasoucedynamic
 * @Description: ${todo}
 * @date 2018/10/24  16:01
 */
@Configuration
public class DataSourceConfig {
    @Bean(name = "selectDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.select")
    public DataSource dataSource1() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "updateDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.update")
    public DataSource dataSource2() {
        return DataSourceBuilder.create().build();
    }

}

这个主要用来找到两个mysql的连接，并提供给另外一个工具包决定我们的方法到底走application.properties中哪一个连接

package com.fh.datademo.datasoucedynamic;

import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

/**
 * @author yuchunqiang
 * @Title: DataSourceContextHolder
 * @Package com.fh.datademo.datasoucedynamic
 * @Description: ${todo}
 * @date 2018/10/24  16:00
 */
@Component
@Lazy(false)
public class DataSourceContextHolder {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDbType(String dbType) {
        contextHolder.set(dbType);
    }

    public static String getDbType() {
        return contextHolder.get();
    }

    public static void clearDbType() {
        contextHolder.remove();
    }
}

package com.fh.datademo.datasoucedynamic;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.stereotype.Component;


import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 * @author yuchunqiang
 * @Title: DynamicDataSource
 * @Package com.fh.datademo.datasoucedynamic
 * @Description: ${todo}
 * @date 2018/10/24  16:06
 */
@Component
@Primary
public class DynamicDataSource extends AbstractRoutingDataSource {

    @Autowired
    @Qualifier("selectDataSource")
    private DataSource selectDataSource;

    @Autowired
    @Qualifier("updateDataSource")
    private DataSource updateDataSource;

    /**
     * 这个是主要的方法，返回的是生效的数据源名称
     */
    @Override
    protected Object determineCurrentLookupKey() {
        System.out.println("DataSourceContextHolder：：："+DataSourceContextHolder.getDbType());
        return DataSourceContextHolder.getDbType();
    }

    /**
     * 自己配的时候老是报什么没有指定target这里设置一下，默认数据源是updateDataSource
     */
    @Override
    public void afterPropertiesSet() {
        Map<Object,Object> map = new HashMap<>();
        map.put("selectDataSource",selectDataSource);
        map.put("updateDataSource",updateDataSource);
        setTargetDataSources(map);
        setDefaultTargetDataSource(updateDataSource);
        super.afterPropertiesSet();
    }
}

package com.fh.datademo.datasoucedynamic;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.context.annotation.Lazy;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * @author yuchunqiang
 * @Title: SwitchDataSourceAOP
 * @Package com.fh.datademo.datasoucedynamic
 * @Description: ${todo}
 * @date 2018/10/24  15:54
 */
@Aspect
@Component
@Lazy(false)
@Order(0) //Order设定AOP执行顺序 使之在数据库事务上先执行
public class SwitchDataSourceAOP {

    //这里切到你的方法目录
    @Before("execution(* com.fh.datademo.service.*.*.*(..))")
    public void process(JoinPoint joinPoint) {
        String methodName=joinPoint.getSignature().getName();
        if (methodName.startsWith("get")
                ||methodName.startsWith("count")
                ||methodName.startsWith("find")
                ||methodName.startsWith("list")
                ||methodName.startsWith("select")
                ||methodName.startsWith("check")
                ||methodName.startsWith("query")){
            DataSourceContextHolder.setDbType("selectDataSource");
        }else {
            //切换dataSource
            DataSourceContextHolder.setDbType("updateDataSource");
        }
    }

}

用来在走方法之前，来决定走哪个数据源，在@Before的设置中（@Before("execution(* com.fh.datademo.service.*.*.*(..))")）决定具体到哪个包，具体到哪个类，然后获取其方法名来判断，方法名中包含所规定的字符，则走读的数据源，否则走写的数据源。从而来达到读写分离，实现自动切换的功能

项目git地址：https://github.com/yuchunqiang