springboot+mysql读写分离

在javaweb开发中数据库表数据量会越来越大，为了减轻数据库读写压力，对数据库进行主从模式部署（一主一从，多主多从），在应用层面可以通过spring提供的路由数据源+注解+切面进行控制，在代码层面切换不同数据库源，不同操作选择不同数据库。

代码如下：

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.9</version>
        </dependency>
        <!-- 引入mybatis 依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- mysql 依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <!--<scope>runtime</scope>-->
        </dependency>

spring.datasource.master.url=jdbc:mysql://localhost:3306/master?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.master.username=root
spring.datasource.master.password=123456
spring.datasource.master.driver-class-name=com.mysql.cj.jdbc.Driver

spring.datasource.slave.url=jdbc:mysql://localhost:3306/slave?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.slave.username=root
spring.datasource.slave.password=123456
spring.datasource.slave.driver-class-name=com.mysql.cj.jdbc.Driver

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, TransactionAutoConfiguration.class})
@MapperScan("com.*.mapper")
public class AnnotationAopReflectionApplication {
    public static void main(String[] args) {
        SpringApplication.run(AnnotationAopReflectionApplication.class, args);
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface DataSourceAnnotation {
    /**
     * 默认数据源
     */
    DataSourceEnum value() default DataSourceEnum.MASTER;
    /**
     * 清除
     */
    boolean clear() default true;
}
public enum DataSourceEnum {

    //数据源主库、从库
    MASTER("1","master"),
    SLAVE("2","slave");

    private String code;
    private String name;

    private DataSourceEnum(String code,String name){
        this.code = code;
        this.name = name;
    }

    public static DataSourceEnum getByCode(String code) {
        for (DataSourceEnum event : DataSourceEnum.values()) {
            if (event.code.equals(code)) {
                return event;
            }
        }
        return null;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}
public class DataSourceContextHolder {

    private static final ThreadLocal<String> context = new ThreadLocal<>();

    /**
     * 赋值
     */
    public static void set(String datasourceType) {
        context.set(datasourceType);
    }

    /**
     * 获取值
     */
    public static String get() {
        return context.get();
    }

    /**
     * 清空
     */
    public static void clear() {
        context.remove();
    }

}
public class RoutingDataSource extends AbstractRoutingDataSource {

    /**
     * 最终的determineCurrentLookupKey返回的是从DataSourceContextHolder中拿到的,因此在动态切换数据源的时候注解
     * 应该给DataSourceContextHolder设值
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.get();
    }

}
@Configuration
@MapperScan(basePackages = "com.", sqlSessionTemplateRef = "sqlSessionTemplate")
public class DataSourceConfig {

    /**
     * 主库
     */
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource master() {
        return DruidDataSourceBuilder.create().build();
    }

    /**
     * 从库
     */
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource slaver() {
        return DruidDataSourceBuilder.create().build();
    }

    /**
     * 实例化数据源路由
     */
    @Bean
    public RoutingDataSource routingDataSource(@Qualifier("master") DataSource masterDataSource,@Autowired(required = false) @Qualifier("slaver") DataSource slaveDataSource) {
        RoutingDataSource routingDataSource = new RoutingDataSource();
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceEnum.MASTER.getName(), masterDataSource);
        if (slaveDataSource != null) {
            targetDataSources.put(DataSourceEnum.SLAVE.getName(), slaveDataSource);
        }
        routingDataSource.setTargetDataSources(targetDataSources);
        routingDataSource.setDefaultTargetDataSource(masterDataSource);
        return routingDataSource;
    }

    /**
     * 配置sessionFactory
     */
    @Bean
    public SqlSessionFactory sqlSessionFactory(@Qualifier("routingDataSource") DataSource routingDataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/*.xml"));
        sqlSessionFactoryBean.setDataSource(routingDataSource);
        return sqlSessionFactoryBean.getObject();
    }

    /**
     * 创建sqlSessionTemplate
     */
    @Bean
    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("sqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    /**
     * 事务配置
     */
    @Bean(name = "dataSourceTransactionManager")
    public DataSourceTransactionManager dataSourceTransactionManager(@Qualifier("routingDataSource") DataSource dynamicDataSource) {
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dynamicDataSource);
        return dataSourceTransactionManager;
    }

}
@Aspect
@Order(value = 1)
@Component
public class DataSourceAspect {

    @Around("@annotation(com.*.DataSourceAnnotation)")
    public Object setDynamicDataSource(ProceedingJoinPoint pjp) throws Throwable {
        boolean clear = false;
        try {
            Method method = this.getMethod(pjp);
            DataSourceAnnotation dataSourceAnnotation = method.getAnnotation(DataSourceAnnotation.class);
            clear = dataSourceAnnotation.clear();
            DataSourceContextHolder.set(dataSourceAnnotation.value().getName());
            System.out.println(String.format("数据源切换至：{%s}", dataSourceAnnotation.value().getName()));
            return pjp.proceed();
        } finally {
            if (clear) {
                DataSourceContextHolder.clear();
            }
        }
    }

    private Method getMethod(JoinPoint pjp) {
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        return signature.getMethod();
    }

}

@Service
public class DemoService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private AuthUserMapper authUserMapper;

    /**
     * 读操作
     */
    @DataSourceAnnotation(DataSourceEnum.SLAVE)
    public AuthUser getAuthUser() {
        String userId = "001";
        AuthUser authUser = authUserMapper.getAuthUserById(userId);
        //User user = userMapper.getUserById(1);
        return authUser;
    }

    /**
     * 写操作
     */
    @DataSourceAnnotation(DataSourceEnum.MASTER)
    public User updateUser() {
        User user = userMapper.getUserById(1);
        return user;
    }

}
@RestController
public class DemoController {
    
    @Autowired
    private DemoService demoService;

    @GetMapping("/readSlave")
    public Object readSlave() {
        return demoService.getAuthUser();
    }

    @GetMapping("/writeMaster")
    public Object writeMaster() {
        return demoService.updateUser();
    }

}

前提是部署好mysql主从数据库或准备不同数据库。注意读写分离的核心点就是数据路由，需要继承AbstractRountingDataSource，覆写它的determinCurrentLookupKey方法，同时需要注意全局的上下文管理器DataSourceContextHolder，它是保存数据源上下文的主要类，也是路由方法中寻找的数据源取值，相当于数据源的中转站，此例配置了3个数据源。再结合jdbc底层、事务等，数据库读写分离就实现了。