1、问题提出
    目前 Oracle 中有两个数据库，要实现一个数据库只进行读操作，另一个数据库进行写操作，也即数据库的主从复制，该怎么做？
    2、简要说明：为什么使用主从复制、读写分离？
    主从复制、读写分离一般是一起使用的。目的很简单，就是为了提高数据库的并发性能。你想，假设是单机，读写都在一台 MySQL 上面完成，性能肯定不高。如果有三台MySQL，一台 mater 只负责写操作，两台 salve 只负责读操作，性能不就能大大提高了吗？
    所以主从复制、读写分离就是为了数据库能支持更大的并发。
    随着业务量的扩展，如果是单机部署的 MySQL，会导致I/O频率过高。采用主从复制、读写分离可以提高数据库的可用性。
    3、AbstractRoutingDataSource
    SpringBoot 提供了 AbstractRoutingDataSource，可以根据用户自定义的规则选择当前的数据源，这样我们每次访问数据库之前，设置要使用的数据源，就可以实现数据源的动态切换。

    4、具体实现
    1、创建一个类继承 AbstractRoutingDataSource

    1. import org.apache.logging.log4j.LogManager;
    2. import org.apache.logging.log4j.Logger;
    3. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
    5. /**
    6.  * 1. 创建 RoutingDataSource 继承 AbstractRoutingDataSource
    7.  * 重写 determineCurrentLookupKey方法，返回要使用的数据源key值。
    8.  */
    9. public class RoutingDataSource extends AbstractRoutingDataSource {
    10.     private Logger logger = LogManager.getLogger();
    12.     @Override
    13.     protected Object determineCurrentLookupKey() {
    14.         String dataSource = RoutingDataSourceHolder.getDataSource();
    15.         logger.info("使用数据源：{}", dataSource);
    16.         return dataSource;
    17.     }
    18. }

    2、创建一个管理数据源 key 值的类，RoutingDataSourceManager

    1. import org.apache.logging.log4j.LogManager;
    2. import org.apache.logging.log4j.Logger;
    4. /**
    5.  * 2. 创建一个管理数据源key值的类 RoutingDataSourceHolder
    6.  * 代码设置了一个事务内使用同一个数据源。
    7.  */
    8. public class RoutingDataSourceManager {
    10.     private static Logger logger = LogManager.getLogger();
    12.     private static final ThreadLocal<String> dataSources = new ThreadLocal<>();
    14.     // 一个事务内使用同一个数据源
    15.     public static void setDataSource(String dataSourceName) {
    16.         if (dataSources.get() == null) {
    17.             dataSources.set(dataSourceName);
    18.             logger.info("设置数据源：{}", dataSourceName);
    19.         }
    20.     }
    22.     public static String getDataSource() {
    23.         return dataSources.get();
    24.     }
    26.     public static void clearDataSource() {
    27.         dataSources.remove();
    28.     }
    30. }

    3、application.properties

    1. # OracleDbProperties  
    2. # master dbsource
    3. spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
    4. spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
    5. spring.datasource.url=jdbc:oracle:thin:@xxx.xxx.xxx.7:1521:xxx
    6. spring.datasource.username=xxx
    7. spring.datasource.password=xxx
    9. # slave dbsource
    10. spring.slave-datasource.type=com.alibaba.druid.pool.DruidDataSource
    11. spring.slave-datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
    12. spring.slave-datasource.url=jdbc:oracle:thin:@xxx.xxx.xxx.6:1521:xxx
    13. spring.slave-datasource.username=xxx
    14. spring.slave-datasource.password=xxx

    4、配置主从数据库

    1. import com.alibaba.druid.pool.DruidDataSource;
    2. import org.apache.commons.lang3.StringUtils;
    3. import org.apache.logging.log4j.LogManager;
    4. import org.apache.logging.log4j.Logger;
    5. import org.springframework.beans.factory.annotation.Qualifier;
    6. import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
    7. import org.springframework.boot.context.properties.ConfigurationProperties;
    8. import org.springframework.context.annotation.Bean;
    9. import org.springframework.context.annotation.Configuration;
    10. import org.springframework.context.annotation.DependsOn;
    11. import org.springframework.context.annotation.Primary;
    13. import javax.sql.DataSource;
    14. import java.util.HashMap;
    15. import java.util.Map;
    17. /**
    18.  * 配置主从数据库：主：xxx.xxx.xxx.7；从：xxx.xxx.xxx.6
    19.  */
    20. @Configuration
    21. public class DataSourceConfigurer {
    22.     private Logger logger = LogManager.getLogger();
    24.     public final static String MASTER_DATASOURCE = "masterDataSource";// 主数据库
    25.     public final static String SLAVE_DATASOURCE = "slaveDataSource";// 从数据库
    27.     // 主数据库：.7
    28.     @Bean(MASTER_DATASOURCE)
    29.     @ConfigurationProperties(prefix = "spring.datasource")
    30.     public DruidDataSource masterDataSource(DataSourceProperties properties) {
    31.         DruidDataSource build = properties.initializeDataSourceBuilder().type(DruidDataSource.class).build();
    32.         logger.info("配置主数据库:{}", build);
    33.         return build;
    34.     }
    36.     // 从数据库：.6
    37.     @Bean(SLAVE_DATASOURCE)
    38.     @ConfigurationProperties(prefix = "spring.slave-datasource")
    39.     public DruidDataSource slaveDataSource(DataSourceProperties properties) {
    40.         DruidDataSource build = properties.initializeDataSourceBuilder().type(DruidDataSource.class).build();
    41.         logger.info("配置从数据库:{}", build);
    42.         return build;
    43.     }
    45.     /**
    46.      * Primary   优先使用该Bean
    47.      * DependsOn 先执行主从数据库的配置
    48.      * Qualifier 指定使用哪个Bean
    49.      *
    50.      * @param masterDataSource 主数据源
    51.      * @param slaveDataSource  从数据源
    52.      * @return
    53.      */
    54.     @Bean
    55.     @Primary
    56.     @DependsOn(value = {MASTER_DATASOURCE, SLAVE_DATASOURCE})
    57.     public DataSource routingDataSource(@Qualifier(MASTER_DATASOURCE) DruidDataSource masterDataSource,
    58.                                         @Qualifier(SLAVE_DATASOURCE) DruidDataSource slaveDataSource) {
    59.         if (StringUtils.isBlank(slaveDataSource.getUrl())) {
    60.             logger.info("没有配置从数据库,默认使用主数据库");
    61.             return masterDataSource;
    62.         }
    64.         // 设置初始化targetDataSources对象
    65.         Map<Object, Object> map = new HashMap<>();
    66.         map.put(DataSourceConfigurer.MASTER_DATASOURCE, masterDataSource);
    67.         map.put(DataSourceConfigurer.SLAVE_DATASOURCE, slaveDataSource);
    68.         RoutingDataSource routing = new RoutingDataSource();
    69.         // 设置动态数据源
    70.         routing.setTargetDataSources(map);
    71.         // 设置默认数据源
    72.         routing.setDefaultTargetDataSource(masterDataSource);
    73.         logger.info("主从数据库配置完成");
    74.         return routing;
    75.     }
    76. }

    5、自定义注解和切面类
    自定义注解：

    1. import java.lang.annotation.*;
    3. @Retention(RetentionPolicy.RUNTIME)// 声明注解有效的时间
    4. @Target({ElementType.TYPE, ElementType.METHOD})// 说明该注解可以写在类和方法上
    5. @Documented
    6. public @interface DataSourceWith {
    7.     String key() default "";
    8. }

    切面类：

    1. <!-- 添加aop依赖 -->
    2. <dependency>
    3.   <groupId>org.springframework.boot</groupId>
    4.   <artifactId>spring-boot-starter-aop</artifactId>
    5. </dependency>
    1. import org.aspectj.lang.JoinPoint;
    2. import org.aspectj.lang.annotation.After;
    3. import org.aspectj.lang.annotation.Aspect;
    4. import org.aspectj.lang.annotation.Before;
    5. import org.aspectj.lang.annotation.Pointcut;
    6. import org.aspectj.lang.reflect.MethodSignature;
    7. import org.springframework.core.annotation.Order;
    8. import org.springframework.stereotype.Component;
    10. import java.lang.reflect.Method;
    12. @Aspect
    13. @Order(-1)// 保证该AOP在@Transactional之前运行
    14. @Component
    15. public class DataSourceWithAspect {
    17.     /**
    18.      * 使用DataSourceWith注解就拦截
    19.      */
    20.     @Pointcut("@annotation(cn.edu.zzuli.hnsmz.annotation.DataSourceWith)||@within(cn.edu.zzuli.hnsmz.annotation.DataSourceWith)")
    21.     public void doPointcut() {
    23.     }
    25.     /**
    26.      * 方法前，为了在事务前设置
    27.      */
    28.     @Before("doPointcut()")
    29.     public void doBefore(JoinPoint joinPoint) {
    30.         MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
    31.         Method method = methodSignature.getMethod();
    32.         // 获取注解对象
    33.         DataSourceWith dataSource = method.getAnnotation(DataSourceWith.class);
    34.         if (dataSource == null) {
    35.             // 方法没有就获取类上的
    36.             dataSource = method.getDeclaringClass().getAnnotation(DataSourceWith.class);
    37.         }
    38.         String key = dataSource.key();
    39.         RoutingDataSourceHolder.setDataSource(key);
    40.     }
    42.     @After("doPointcut()")
    43.     public void doAfter(JoinPoint joinPoint) {
    44.         RoutingDataSourceHolder.clearDataSource();
    45.     }
    47. }

    6、使用

    1. @DataSourceWith(key = DataSourceConfigurer.SLAVE_DATASOURCE)
    2. public Long selectById(String id) {
    3.     return studentService.selectById(id);
    4. }