SpringBoot主从数据源切换

SpringBoot主从数据源切换

1.原理

借助spring的【org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource】这个抽象类实现，来进行·数据源的路由，并通过Aop 进行路由选择。

2.配置主从数据源

# dev server
# 多数据源时，主数据源为 master
spring.datasource.master.jdbc-url=jdbc:mysql://localhost:3306/epoint?characterEncoding=utf8&allowMultiQueries=true&useSSL=false&autoReconnect=true&failOverReadOnly=false
spring.datasource.master.username=test
spring.datasource.master.password=test

# dev server
# 多数据源时，从数据源为 slave
spring.datasource.slave.jdbc-url=jdbc:mysql://localhost:3306/epoint2?characterEncoding=utf8&allowMultiQueries=true&useSSL=false&autoReconnect=true&failOverReadOnly=false
spring.datasource.slave.username=test
spring.datasource.slave.password=test

启动报错处理

spring boot ：error querying database. Cause: java.lang.IllegalArgumentException: dataSource or dataSourceClassName or jdbcUrl is required
配置多个数据源启动报错，error querying database. Cause: java.lang.IllegalArgumentException: dataSource or dataSourceClassName or jdbcUrl is required，
主要原因是在1.0 配置数据源的过程中主要是写成：spring.datasource.url 和spring.datasource.driverClassName。
而在2.0升级之后需要变更成：spring.datasource.jdbc-url和spring.datasource.driver-class-name即可解决！
更改配置：spring.datasource.master.url  ->  spring.datasource.master.jdbc-url

3.获取当前线程的数据源类型

/**
 * describe:定义HandleDataSource类来获取当前线程的数据源类型
 * current user Maochao.zhu
 * current system 2020/9/15
 */
public class HandleDataSource {
    public static final ThreadLocal<String> holder = new ThreadLocal<String>();

    /**
     * 绑定当前线程数据源
     *
     * @param datasource
     */
    public static void putDataSource(String datasource) {
        holder.set(datasource);
    }

    /**
     * 获取当前线程的数据源
     *
     * @return
     */
    public static String getDataSource() {
        return holder.get();
    }

}

3.1线程冲突问题

注意：因为新加了数据库线程处理类，和原来存在的多线程处理类冲突，会造成现有程序“卡顿”或者“死机”，因此去除原来配置的定时任务多线程配置

/**
 * describe:配置多线程定时器
 * current user Maochao.zhu
 * current system 2020/1/20
 */
@Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        Method[] methods = BatchProperties.Job.class.getMethods();
        int defaultPoolSize = 3;
        int corePoolSize = 0;
        if (methods != null && methods.length > 0) {
            for (Method method : methods) {
                Scheduled annotation = method.getAnnotation(Scheduled.class);
                if (annotation != null) {
                    corePoolSize++;
                }
            }
            if (defaultPoolSize > corePoolSize)
                corePoolSize = defaultPoolSize;
        }
        taskRegistrar.setScheduler(Executors.newScheduledThreadPool(corePoolSize));
    }
}

4.定义路由数据源的实现类

/**
 * describe:定义路由数据源的实现类MyAbstractRoutingDataSource
 * current user Maochao.zhu
 * current system 2020/9/15
 */
public class MyAbstractRoutingDataSource extends AbstractRoutingDataSource {
    private final Logger log = LoggerFactory.getLogger(this.getClass());
    @Override
    protected Object determineCurrentLookupKey() {
        log.info("###请求的数据源：{}",HandleDataSource.getDataSource());
        return HandleDataSource.getDataSource();//获取对应的数据源
    }
}

5.配置数据源和路由

/**
 * describe:配置数据源数据源和路由配置
 * current user Maochao.zhu
 * current system 2020/9/15
 */
@Configuration
public class DataSourceConfig {
    //主数据源
    @Bean()
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource MasterDataSource() {
        return DataSourceBuilder.create().build();
    }
    //从数据源
    @Bean()
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource SlaveDataSource() {
        return DataSourceBuilder.create().build();
    }
    /**
     * 设置数据源路由，通过该类中的determineCurrentLookupKey决定使用哪个数据源
     */
    @Bean
    public AbstractRoutingDataSource routingDataSource() {
        MyAbstractRoutingDataSource proxy = new MyAbstractRoutingDataSource();
        Map<Object, Object> targetDataSources = new HashMap<>(2);//存放对于数据源的映射
        targetDataSources.put("master", MasterDataSource());
        targetDataSources.put("slave", SlaveDataSource());
        proxy.setDefaultTargetDataSource(MasterDataSource());
        proxy.setTargetDataSources(targetDataSources);
        return proxy;
    }


