SpringBoot 动态数据源

已于 2022-07-05 19:36:47 修改
阅读量3k 收藏 9
点赞数 2
分类专栏： 笔记 文章标签： spring boot java spring
于 2022-01-19 19:50:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuwenjingrenca/article/details/122566623
版权

解决多租户，多数据源的问题
本demo的技术栈，SpringBoot，SpringCloud Alibaba(dubbo, nacos)，hikaricp，druid，mysql

项目地址：https://gitee.com/xuwenjingrencai/dynamic-datasource-spring-boot-starter

1、动态数据源原理

利用aop做的动态数据源的切换，每个线程绑定一个数据源

2、动态数据源基础类

DynamicDatasource

public class DynamicDatasource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDatasourceHandler.getDatasource();
    }

    @Override
    protected DataSource determineTargetDataSource() {
        Object o = determineCurrentLookupKey();
        if (Objects.nonNull(o) && DynamicDatasourceUtil.DATASOURCES.containsKey(o)) {
            return DynamicDatasourceUtil.DATASOURCES.get(o);
        }
        throw new RuntimeException("数据源不存在");
    }
}

DynamicDatasourceHandler

@Slf4j
public class DynamicDatasourceHandler {
    private static ThreadLocal<String> threadDatasource = new InheritableThreadLocal<>();

    public static void setDatasource(String dataSource) {
        threadDatasource.set(dataSource);
    }

    public static String getDatasource() {
        return threadDatasource.get();
    }

    public static void remove() {
        threadDatasource.remove();
    }

    public static void close(DataSource dataSource) {
        Class<? extends DataSource> clazz = dataSource.getClass();
        try {
            Method close = clazz.getDeclaredMethod("close");
            close.invoke(clazz);
            log.debug("该数据源已关闭");
        } catch (Exception e) {
            log.warn("动态数据源关闭错误, 数据源名称 [{}]", dataSource, e);
        }
    }
}

DynamicDatasourceUtil ，对连接池做了简单适配，代码有点长

@Slf4j
public class DynamicDatasourceUtil {

    public static final String MASTER = "master";

    public static final Map<String, DataSource> DATASOURCES = new ConcurrentHashMap<>();

    public static void createDatasource(DynamicDatasourceProperty property) {
        if (DynamicDatasourceUtil.DATASOURCES.containsKey(property.getKey())) {
//            return DATASOURCES.get(property.getKey());
            return;
        }
        DataSource dataSource = null;
        if (Objects.nonNull(property.getType()) && ("com.zaxxer.hikari.HikariDataSource".equals(property.getType()) || "hikari".equals(property.getType()))) {
            dataSource = createHikariDataSource(property);
        } else if (Objects.nonNull(property.getType()) && ("com.alibaba.druid.pool.DruidDataSource".equals(property.getType()) || "druid".equals(property.getType()))) {
            dataSource = createDruidDataSource(property);
        } else {
            dataSource = createDefaultDataSource(property);
        }
        log.info("创建数据源: key: {}, type: {}", property.getKey(), property.getType());
        DynamicDatasourceUtil.DATASOURCES.putIfAbsent(property.getKey(), dataSource);
    }

    private static DataSource createDruidDataSource(DynamicDatasourceProperty property) {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(property.getDriverClassName());
        dataSource.setUrl(property.getUrl());
        dataSource.setUsername(property.getUsername());
        dataSource.setPassword(property.getPassword());
        if (Objects.nonNull(property.getMaxPoolSize())) {
            dataSource.setMaxActive(property.getMaxPoolSize());
        }
        if (Objects.nonNull(property.getInitSize())) {
            dataSource.setInitialSize(property.getInitSize());
        }
        if (Objects.nonNull(property.getMinIdle())) {
            dataSource.setMinIdle(property.getMinIdle());
        }
        if (Objects.nonNull(property.getPoolName())) {
            dataSource.setName(property.getPoolName());
        }
        if (Objects.nonNull(property.getMaxWait())) {
            dataSource.setMaxWait(property.getMaxWait());
        }
        if (Objects.nonNull(property.getValidationQuery())) {
            dataSource.setValidationQuery(property.getValidationQuery());
        }
        return dataSource;
    }

