<dependency>
  <groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!-- aop切面-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!--druid連接池-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.2.20</version>
</dependency>
<!--mysql驅(qū)動(dòng)-->
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
</dependency>
<!--MybatisPlus-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.3.1</version>
</dependency>

#application.yml
 
server:
  port: 8000
spring:
  profiles:
    active: druid

# 數(shù)據(jù)源配置
spring:
datasource:
    type:com.alibaba.druid.pool.DruidDataSource
    driverClassName:com.mysql.cj.jdbc.Driver
    druid:
      # 主庫數(shù)據(jù)源
      master:
        url:jdbc:mysql://localhost:3306/study?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
        username:root
        password:123456
      # 從庫數(shù)據(jù)源
      slave:
        # 從數(shù)據(jù)源開關(guān)/默認(rèn)關(guān)閉
        enabled:true
        url:jdbc:mysql://localhost:3306/t_lyj?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
        username:root
        password:123456
      # 初始連接數(shù)
      initialSize:5
      # 最小連接池?cái)?shù)量
      minIdle:10
      # 最大連接池?cái)?shù)量
      maxActive:20
      # 配置獲取連接等待超時(shí)的時(shí)間
      maxWait:60000
      # 配置連接超時(shí)時(shí)間
      connectTimeout:30000
      # 配置網(wǎng)絡(luò)超時(shí)時(shí)間
      socketTimeout:60000
      # 配置間隔多久才進(jìn)行一次檢測(cè)，檢測(cè)需要關(guān)閉的空閑連接，單位是毫秒
      timeBetweenEvictionRunsMillis:60000
      # 配置一個(gè)連接在池中最小生存的時(shí)間，單位是毫秒
      minEvictableIdleTimeMillis:300000
      # 配置一個(gè)連接在池中最大生存的時(shí)間，單位是毫秒
      maxEvictableIdleTimeMillis:900000

/**
 * 數(shù)據(jù)源
 * 
 * @author ruoyi
 */
public enum DataSourceType
{
    /**
     * 主庫
     */
    MASTER,
 
    /**
     * 從庫
     */
    SLAVE
}

