Druid多数据源配置(Datasurce动态切换)

已于 2023-12-20 10:06:06 修改
阅读量5.3k 收藏 22
点赞数 5
分类专栏： Mysql 文章标签： spring boot spring java
于 2021-07-29 15:11:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43695916/article/details/119210008
版权

Druid多数据源配置(Datasurce动态切换)

提示: 本材料只做个人学习参考,不作为系统的学习流程,请注意识别!!!

Druid

一. 直接上代码

  1. 多数据源切换自定义注解
package com.gateway.admin.datasources.annotation;

import java.lang.annotation.*;
/**
 * 多数据源注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
    String name() default "";
}
  1. 多数据源,切面处理类
package com.gateway.admin.datasources;

import com.gateway.admin.datasources.annotation.DataSource;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 多数据源，切面处理类
 */
@Aspect
@Component
public class DataSourceAspect implements Ordered {
    protected Logger logger = LoggerFactory.getLogger(getClass());
    
    /**
	 * 针对上面注解做切面拦截
 	 */
    @Pointcut("@annotation(com.gateway.admin.datasources.annotation.DataSource)")
    public void dataSourcePointCut() {}

    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        DataSource ds = method.getAnnotation(DataSource.class);
        if(ds == null){
        	//如果没有注解,使用默认数据源
            DynamicDataSource.setDataSource(DataSourceNames.FIRST);
        }else {
        	//根据注解中设置的数据源名称,选择对应的数据源
            DynamicDataSource.setDataSource(ds.name());
            logger.debug("set datasource is " + ds.name());
        }

        try {
            return point.proceed();
        } finally {
        	//清除数据源配置
            DynamicDataSource.clearDataSource();
        }
    }

    @Override
    public int getOrder() {
        return 1;
    }
}
  1. 动态数据源类,需要继承:AbstractRoutingDataSource
package com.gateway.admin.datasources;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import javax.sql.DataSource;
import java.util.Map;

/**
 * 动态数据源
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(targetDataSources);
        super.afterPropertiesSet();
    }

    @Override
    protected Object determineCurrentLookupKey() {
        return getDataSource();
    }

    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
    }

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

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

}

4 .数据源名称配置

package com.gateway.admin.datasources;

/**
 * 多数据源配置数据源
 */
public interface DataSourceNames {
    String FIRST = "first";
    String SECOND = "second";
    String THREE = "three";
    String FOUR = "four";
}

5 .多数据源配置类

package com.gateway.admin.datasources;

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

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

/**
 * 多数据源配置类
 */
@Configuration
public class DynamicDataSourceConfig {

	//如果ioc容器中,同一个类型有多个bean,则bean的名称为方法的名称
    @Bean
    @ConfigurationProperties("spring.datasource.druid.first")
    public DataSource firstDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid.second")
    public DataSource secondDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid.three")
    public DataSource threeDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid.four")
    public DataSource fourDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @Primary
    public DynamicDataSource dataSource(DataSource firstDataSource, DataSource secondDataSource, DataSource threeDataSource, DataSource fourDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceNames.FIRST, firstDataSource);
        targetDataSources.put(DataSourceNames.SECOND, secondDataSource);
        targetDataSources.put(DataSourceNames.THREE, threeDataSource);
        targetDataSources.put(DataSourceNames.FOUR, fourDataSource);
        return new DynamicDataSource(firstDataSource, targetDataSources);
    }
}
  1. yml部分数据源相关配置
spring:
    datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.jdbc.Driver
        druid:
            first:  #db1
                url: jdbc:mysql://127.0.0.1:3306/db1?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false
                username: root
                password: root
            second:  #db2
                url: jdbc:mysql://127.0.0.1:3306/db2?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false
                username: root
                password: root
            three:  #db3
                url: jdbc:mysql://127.0.0.1:3306/db3?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false
                username: root
                password: root
            four:   #db4
                url: jdbc:mysql://127.0.0.1:3306/db4?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false
                username: root
                password: root
  1. 动态调用数据源示例代码
	//通过@DataSource以及name,动态指定对应的数据源
   	@DataSource(name = DataSourceNames.SECOND)
    public void test(String param) {
        testMapper.test(param);
    }

二. AbstractRoutingDataSource 补充