    private static DataSource createDefaultDataSource(DynamicDatasourceProperty property) {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(property.getDriverClassName());
        dataSource.setUrl(property.getUrl());
        dataSource.setUsername(property.getUsername());
        dataSource.setPassword(property.getPassword());
        return dataSource;
    }

    private static HikariDataSource createHikariDataSource(DynamicDatasourceProperty property) {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setDriverClassName(property.getDriverClassName());
        dataSource.setJdbcUrl(property.getUrl());
        dataSource.setUsername(property.getUsername());
        dataSource.setPassword(property.getPassword());
        if (Objects.nonNull(property.getMaxPoolSize())) {
            dataSource.setMaximumPoolSize(property.getMaxPoolSize());
        }
        if (Objects.nonNull(property.getMinIdle())) {
            dataSource.setMinimumIdle(property.getMinIdle());
        }
        if (Objects.nonNull(property.getPoolName())) {
            dataSource.setPoolName(property.getPoolName());
        }
        if (Objects.nonNull(property.getIdleTimeout())) {
            dataSource.setIdleTimeout(property.getIdleTimeout());
        }
        if (Objects.nonNull(property.getMaxLifetime())) {
            dataSource.setMaxLifetime(property.getMaxLifetime());
        }
        if (Objects.nonNull(property.getConnectionTimeout())) {
            dataSource.setConnectionTimeout(property.getConnectionTimeout());
        }
        return dataSource;
    }
}

DynamicDatasourceProperty ，配置类

@Data
public class DynamicDatasourceProperty {

    private String key;

    private String type;

    private String url;

    private String driverClassName;

    private String username;

    private String password;

    //可选参数
    private Integer maxPoolSize;

    private Integer minIdle;

    private String poolName;

    private Long idleTimeout;

    private Long maxLifetime;

    private Long connectionTimeout;

    //druid
    private Integer initSize;

    private Long maxWait;

    private String validationQuery;
}

DataSourceConfig ，注册动态数据源，这里为了和springboot的固定数据源做兼容，用上了@ConditionalOnProperty，当属性为true的时候，切换至动态数据源，否则走springboot的固定数据源

@Data
@Component
@ConditionalOnProperty(name = "spring.dynamicdatasource.enabled", havingValue = "true")
@ConfigurationProperties(prefix = "spring.dynamicdatasource")
public class DataSourceConfig implements InitializingBean {

    private List<DynamicDatasourceProperty> ds = new ArrayList<>();

    private Map<String, DynamicDatasourceProperty> dsMap;

    @Override
    public void afterPropertiesSet() throws Exception {
        dsMap = ds.stream().collect(Collectors.toConcurrentMap(DynamicDatasourceProperty::getKey, x->x));
    }

    @Primary
    @Bean
    public DataSource dataSource() {
        DynamicDatasourceProperty master = dsMap.get(DynamicDatasourceUtil.MASTER);
        DynamicDatasourceUtil.createDatasource(master);
        DynamicDatasource dynamicDatasource = new DynamicDatasource();
        dynamicDatasource.setDefaultTargetDataSource(DynamicDatasourceUtil.DATASOURCES.get(DynamicDatasourceUtil.MASTER));
        dynamicDatasource.setTargetDataSources(new HashMap<>());
        return dynamicDatasource;
    }
}

3、切面

切面注解，DynamicDatasourceAop ，为什么这么写，下面会讲解

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
@Transactional
public @interface DynamicDatasourceAop {
    @AliasFor(annotation = Transactional.class)
    String value() default "";

    @AliasFor(annotation = Transactional.class)
    String transactionManager() default "";

    @AliasFor(annotation = Transactional.class)
    Propagation propagation() default Propagation.REQUIRED;

    @AliasFor(annotation = Transactional.class)
    Isolation isolation() default Isolation.DEFAULT;

    @AliasFor(annotation = Transactional.class)
    int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;

    @AliasFor(annotation = Transactional.class)
    boolean readOnly() default false;