@Component
publicfinalclass SpringUtils implements BeanFactoryPostProcessor, ApplicationContextAware 
{
    /** Spring應(yīng)用上下文環(huán)境 */
    privatestatic ConfigurableListableBeanFactory beanFactory;

    privatestatic ApplicationContext applicationContext;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException 
    {
        SpringUtils.beanFactory = beanFactory;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException 
    {
        SpringUtils.applicationContext = applicationContext;
    }

    /**
     * 獲取對(duì)象
     *
     * @param name
     * @return Object 一個(gè)以所給名字注冊(cè)的bean的實(shí)例
     * @throws BeansException
     *
     */
    @SuppressWarnings("unchecked")
    publicstatic <T> T getBean(String name) throws BeansException
    {
        return (T) beanFactory.getBean(name);
    }

    /**
     * 獲取類型為requiredType的對(duì)象
     *
     * @param clz
     * @return
     * @throws BeansException
     *
     */
    publicstatic <T> T getBean(Class<T> clz) throws BeansException
    {
        T result = (T) beanFactory.getBean(clz);
        return result;
    }

    /**
     * 如果BeanFactory包含一個(gè)與所給名稱匹配的bean定義，則返回true
     *
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name)
    {
        return beanFactory.containsBean(name);
    }

    /**
     * 判斷以給定名字注冊(cè)的bean定義是一個(gè)singleton還是一個(gè)prototype。 如果與給定名字相應(yīng)的bean定義沒有被找到，將會(huì)拋出一個(gè)異常（NoSuchBeanDefinitionException）
     *
     * @param name
     * @return boolean
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.isSingleton(name);
    }

    /**
     * @param name
     * @return Class 注冊(cè)對(duì)象的類型
     * @throws NoSuchBeanDefinitionException
     *
     */
    publicstatic Class<?> getType(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getType(name);
    }

    /**
     * 如果給定的bean名字在bean定義中有別名，則返回這些別名
     *
     * @param name
     * @return
     * @throws NoSuchBeanDefinitionException
     *
     */
    publicstatic String[] getAliases(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getAliases(name);
    }

    /**
     * 獲取aop代理對(duì)象
     * 
     * @param invoker
     * @return
     */
    @SuppressWarnings("unchecked")
    publicstatic <T> T getAopProxy(T invoker)
    {
        return (T) AopContext.currentProxy();
    }

    /**
     * 獲取當(dāng)前的環(huán)境配置，無配置返回null
     *
     * @return 當(dāng)前的環(huán)境配置
     */
    publicstatic String[] getActiveProfiles()
    {
        return applicationContext.getEnvironment().getActiveProfiles();
    }

    /**
     * 獲取當(dāng)前的環(huán)境配置，當(dāng)有多個(gè)環(huán)境配置時(shí)，只獲取第一個(gè)
     *
     * @return 當(dāng)前的環(huán)境配置
     */
    public static String getActiveProfile()
    {
        final String[] activeProfiles = getActiveProfiles();
        return StringUtils.isNotEmpty(Arrays.toString(activeProfiles)) ? activeProfiles[0] : null;
    }

    /**
     * 獲取配置文件中的值
     *
     * @param key 配置文件的key
     * @return 當(dāng)前的配置文件的值
     *
     */
    public static String getRequiredProperty(String key)
    {
        return applicationContext.getEnvironment().getRequiredProperty(key);
    }
}

/**
 * 自定義多數(shù)據(jù)源切換注解
 *
 * 優(yōu)先級(jí)：先方法，后類，如果方法覆蓋了類上的數(shù)據(jù)源類型，以方法的為準(zhǔn)，否則以類上的為準(zhǔn)
 *
 * @author lyj
 */
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataSource
{
    /**
     * 切換數(shù)據(jù)源名稱
     */
    public DataSourceType value() default DataSourceType.MASTER;
}

@Configuration
publicclass DruidConfig {

   @Bean
   @ConfigurationProperties("spring.datasource.druid.master")
   public DataSource masterDataSource(DruidProperties druidProperties){
       DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
       return druidProperties.dataSource(dataSource);
   }

   @Bean
   @ConfigurationProperties("spring.datasource.druid.slave")
   @ConditionalOnProperty(prefix = "spring.datasource.druid.slave", name = "enabled", havingValue = "true")
   public DataSource slaveDataSource(DruidProperties druidProperties) {
       DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
       return druidProperties.dataSource(dataSource);
   }

   @Bean(name = "dynamicDataSource")
   @Primary
   public DynamicDataSource dataSource(DataSource masterDataSource) {
       Map<Object, Object> targetDataSources = new HashMap<>();
       targetDataSources.put(DataSourceType.MASTER.name(), masterDataSource);
       setDataSource(targetDataSources, DataSourceType.SLAVE.name(), "slaveDataSource");
       returnnew DynamicDataSource(masterDataSource, targetDataSources);
   }


   /**
    * 設(shè)置數(shù)據(jù)源
    *
    * @param targetDataSources 備選數(shù)據(jù)源集合
    * @param sourceName 數(shù)據(jù)源名稱
    * @param beanName bean名稱
    */
   public void setDataSource(Map<Object, Object> targetDataSources, String sourceName, String beanName) {
       try {
           DataSource dataSource = SpringUtils.getBean(beanName);
           targetDataSources.put(sourceName, dataSource);
       } catch (Exception e) {
       }
   }
}

/**
 * 動(dòng)態(tài)數(shù)據(jù)源
 * 
 * @author lyj
 */
publicclass DynamicDataSource extends AbstractRoutingDataSource {
    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources)
    {
        //設(shè)置默認(rèn)數(shù)據(jù)源
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        //設(shè)置目標(biāo)數(shù)據(jù)源的映射
        super.setTargetDataSources(targetDataSources);
        //初始化
        super.afterPropertiesSet();
    }

    @Override
    protected Object determineCurrentLookupKey()
    {
        return DynamicDataSourceContextHolder.getDataSourceType();
    }
}