部分源码分析

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {

    @Nullable//目标数据源
    private Map<Object, Object> targetDataSources;

    @Nullable//默认数据源
    private Object defaultTargetDataSource;

    @Nullable//解析的数据源
    private Map<Object, DataSource> resolvedDataSources;

    @Nullable//解析默认的数据源
    private DataSource resolvedDefaultDataSource;

    @Override
    public void afterPropertiesSet() {
        if (this.targetDataSources == null) {
            throw new IllegalArgumentException("Property 'targetDataSources' is required");
        }
        this.resolvedDataSources = new HashMap<>(this.targetDataSources.size());
        this.targetDataSources.forEach((key, value) -> {
            Object lookupKey = resolveSpecifiedLookupKey(key);
            DataSource dataSource = resolveSpecifiedDataSource(value);
            this.resolvedDataSources.put(lookupKey, dataSource);
        });
        if (this.defaultTargetDataSource != null) {
        	//设置解析的默认数据源
            this.resolvedDefaultDataSource = resolveSpecifiedDataSource(this.defaultTargetDataSource);
        }
    }

	//数据源对应的key，默认和目标数据源map中的key一致
    protected Object resolveSpecifiedLookupKey(Object lookupKey) {
        return lookupKey;
    }

	 //将指定的数据源对象解析为 DataSource 实例
	 protected DataSource resolveSpecifiedDataSource(Object dataSource) throws IllegalArgumentException {
	       if (dataSource instanceof DataSource) {
	           return (DataSource) dataSource;
	       }
	       else if (dataSource instanceof String) {
	           return this.dataSourceLookup.getDataSource((String) dataSource);
	       }
	       else {
	           throw new IllegalArgumentException(
	                   "Illegal data source value - only [javax.sql.DataSource] and String supported: " + dataSource);
	       }
	   }

//==========================================获取数据库连接=========================================

    @Override
    public Connection getConnection() throws SQLException {
        return determineTargetDataSource().getConnection();
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
    	//从特定的数据源中获取对应的数据库连接对象
        return determineTargetDataSource().getConnection(username, password);
    }

    protected DataSource determineTargetDataSource() {
        Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
        //DynamicDataSource 中对 determineCurrentLookupKey()方法进行了重写
        Object lookupKey = determineCurrentLookupKey();
        //resolvedDataSources 对应的map中获取对应的数据源
        DataSource dataSource = this.resolvedDataSources.get(lookupKey);
        if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
            dataSource = this.resolvedDefaultDataSource;
        }
        if (dataSource == null) {
            throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
        }
        return dataSource;
    }

    @Nullable
    protected abstract Object determineCurrentLookupKey();

}

三. 多数据源 + ShardingJDBC 数据源整合

现有需求: 在多数据源能够动态切换的前提下,其中某个库中的表需要实现分表操作,例如:上述多数据源配置中的second 数据库中某个表需要实现分表操作,我们采用ShardingJDBC实现。此时second 数据源的配置需要更改为ShardingJDBC对应的数据源，如下面更改后的多数据源配置：

原来多数据源配置类

package com.gateway.admin.datasources;

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

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

/**
 * 多数据源配置类
 */
@Configuration
public class DynamicDataSourceConfig {

	//如果ioc容器中,同一个类型有多个bean,则bean的名称为方法的名称
    @Bean
    @ConfigurationProperties("spring.datasource.druid.first")
    public DataSource firstDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid.second")
    public DataSource secondDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid.three")
    public DataSource threeDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid.four")
    public DataSource fourDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @Primary
    public DynamicDataSource dataSource(DataSource firstDataSource, DataSource secondDataSource, DataSource threeDataSource, DataSource fourDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceNames.FIRST, firstDataSource);
        targetDataSources.put(DataSourceNames.SECOND, secondDataSource);
        targetDataSources.put(DataSourceNames.THREE, threeDataSource);
        targetDataSources.put(DataSourceNames.FOUR, fourDataSource);
        return new DynamicDataSource(firstDataSource, targetDataSources);
    }
}

整合ShardingJDBC 后，多数据源配置类

package com.gateway.admin.datasources;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.apache.shardingsphere.shardingjdbc.jdbc.adapter.AbstractDataSourceAdapter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Primary;

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

/**
 * 多数据源配置类
 */
@Configuration
public class DynamicDataSourceConfig {
   @Bean
    @ConfigurationProperties("spring.datasource.druid.first")
    public DataSource firstDataSource() {
        return DruidDataSourceBuilder.create().build();
    }
    
    @Bean
    @ConfigurationProperties("spring.datasource.druid.three")
    public DataSource threeDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid.four")
    public DataSource fourDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

//该数据源为shardingjdbc对应的数据源,可通过java代码配置,也可通过配置文件配置,此处我们采用yml配置,配置文件下面会给出
    /**
     * shardingjdbc有四种数据源，需要根据业务注入不同的数据源
     *
     * <p>1. 未使用分片, 脱敏的名称(默认): shardingDataSource;
     * <p>2. 主从数据源: masterSlaveDataSource;
     * <p>3. 脱敏数据源：encryptDataSource;
     * <p>4. 影子数据源：shadowDataSource
     *
     */
    @Lazy
    @Resource(name = "shardingDataSource")
    private AbstractDataSourceAdapter shardingDataSource;