    @Bean(name = "SqlSessionFactory")
    @Primary
    public SqlSessionFactory MasterSqlSessionFactory(DataSource routingDataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(routingDataSource);//DataSource使用路由数据源

        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        try {
            bean.setMapperLocations(resolver.getResources("classpath*:mapper/**/*.xml"));
            bean.setConfigLocation(resolver.getResource("classpath:mybatis-config.xml"));
            return bean.getObject();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }

    }

    @Bean(name = "TransactionManager")
    @Primary
    public DataSourceTransactionManager testTransactionManager(DataSource routingDataSource) {
        return new DataSourceTransactionManager(routingDataSource);
    }

    @Bean(name = "SqlSessionTemplate")
    @Primary
    public SqlSessionTemplate MasterSqlSessionTemplate(SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

5.1启动权限shiro问题

注意：配置路由设置后，原来的apache.shiro 权限读取不到问题，排查以后确定原因是在使用配置路由设置,原来在application.properties中配置的mybaits属性,将不起作用，因此需要新加一个配置文件(mybatis-config.xml),从中读取配置信息， 其中ShiroConfig配置类中新增注解支持

/**
 * 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
 * 配置以下两个bean(DefaultAdvisorAutoProxyCreator和AuthorizationAttributeSourceAdvisor)即可实现此功能
 * @return
 */
@Bean
@ConditionalOnMissingBean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
	DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
	advisorAutoProxyCreator.setProxyTargetClass(true);
	return advisorAutoProxyCreator;
}

/**
 * 开启shiro aop注解支持.
 * 使用代理方式;所以需要开启代码支持;
 * @param securityManager
 * @return
 * */
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager){
	AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
	authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
	return authorizationAttributeSourceAdvisor;
}

6.加载mybatis配置

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="cacheEnabled" value="true" />
        <setting name="lazyLoadingEnabled" value="true" />
        <setting name="multipleResultSetsEnabled" value="true" />
        <setting name="useColumnLabel" value="true" />
        <setting name="useGeneratedKeys" value="false" />
        <setting name="defaultExecutorType" value="SIMPLE" />
        <setting name="mapUnderscoreToCamelCase" value="true" />
        <setting name="logImpl" value="STDOUT_LOGGING" />
    </settings>
</configuration>

7.新建注解来注释使用的数据源

/**
 * describe:DataSource注解来注释Mapper接口所要使用的数据源
 * current user Maochao.zhu
 * current system 2020/9/15
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DataSource {
    String value();//设置数据源类型
}

8.配置Aop

/**
 * describe:配置Aop切换路由选择
 * current user Maochao.zhu
 * current system 2020/9/15
 */
@Aspect
@Component
public class DataSourceAspect {
    public Logger logger = LoggerFactory.getLogger(this.getClass());
    /**
     * 在dao层方法获取datasource对象之前，在切面中指定当前线程数据源
     */
    @Pointcut("execution(* com.cn.zx.dao..*.*(..))")//切点为所有的mapper接口
    public void pointcut() {

    }

    @Before("pointcut()")
    public void before(JoinPoint point) {
        System.out.println("before");
        Object target = point.getTarget();
        String method = point.getSignature().getName();
        Class<?>[] classz = target.getClass().getInterfaces();// 获取目标类的接口， 所以@DataSource需要写在接口上
        Class<?>[] parameterTypes = ((MethodSignature) point.getSignature()).getMethod().getParameterTypes();
        try {
            Method m = classz[0].getMethod(method, parameterTypes);
            if (m != null && m.isAnnotationPresent(DataSource.class)) {
                DataSource data = m.getAnnotation(DataSource.class);
                System.out.println("####################用户选择数据库库类型：" + data.value());
                HandleDataSource.putDataSource(data.value());// 数据源放到当前线程中
            }
            logger.info("执行接口方法:{}.{}", point.getSignature().getDeclaringTypeName(), point.getSignature().getName());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

9.设置数据源类型

在对应的mapper方法上使用注解DataSource("master/slave")来设置数据源类型

/**
 * 调用主数据源 master
 * @param user
 * @return
 */
@DataSource("master")
Integer insertUser(User user);

/**
 * 调用从数据源 slave
 * @param user
 * @return
 */
@DataSource("slave")
List<User> getUserList(User user);

10.事务失效问题

添加主从数据库以后，事务就失效了，原因还在找, 初步定位为： 事务和切面的执行顺序问题

@EnableTransactionManagement(order = 2) @Order(2)

11.主从数据库同步问题

主从数据库数据同步问题，
初步定位：
	1.程序同步。因为要读写分离，肯定要设置数据库权限，主数据库可以读写，从数据库只能读，所以这个方法可能行不通
	2.数据库操作同步数据

...待更新

参考：https://blog.csdn.net/qq_39084534/article/details/99938432

推荐：锌媒体

SpringBoot主从数据源切换

原文：https://www.cnblogs.com/plus666/p/13676089.html