    @AliasFor(annotation = Transactional.class)
    Class<? extends Throwable>[] rollbackFor() default {};

    @AliasFor(annotation = Transactional.class)
    String[] rollbackForClassName() default {};

    @AliasFor(annotation = Transactional.class)
    Class<? extends Throwable>[] noRollbackFor() default {};

    @AliasFor(annotation = Transactional.class)
    String[] noRollbackForClassName() default {};
}

切面类，DynamicDatasourceAspect

@Configuration
@Slf4j
@Aspect
@Order(value = Ordered.HIGHEST_PRECEDENCE + 10)
@RequiredArgsConstructor
@ConditionalOnProperty(name = "spring.dynamicdatasource.enabled", havingValue = "true")
public class DynamicDatasourceAspect {

    @Autowired
    private DataSourceConfig dataSourceConfig;

    @Before("@annotation(DynamicDatasourceAop)")
    public void before(JoinPoint joinpoint) {
        BaseParam baseParam = null;
        try {
            Object[] args = joinpoint.getArgs();
            for (Object o : args) {
                if (o instanceof BaseParam) {
                    baseParam = (BaseParam) o;
                }
            }
            if (baseParam == null) {
                throw new RuntimeException("没有数据源");
            }
            if (DynamicDatasourceUtil.DATASOURCES.containsKey(baseParam.getDataKey())) {
                DynamicDatasourceHandler.setDatasource(baseParam.getDataKey());
            } else {
                if (dataSourceConfig.getDsMap().containsKey(baseParam.getDataKey())) {
                    DynamicDatasourceUtil.createDatasource(dataSourceConfig.getDsMap().get(baseParam.getDataKey()));
                    DynamicDatasourceHandler.setDatasource(baseParam.getDataKey());
                } else {
                    throw new RuntimeException("数据源不存在");
                }
            }
        } catch (Throwable e) {
            log.error(e.getMessage(), e);
        }

    }

    @After("@annotation(DynamicDatasourceAop)")
    public void after(JoinPoint joinPoint) {
        DynamicDatasourceHandler.remove();
    }
}

4、配置

配置文件，不同的profile加载不同的nacos配置

#application.yml
server:
  port: 0

dubbo:
  application:
    name: cloud-dubbo-provider
  scan:
    base-packages: com.xuwj.provider.dubboService
  protocols:
    dubbo:
      id: dubbo
      name: dubbo
      port: -1

#bootstrap.yml
spring:
  profiles:
#    active: dev
#    active: test
    active: dynamicshort
#    active: dynamiclong
  application:
    name: cloud-dubbo-provider
  cloud:
    nacos:
      discovery:
        enabled: true
        register-enabled: true
        server-addr: 127.0.0.1:8848
        ephemeral: false
      config:
        enabled: true
        server-addr: 127.0.0.1:8848
        file-extension: yml

profile: dev

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
    username: root
    password: root
    druid:
      initial-size: 8
      max-active: 8
      min-idle: 8
      max-wait: 1000
      validation-query: 'select 1'

mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true
    auto-mapping-behavior: full
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath*:mapper/**/*Mapper.xml
  global-config:
    db-config:
      logic-not-delete-value: 1
      logic-delete-value: 0

profile: test

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/testv?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
    username: root
    password: root
    druid:
      initial-size: 8
      max-active: 8
      min-idle: 8
      max-wait: 1000
      validation-query: 'select 1'

mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true
    auto-mapping-behavior: full
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath*:mapper/**/*Mapper.xml
  global-config:
    db-config:
      logic-not-delete-value: 1
      logic-delete-value: 0

profile: dynamicshot

spring:
  # datasource:
  #   # type: com.alibaba.druid.pool.DruidDataSource
  #   driverClassName: com.mysql.cj.jdbc.Driver
  #   url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
  #   username: root
  #   password: root

  dynamicdatasource:
    enabled: true
    ds:
      - key: master
        type: hikari
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
        username: root
        password: root

      - key: test1
        type: hikari
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/test1?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
        username: root
        password: root

      - key: test2
        # type: hikari
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/test2?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
        username: root
        password: root

      - key: testv1
        type: hikari
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/testv1?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
        username: root
        password: root

      - key: testv2
        # type: druid
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/testv2?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
        username: root
        password: root

mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true
    auto-mapping-behavior: full
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath*:mapper/**/*Mapper.xml
  global-config:
    db-config:
      logic-not-delete-value: 1
      logic-delete-value: 0

5、总结

本案例可以支持根据配置文件的配置，走springboot的固定数据源或者动态数据源，动态数据源中根据key匹配不同的数据源，根据type开启对应的连接池，动态数据源是懒加载的方式，用到了，再去配置中寻找数据源的配置，初始化数据源。
如果仔细看，可以发现，本案例已经将事务和动态数据源的切面的注解合二为一了，具体的心路历程：
1、做动态数据源，切面注解 @DynamicDatasourceAop 中是空的，实现了动态切换数据源
2、支持事务，发现事务注解 @Transactional 只能放在 切面注解标的方法的内层方法上面，如果放在一起，会先执行事务，发现没有数据源，报错
3、将两个注解放在一起，思考事务和切面都是走的aop，应该可以规定一个顺序，此时发现开启事务的注解 @EnableTransactionManagement 里面的 int order() default Ordered.LOWEST_PRECEDENCE; 是最低优先级，于是在切面类上标注 @Order(value = Ordered.HIGHEST_PRECEDENCE)，报错，

java.lang.IllegalStateException: No MethodInvocation found: Check that an AOP invocation is in progress and that the ExposeInvocationInterceptor is upfront in the interceptor chain. Specifically, note that advices with order HIGHEST_PRECEDENCE will execute before ExposeInvocationInterceptor! In addition, ExposeInvocationInterceptor and ExposeInvocationInterceptor.currentInvocation() must be invoked from the same thread.

，寻找原因，是order的问题，于是修改order：@Order(value = Ordered.HIGHEST_PRECEDENCE + 10)，正常启动，事务和动态数据源兼容
4、合并注解，参考RestController的注解获得现在的注解