    @Bean
    @Primary
    public DynamicDataSource dataSource(DataSource firstDataSource, DataSource threeDataSource, DataSource fourDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceNames.FIRST, firstDataSource);
        targetDataSources.put(DataSourceNames.SECOND, shardingDataSource);
        targetDataSources.put(DataSourceNames.THREE, threeDataSource);
        targetDataSources.put(DataSourceNames.FOUR, fourDataSource);
        return new DynamicDataSource(firstDataSource, targetDataSources);
    }
}

对应的yml配置文件为(我们此处只是针对单个库做分表操作):

# Tomcat
server:
  tomcat:
    uri-encoding: UTF-8
    max-threads: 1000
    min-spare-threads: 30
  port: 8888

spring:
  #shardingjdbc--------------------------------------------------------------------------------------------------------
  main:
    allow-bean-definition-overriding: true
  shardingsphere:
    props:
      sql:
        show: true
    dataSource:
      names: ds0
      ds0:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/gateway_stable?useUnicode=true&characterEncoding=utf-8&useSSL=false
        username: root
        password: root
    sharding:
      tables:
        t_order:
          logicTable: t_order
          actualDataNodes: ds0.t_order$->{1..2}
          tableStrategy:
#            standard:
#              shardingColumn: id
#              preciseAlgorithmClassName: com.personal.datasources.MonthPreciseShardingAlgorithm
#              rangeAlgorithmClassName:
            inline:
              shardingColumn: id
              algorithmExpression: t_order$->{id % 2 + 1}
          keyGenerator:
            type: SNOWFLAKE
            column: id
            worker:
              id: 1

  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.jdbc.Driver
    druid:
      first:  #数据源1
        url: jdbc:mysql://127.0.0.1:3306/wanshu_admin?useUnicode=true&characterEncoding=utf-8&useSSL=false
        username: root
        password: 123456
#      second:  #数据源2
#        url: jdbc:mysql://127.0.0.1:3306/gateway_stable?useUnicode=true&characterEncoding=utf-8&useSSL=false
#        username: root
#        password: root
      three:  #数据源3
        url: jdbc:mysql://127.0.0.1:3306/datacenter_stable?useUnicode=true&characterEncoding=utf-8&useSSL=false
        username: root
        password: 123456
      four:   #数据源4
        url: jdbc:mysql://127.0.0.1:3306/chuanglan_risk_control?useUnicode=true&characterEncoding=utf-8&useSSL=false
        username: root
        password: 123456
      initial-size: 10
      max-active: 100
      min-idle: 10
      max-wait: 60000
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      validation-query: SELECT 1 FROM DUAL
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        login-username: admin
        login-password: admin
      filter:
        stat:
          log-slow-sql: true
          slow-sql-millis: 1000
          merge-sql: false
        wall:
          config:
            multi-statement-allow: true


mybatis:
  mapper-locations: classpath:mapper/**/*.xml

关于shardingJDBC的相关知识,可参考:shardingJDBC分库分表

过了火的你
关注
专栏目录
druid 多数据源_SpringBoot 配置Druid多数据源并实现动态切换
weixin_39565777的博客
11-26 1395
概述前面我们已经介绍过了对MyBatis、Druid的整合,接下来我们在之前的基础上做扩展,实现对Druid多数据源的配置以及动态切换数据源。问题:多数据源使用场景有哪些呢?回答:在业务发展中,数据的不断增长,会有读写分离的需求,以及按业务模块分库的需求,这样我们的数据源会越来越多,在项目中就有了在各个数据源之间来回切换的场景。实践如何配置Druid多数据源并实现动态切换首先是启动类的改造,在@S...
Spring配置多个数据源并实现动态切换示例
08-30
本篇文章主要介绍了Spring配置多个数据源并实现动态切换示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
MyBatis初级实战之四：druid多数据源
最新发布
2401_87254533的博客
09-22 1272
server:port: 8080spring:#1.JDBC数据源druid:first:#初始化连接池的连接数量 大小，最小，最大#配置获取连接等待超时的时间#配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒。
JAVA：Springboot 集成 Druid 多数据源配置教程
木头
06-26 4341
简要的阐述了springboot+druid配置多数据源的实现。
spring boot 配置 Druid
从零开始的程序员之路
08-01 4001
       Druid是阿里托管于GitHub的开源的数据库链接池工具，他封装提供并聚合了各种统计，通过简单的配置就可以实现sql防火墙和防注入功能，是当下最强大，功能最全的数据库连接池工具。       因项目需要，配置了连接池，现项目上线，特此记录下，方便以后使用。       相关环境版本：jdk版本1.8，springboot版本1.5.10，druid版本 首先引入maven配置...