/**
 * 數(shù)據(jù)源切換處理
 * 
 * @author lyj
 */
publicclass DynamicDataSourceContextHolder
{
    publicstaticfinal Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);

    /**
     * 使用ThreadLocal維護(hù)變量，ThreadLocal為每個(gè)使用該變量的線程提供獨(dú)立的變量副本，
     * 所以每一個(gè)線程都可以獨(dú)立地改變自己的副本，而不會(huì)影響其它線程所對(duì)應(yīng)的副本。
     */
    privatestaticfinal ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    /**
     * 設(shè)置數(shù)據(jù)源的變量
     */
    public static void setDataSourceType(String dsType)
    {
        log.info("切換到{}數(shù)據(jù)源", dsType);
        CONTEXT_HOLDER.set(dsType);
    }

    /**
     * 獲得數(shù)據(jù)源的變量，默認(rèn)使用主數(shù)據(jù)源
     */
    public static String getDataSourceType()
    {
        return CONTEXT_HOLDER.get() == null ? DataSourceType.MASTER.name() : CONTEXT_HOLDER.get();
    }

    /**
     * 清空數(shù)據(jù)源變量
     */
    public static void clearDataSourceType()
    {
        CONTEXT_HOLDER.remove();
    }
}

@Aspect
@Order(1)
@Component
publicclass DataSourceAspect {


    @Pointcut("@annotation(com.LYJ.study.DynamicDataSource.annocation.DataSource)"
            + "|| @within(com.LYJ.study.DynamicDataSource.annocation.DataSource)")
    public void dsPointCut(){}

    @Around("dsPointCut()")

    public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
        DataSource dataSource = getDataSource(joinPoint);
        if (dataSource != null){
            DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
        }
        try {
            return joinPoint.proceed();
        }
        finally {
            // 銷毀數(shù)據(jù)源 在執(zhí)行方法之后
            DynamicDataSourceContextHolder.clearDataSourceType();
        }
    }

    /**
     * 獲取需要切換的數(shù)據(jù)源
     */
    public DataSource getDataSource(ProceedingJoinPoint point)
    {
        MethodSignature signature = (MethodSignature) point.getSignature();
        com.LYJ.study.DynamicDataSource.annocation.DataSource dataSource = AnnotationUtils.findAnnotation(signature.getMethod(), com.LYJ.study.DynamicDataSource.annocation.DataSource.class);
        if (Objects.nonNull(dataSource)) {
            return dataSource;
        }
        return AnnotationUtils.findAnnotation(signature.getDeclaringType(), DataSource.class);
    }
}

@Service
@RequiredArgsConstructor
@DataSource(value=DataSourceType.MASTER)
//@DataSource(value=DataSourceType.SLAVE)
publicclass UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    privatefinal UserMapper userMapper;
    @Override
    @DataSource(value=DataSourceType.MASTER)
    //@DataSource(value=DataSourceType.SLAVE)
    public List<User> queryAll() {
        return userMapper.selectList(null);
    }
}

//如果配置多數(shù)據(jù)源，繼續(xù)添加即可
public enum DataSourceType
{
    /**
     * 主庫
     */
    MASTER,
 
    /**
     * 從庫
     */
    SLAVE,
    /**
     * 從庫2
     */
    SLAVE2
}

<!--oracle驅(qū)動(dòng)-->
<dependency>
  <groupId>com.oracle</groupId>
  <artifactId>ojdbc6</artifactId>
  <version>11.2.0.3</version>
</dependency>

slave3:
  # 從數(shù)據(jù)源開關(guān)/默認(rèn)關(guān)閉
  enabled: true
  url: jdbc:oracle:thin:@127.0.0.1:1521:oracle
  username: root
  password: password