喜欢小苹果的码农
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot_dynamic_datasource.zip
06-10
Springboot2.0.3整合druid多数据源（不重启项目动态添加数据源）和数据监控，附源码 这是动态数据源的测试demo
Spring Boot使用动态数据源
qq_33594592的博客
10-10 9804
动态数据源 Hikari
springboot 实现 动态数据源
最新发布
m0_74295055的博客
03-27 290
*** 切换数据源名称.*//*** 多数据源处理*/@Aspect@Order(1)@Componenttry {// 销毁数据源 在执行方法之后/*** 获取需要切换的数据源*/
spring boot运行中添加、切换多数据源
qq_18268843的博客
04-11 1371
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0..
MyBatis-Plus多数据源dynamic-datasource解决多线程情境下数据源切换失效问题
拽着尾巴的鱼儿的博客
04-23 8751
MyBatis-Plus多数据源dynamic-datasource解决多线程情境下数据源切换失效问题
多数据源组件dynamic-datasource使用总结
zhouzhiwengang的专栏
01-25 1896
dynamic-datasource-spring-boot-starter 是一个基于springboot的快速集成多数据源的启动器。其支持。
SpringBoot——动态数据源（多数据源自动切换）
quanzhan_King的博客
06-13 1万+
日常的业务开发项目中只会配置一套数据源，如果需要获取其他系统的数据往往是通过调用接口， 或者是通过第三方工具比如kettle将数据同步到自己的数据库中进行访问。但是也会有需要在项目中引用多数据源的场景。自研数据迁移系统，至少需要新、老两套数据源，从老库读取数据写入新库自研读写分离中间件，系统流量增加，单库响应效率降低，引入读写分离方案，写入数据是一个数据源，读取数据是另一个数据源。
SpringBoot实现动态数据源配置
Bin哥厉害的博客
01-29 1291
DynamicDataSource继承AbstractRoutingDataSource。@Override这里的determineCurrentLookupKey方法，需要返回一个数据源。又有同学问了：DynamicDataSourceContextHolder 又是什么东西？看到 Context 应该很熟悉了，跟程序上下文有关。它的作用就是你查询数据库的时候用哪个数据源，就 setDataSource 哪个。还有点懵？没事，继续往下看。
Spring动态添加数据源（全自动）
专注技术交流、咨询
04-28 4785
1、现在网上所有写的动态数据源，都是假动态数据，都是预先知道要连接几个数据库，但这不满足具体真正需要动态添加连接数据库的需求； 2、在很多业务场景下，如项目默认连一个主数据库，服务启动后，因业务不停的变更，需要动态连接其它数据库处理数据，关键点是其它数据库，在服务启动前是不知道连接地址的，所以其它数据库的地址是无法预先配置在application.yml文件中
springBoot(六) 调用多数据源 dynamic-datasource
热门推荐
Tang的博客
09-21 2万+
1 dynamic-datasource简介 本框架只做 切换数据源 这件核心的事情，并不限制您的具体操作。 强烈建议在 主从模式 下遵循普遍的规则，以便他人能更轻易理解您的代码。 主数据库 建议 只执行 INSERT UPDATE DELETE 操作。 从数据库 建议 只执行 SELECT 操作。 2 使用方法 2.1 引入dynamic-datasource-spring-boot-sta...
SpringBoot实战（十）集成多数据源dynamic-datasource
ACGkaka的博客
12-19 4912
`dynamic-datasource-spring-boot-starter` 是一个基于 springboot 的快速集成多数据源的启动器。其支持 `Jdk 1.7+`、`SpringBoot 1.5.x` 和 `2.x.x`。
springboot 动态数据源的实现方法(Mybatis+Druid)
08-26
主要介绍了springboot 动态数据源的实现方法(Mybatis+Druid)，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springboot动态数据源.zip
06-28
spring boot 开发的动态数据源，很好用，也很经典，包含代码，可以互相交流学习。现在大家应用的比较广泛，所以提出来互相学习
基于springboot整理的分布式事务及动态数据源切换
04-17
整理的分布式事务 及动态数据源切换 基于数据库XA协议 maven 包可直接使用 maven 引入路径: <groupId>com.maple</groupId> <artifactId>DCSDataSourcesServer <version>0.0.1-SNAPSHOT 事务及数据源标签...
SpringBoot配置多数据源实现动态切换数据源
06-29
通过简单的demo实现SpingBoot多数据源配置并动态切换多数据源
springboot动态数据源代码实现，动态数据源代码，租户系统动态数据源代码
07-17
项目实现了使用SpringBoot实现动态数据源，实现步骤： 1.租户通过域名访问接口，用filter获取租户独立标识，比如 zhangsan.localhost.com 、lisi.localhost.com 2.实现AbstractRoutingDataSource类来跟进当前访问的...
springboot使用DynamicDataSource来动态切换数据源
weixin_46931883的博客
03-17 7637
在该类中重写**determineCurrentLookupKey()**方法，该方法返回一个字符串，用于指示当前要使用哪个数据源。
SpringBoot 动态数据源配置(附带可执行Demo)
优秀的程序员不应该是CRUD
10-28 3910
spring动态数据源，含完整demo,demo跑一遍基本都能明白
springboot 动态数据源
04-03
SpringBoot动态数据源是指在应用程序运行时根据需要动态地切换数据源，而不是在应用程序启动时就确定使用哪个数据源。动态数据源可以根据业务需求，灵活配置多个数据源，实现读写分离、多租户等功能。 SpringBoot动态数据源的实现通常包括以下步骤： 1. 配置多个数据源：在应用程序启动时，配置多个数据源，包括数据源的基本信息和连接池等参数。 2. 实现数据源路由：通过AOP、自定义注解等方式，拦截数据源访问的方法，并根据业务需求选择使用哪个数据源。 3. 动态切换数据源：在需要切换数据源的时候，通过调用切换数据源的方法，切换到指定的数据源。 SpringBoot的动态数据源实现方式有很多种，可以根据具体业务需求选择合适的方式。常见的实现方式包括使用AbstractRoutingDataSource、使用JdbcTemplate、使用Mybatis等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值