Spring Boot配置多数据源并实现Druid自动切换
热门推荐
数组斯诺
07-19 6万+
Spring Boot配置多数据源 配置yml文件 主数据源配置 从数据源配置 使用daoSpring Boot配置多数据源配置yml文件这里并没有对spring.datasource配置数据源，因为增加新数据源后，系统会覆盖由spring.datasource自动配置的内容。 这里自定义了两个数据源spring.datasource.cmmi和spring.datasource.zentaosp
DruidDataSource数据源配置详解
06-29
可以帮助你了解,以及配置实现DruidDataSource数据源的配置
Druid配置多数据源
u012970850的专栏
03-18 1474
@Slf4j @Configuration @MapperScan(basePackages = MerchantDruidConfig.PACKAGE, sqlSessionTemplateRef = "merchantSqlSessionTemplate") public class MerchantDruidConfig { static final String PACKAGE = "com.xx.mapper"; static final String MAPPER_LOC..
基于Druid的多数据源配置（最简单的方式）
记录并分享一些日常工作和学习笔记
06-30 1万+
多数据源的配置方式，只需三步搞定
Springboot+druid+多数据源
fonjames的专栏
05-30 1658
1.在Spring Boot中配置两个不同的Oracle数据源，你需要在配置类中分别定义两个数据源，并使用AbstractRoutingDataSource来路由到不同的数据源。当然，如果你的应用需要配置多个Druid数据源，并且每个数据源的密码都需要通过自定义的解密方法解密，你可以扩展上面的配置方法以适应多数据源的场景。这样，每次调用到数据源的地方，都会根据你的逻辑动态切换到不同的数据源。3. 使用多数据源在业务代码中，你可以通过@DS注解器来指定使用特定的数据源，或者不指定时使用默认的数据源。
druid 多数据源_「Java」 - SpringBoot & Druid
weixin_39543835的博客
11-29 442
一、Druid简介Druid是阿里巴巴开源平台上的一个项目，整个项目由数据库连接池、插件框架和SQL解析器组成。该项目主要是为了扩展JDBC的一些限制，可以让程序员实现一些特殊的需求，比如向密钥服务请求凭证、统计SQL信息、SQL性能收集、SQL注入检查、SQL翻译等，程序员可以通过定制来实现自己需要的功能。Druid首先是一个数据库连接池，但它不仅仅是一个数据库连接池，它还包含一个ProxyDr...
Springboot Druid多数据源 多线程
05-14
一个基于Springboot的小项目，采用Druid多数据源的设计，可以同时操作Mysql与Oracle数据库，配置了多线程处理任务，为刚接触springboot的朋友提供参考。
Springboot+Mybatis+Druid多数据源配置
01-14
本教程将围绕"Springboot+Mybatis+Druid多数据源配置"这一主题，详细介绍如何实现这一功能。 首先，Spring Boot简化了Spring应用的初始化和配置。在多数据源场景下，我们可以通过Spring Boot的@...
通过springboot+mybatis+druid配置动态数据源
08-25
一级标题：动态数据源配置 在 SpringBoot 项目中，使用 Druid 可以轻松地配置动态数据源。Druid 是一个基于 Java 的数据库连接池实现，它提供了高效、可靠的数据库连接池管理机制。通过使用 Druid，我们可以轻松地...
springboot多数据源,DruidDataSource多数据源切换，不重启项目，修改数据库名解决方案
01-04
项目背景： 1. Springboot项目 2. 一个主数据源，数据名称库不变。 3. 一个副数据源，数据库名称每天都在...4.不重启项目切换数据源。 5.项目介绍： https://blog.csdn.net/qq_38105536/article/details/122296977
SpringBoot+Druid多数据源配置
从入门到放弃的博客
01-20 5111
以下内容转载自：https://my.oschina.net/u/3681868/blog/1813011 一.引入Jar包: <dependency> <!-- MySql驱动 --> <groupId>mysql</groupId> <artifactId>mysql-connector-java</art...
Springboot：多数据源（druid）
weixin_44204274的博客
06-14 164
多数据源 pom依赖 <!-- jdbc --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artif...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值