Springboot+Mybatis+Druid配置动态切换多数据源

最新推荐文章于 2024-05-07 15:52:14 发布
最新推荐文章于 2024-05-07 15:52:14 发布
阅读量2.9k 收藏 8
点赞数 2
分类专栏： 编码-Java 学习笔记 文章标签： springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42720251/article/details/125622857
版权

前言：本方案来自若依框架，跟着学习搭建并测试。完美实现了多数据源的动态切换。

第一步：导包

首先在SpringBoot项目的pom.xml中，引入相关jar

<!--springboot web-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!--mybatis-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.2</version>
</dependency>

<!--mysql-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

<!--druid-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.11</version>
</dependency>

<!--aop-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

<!--lombok-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.4</version>
</dependency>

<!--test-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

第二步：配置

yml配置mybatis扫描包路径以及数据源参数如下

#MyBatis
mybatis:
  type-aliases-package: com.example.dbtest.mapper
  mapper-locations: classpath:mapper/*.xml
#Spring
spring:
  datasource:
    druid:
      master:
        url: jdbc:mysql://xxxxxx:3306/xxxx?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true
        username: root
        password: woshidashuaiB
      slave:
        enabled: true
        url: jdbc:mysql://xxxxxxxx:3306/xxx?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true
        username: root
        password: woshidashuaiB
      min-idle: 10
      initial-size: 5
      max-active: 20
      max-wait: 60000
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      max-evictable-idle-time-millis: 900000
      validation-query: SELECT 1 FROM DUAL
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      web-stat-filter:
        enabled: true
      stat-view-servlet:
        enabled: true
        allow:
        url-pattern: /druid/*
        login-username: admin
        login-password: woshidashuaiB
      filter:
        stat:
          enabled: true
          log-slow-sql: true
          slow-sql-millis: 1000
          merge-sql: true
        wall:
          config:
            multi-statement-allow: true
      db-type: com.alibaba.druid.pool.DruidDataSource
      driver-class-name: com.mysql.jdbc.Driver
server:
  port: 8080

第三步：编码

自定义数据源切换的注解

package com.example.dbtest.config;

import java.lang.annotation.*;

/**
 * 数据源切换自定义注解
 * @Author dashuaiB
 * @Date 2022/7/4 17:45
 */
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataSource {
    public DataSourceType value() default DataSourceType.MASTER;
}

数据源类型枚举类

package com.example.dbtest.config;

/**
 * @Author dashuaiB
 * @Date 2022/7/4 17:44
 */
public enum DataSourceType {

    /**
     * 主库
     */
    MASTER,

    /**
     * 从库
     */
    SLAVE
}

配置切面拦截

package com.example.dbtest.config;

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.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @Author dashuaiB
 * @Date 2022/7/4 17:44
 */
@Aspect
@Order(1) // 优先级
@Component
public class DataSourceAspect {

    /**
     * 通过自定义注解@DataSource定义切点
     */
    @Pointcut("@annotation(com.example.dbtest.config.DataSource)"
            + "|| @within(com.example.dbtest.config.DataSource)")
    public void dsPointCut() {
    }

    /**
     * 切点环绕
     * @param point
     * @return
     * @throws Throwable
     */
    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        DataSource dataSource = getDataSource(point);
        if (dataSource!=null) {
            DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
        }

        try {
            return point.proceed();
        } finally {
            DynamicDataSourceContextHolder.clearDataSourceType();
        }
    }

    /**
     * 获取需要切换的数据源
     */
    public DataSource getDataSource(ProceedingJoinPoint point) {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Class<? extends Object> targetClass = point.getTarget().getClass();
        DataSource targetDataSource = targetClass.getAnnotation(DataSource.class);
        if (targetDataSource!=null) {
            return targetDataSource;
        } else {
            Method method = signature.getMethod();
            DataSource dataSource = method.getAnnotation(DataSource.class);
            return dataSource;
        }
    }
}

数据源配置元数据

package com.example.dbtest.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

/**
 * @Author dashuaiB
 * @Date 2022/7/4 17:39
 */
@Configuration
public class DruidProperties {
    @Value("${spring.datasource.druid.initial-size: 6}")
    private int initialSize;

    @Value("${spring.datasource.druid.min-idle}")
    private int minIdle;

    @Value("${spring.datasource.druid.max-active}")
    private int maxActive;

    @Value("${spring.datasource.druid.max-wait}")
    private int maxWait;

    @Value("${spring.datasource.druid.time-between-eviction-runs-millis}")
    private int timeBetweenEvictionRunsMillis;

    @Value("${spring.datasource.druid.min-evictable-idle-time-millis}")
    private int minEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.max-evictable-idle-time-millis}")
    private int maxEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.validation-query}")
    private String validationQuery;

    @Value("${spring.datasource.druid.test-while-idle}")
    private boolean testWhileIdle;

    @Value("${spring.datasource.druid.test-on-borrow}")
    private boolean testOnBorrow;

    @Value("${spring.datasource.druid.test-on-return}")
    private boolean testOnReturn;

    public DruidDataSource dataSource(DruidDataSource datasource) {
        /** 配置初始化大小、最小、最大 */
        datasource.setInitialSize(initialSize);
        datasource.setMaxActive(maxActive);
        datasource.setMinIdle(minIdle);

        /** 配置获取连接等待超时的时间 */
        datasource.setMaxWait(maxWait);

        /** 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 */
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);

        /** 配置一个连接在池中最小、最大生存的时间，单位是毫秒 */
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis);

        /**
         * 用来检测连接是否有效的sql，要求是一个查询语句，常用select
         * 'x'。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。
         */
        datasource.setValidationQuery(validationQuery);
        /**
         * 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
         */
        datasource.setTestWhileIdle(testWhileIdle);
        /** 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnBorrow(testOnBorrow);
        /** 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnReturn(testOnReturn);
        return datasource;
    }
}

数据源配置

package com.example.dbtest.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.alibaba.druid.spring.boot.autoconfigure.properties.DruidStatProperties;
import com.alibaba.druid.util.Utils;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.servlet.*;
import javax.sql.DataSource;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * @Author dashuaiB
 * @Date 2022/7/4 17:42
 */
@Configuration
public class 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, DataSource slaveDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceType.MASTER.name(), masterDataSource);
        targetDataSources.put(DataSourceType.SLAVE.name(), slaveDataSource);
        return new DynamicDataSource(masterDataSource, targetDataSources);
    }

    /**
     * 去除监控页面底部广告
     * @param properties
     * @return
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    @Bean
    @ConditionalOnProperty(name = "spring.datasource.druid.statViewServlet.enabled", havingValue = "true")
    public FilterRegistrationBean removeDruidFilterRegistrationBean(DruidStatProperties properties) {
        //获取web监控页面的参数
        DruidStatProperties.StatViewServlet config = properties.getStatViewServlet();
        //提取common.js的配置路径
        String pattern = config.getUrlPattern() != null ? config.getUrlPattern() : "/druid/*";
        String commonJsPattern = pattern.replaceAll("\\*", "js/common.js");
        final String filePath = "support/http/resources/js/common.js";
        //创建filter进行过滤
        Filter filter = new Filter() {

            @Override
            public void init(FilterConfig filterConfig) throws ServletException {

            }

            @Override
            public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
                    throws IOException, ServletException {
                chain.doFilter(request, response);
                //重置缓冲区，响应头不会被重置
                response.resetBuffer();
                //获取common.js
                String text = Utils.readFromResource(filePath);
                //正则替换banner, 除去底部广告信息
                text = text.replaceAll("<a.*?banner\"></a><br/>", "");
                text = text.replaceAll("powered.*?shrek.wang</a>", "");
                response.getWriter().write(text);
            }

            @Override
            public void destroy() {

            }
        };

        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        registrationBean.setFilter(filter);
        registrationBean.addUrlPatterns(commonJsPattern);
        return registrationBean;
    }
}

动态数据源切换上下文

package com.example.dbtest.config;

import lombok.extern.slf4j.Slf4j;

/**
 * @Author dashuaiB
 * @Date 2022/7/4 17:37
 */
@Slf4j
public class DynamicDataSourceContextHolder {
    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    public static void setDataSourceType(String dataSourceType) {
        log.info("切换到{}数据库",dataSourceType);
        CONTEXT_HOLDER.set(dataSourceType);
    }

    public static String getDataSourceType() {
        return CONTEXT_HOLDER.get();
    }

    public static void clearDataSourceType() {
        CONTEXT_HOLDER.remove();
    }
}

动态数据源处理

package com.example.dbtest.config;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

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

/**
 * @Author dashuaiB
 * @Date 2022/7/4 17:38
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceType();
    }

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

至此，所有工作已完成，完整项目结构如下：

 

测试：

两个库分别插入不同数据（左从右主）

 

 编写mapper

@Repository
public interface TestMapper {
    List<TestVO> getList();

    List<TestVO> getList2();
}
<mapper namespace="com.example.dbtest.mapper.TestMapper">
    <select id="getList" resultType="com.example.dbtest.vo.TestVO">
        select id,name from test_table_info
    </select>

    <select id="getList2" resultType="com.example.dbtest.vo.TestVO">
        select id,name from test_table_info
    </select>
</mapper>

编写service

@Service
//不指定数据源则默认访问主库
public class TestServiceImpl implements TestService {

    @Autowired
    private TestMapper testMapper;

    @Override
    public List<TestVO> getList() {
        return testMapper.getList();
    }


    @Override
    //配置访问从库
    @DataSource(DataSourceType.SLAVE)
    public List<TestVO> getList2() {
        return testMapper.getList2();
    }
}

编写controller

@RestController
@RequestMapping("/test")
public class TestController {

    @Autowired
    private TestService testService;

    @GetMapping("/get")
    public List<TestVO> getList(){
        return testService.getList();
    }

    @GetMapping("/get2")
    public List<TestVO> getList2(){
        return testService.getList2();
    }
}

启动应用

@SpringBootApplication
@MapperScan(basePackages = "com.example.dbtest.mapper")
public class DbtestApplication {

    public static void main(String[] args) {
        SpringApplication.run(DbtestApplication.class, args);
    }
}

测试结果：

对主库的访问如下：

 日志：

 

对从库的访问如下：

日志：

 

 

Java丶zhou
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
动态数据源切换（二）：Mybatis不同Mapper映射不同数据源
M义薄云天的博客
04-26 4680
背景 面对业务需要，业务数据在不同的数据库里面，数据又要在系统里面整合所以需要根据不同的数据操作切换不同的数据源，因此根据Mapper不同切换不同的数据源，来操作对应的数据库 图解 代码实现 Mybatis配置信息 // Uplus数据源配置信息， @Configuration @MapperScan(basePackages = UqierpDataSourceConfig....
SpringBoot+mybatis+Druid 运行时动态多数据源
09-18
总结来说，结合SpringBoot的自动配置能力、MyBatis的灵活映射和Druid的高性能连接池，我们可以构建一个动态多数据源系统，适应各种复杂的企业需求。这样的系统能够根据业务逻辑或外部条件灵活地切换数据源，提高了...
springboot，druid动态数据源切换
weixin_46519031的博客
03-01 842
springboot动态线程池配置，开箱即用
Spring Boot——Druid在application.yml文件中配置【spring.datasource.druid.aop-patterns】无效解决方案
无限迭代中......
03-22 4482
问题描述 在使用aop-patterns配置的时候发现Spring监控无效 Druid版本：1.1.22 如果SpringBoot的配置使用的是properties文件，该配置正常。 如果使用yml作为配置文件，则该配置无效。 问题分析 似乎不能以“-”作为分隔符。 使用了ConditionalOnProperty注解，该配置类并不会生效。 解决方案 方法一：重写DruidSpringAopConfiguration 如果我们想要使用yml文件，并且希望该配置生效，我们可以定义.
SpringBoot 整合多数据源 （MyBats + Druid）
最新发布
2401_83412087的博客
05-07 304
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
springboot 多数据源配置动态切换
梦醒了该散了的博客
09-04 1370
在实际开发中，经常可能遇到在一个应用中可能需要访问多个数据库的情况，那么我们就要使用切换数据源来实现我们的功能，也就是多数据源的配置 环境是springboot 在application-druid.yml配置从库数据源 # 数据源配置 spring: datasource: type: com.alibaba.druid.pool.DruidDataSource ...
SpringBoot整合Druid数据库连接池&多数据源&注解切换&动态添加
hello，word！
11-30 4950
*** 自定义多数据源切换注解* 优先级：先方法，后类，如果方法覆盖了类上的数据源类型，以方法的为准，否则以类上的为准*/@Inherited/*** 切换数据源名称*/
druid.properties 配置以及 Java 示例代码
繁依Fanyi的博客
06-29 3058
文件中，你可以添加Druid连接池的各种配置项，每个配置项由键值对的形式表示。文件配置Druid连接池的基本方法。根据你的具体需求，你可以添加更多的配置项来优化连接池的性能和行为。你可以根据自己的需求添加其他配置项，具体的配置项可以参考Druid的文档或官方网站。是用于配置Druid连接池的配置文件。下面是配置Druid连接池的。3、编辑配置项的值：在每个配置项的等号后面填写相应的值。5、在代码中加载配置文件：在你的代码中，使用Druid提供的。文件：在你的项目中创建一个名为。文件放置到正确的位置：将。
通过springboot+mybatis+druid配置动态数据源
08-25
通过 SpringBoot、MyBatis 和 Druid 配置动态数据源是一种常见的解决方案，它可以帮助开发者轻松地管理多个数据源，并提供了动态切换数据源的能力。在本文中，我们将通过示例代码详细介绍如何使用 SpringBoot、...
Springboot+mybatis+druid多数据源配置（oracle+mybatis）
07-29
要在业务代码中动态切换数据源，可以创建一个`AbstractRoutingDataSource`的子类，例如`DynamicDataSource`，并重写`determineCurrentLookupKey`方法来根据业务逻辑选择数据源。 6. 配置Mybatis的Mapper： 为每个...
Springboot+Mybatis+Druid多数据源配置
01-14
// 根据注解值切换数据源... // 执行原方法 return joinPoint.proceed(); } } ``` 在Service方法上使用这个注解，即可指定数据源： ```java @Service public class UserService { @UseDataSource(value = ...
SpringBoot + mybatis-plus + druid 实现mySql与Orcl双数据源
01-12
然后，创建两个数据源的配置类，继承`AbstractRoutingDataSource`，用于动态切换数据源： ```java @Configuration public class DynamicDataSourceConfig extends AbstractRoutingDataSource { @Autowired ...
SpringBoot+Mybatis+Druid+PageHelper实现多数据源并分页方法
08-26
在本文中，我们将深入探讨如何使用SpringBoot、Mybatis、Druid和PageHelper来实现多数据源和分页功能。首先，SpringBoot是基于Spring框架的简化版本，它旨在简化微服务开发，提供了自动配置、内嵌式Web服务器以及...
SpringBoot+Druid+MyBatis实现多数据源切换
03-14
本教程将详细介绍如何利用SpringBoot、Druid以及MyBatis这三大组件来构建一个能够动态切换数据源的系统。 首先，SpringBoot以其简洁的配置和快速的启动特性，已经成为Java微服务开发的首选框架。在SpringBoot中，...
springboot+druid+mybatis多数据源动态切换案例
05-13
7. **动态数据源切换**：可以通过定义一个工具类或者Service，提供动态切换数据源的方法，根据业务需求在运行时切换数据源，例如切换到主库执行写操作，切换到从库执行读操作。 8. **测试**：在名为`test`的文件中...
springboot + mybatis(通用mapper) + druid多数据源
09-22
Druid可以很好地支持多数据源配置，通过Spring的DataSourceProxy和DataSourceConfig，开发者可以方便地切换和管理多个数据源。这样，同一个应用可以根据业务需求，灵活地读写不同的数据库，实现数据的隔离。 项目名...
若依Druid多数据源配置及使用代码详解
m0_58189021的博客
09-05 2258
此外，笔者水平有限，如果本文讲解有哪里不对，还望评论指正，我们一起努力，共同进步！
Spring Boot 之 Druid 多数据源配置
bluemysky的博客
11-13 3650
Spring Boot 之 Druid 多数据源配置
Springboot2.0x 多数据源+Durid 使用注解动态切换
qq_39971775的博客
06-03 1439
Spring boot提供了AbstractRoutingDataSource 根据用户定义的规则选择当前的数据源，这样我们可以在执行查询之前，设置使用的数据源。实现可动态路由的数据源，在每次数据库查询操作前执行。它的抽象方法 determineCurrentLookupKey() 决定使用哪个数据源。
Springboot+MyBatis-Plus实现多租户动态数据源模式
12-23
Springboot+MyBatis-Plus实现多租户动态数据源模式是一种在Spring Boot框架下使用MyBatis-Plus插件实现多租户数据隔离的方法。它可以根据不同的租户动态切换数据源，实现不同租户之间的数据隔离。 实现多租户动态数据源模式的关键是配置多个数据源，并在运行时根据租户信息动态选择使用哪个数据源。以下是一个简单的示例代码： 1. 首先，需要在pom.xml文件中添加Druid数据源的依赖： ```xml <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.1.21</version> </dependency> ``` 2. 在application.properties或application.yml文件中配置多个数据源的连接信息，例如： ```yaml spring.datasource.master.url=jdbc:mysql://localhost:3306/master_db spring.datasource.master.username=root spring.datasource.master.password=123456 spring.datasource.tenant1.url=jdbc:mysql://localhost:3306/tenant1_db spring.datasource.tenant1.username=root spring.datasource.tenant1.password=123456 spring.datasource.tenant2.url=jdbc:mysql://localhost:3306/tenant2_db spring.datasource.tenant2.username=root spring.datasource.tenant2.password=123456 ``` 3. 创建一个多租户数据源配置类，用于动态选择数据源。可以使用ThreadLocal来保存当前租户的标识，然后根据标识选择对应的数据源。以下是一个简单的示例： ```java @Configuration public class MultiTenantDataSourceConfig { @Autowired private DataSourceProperties dataSourceProperties; @Bean @ConfigurationProperties(prefix = "spring.datasource.master") public DataSource masterDataSource() { return DataSourceBuilder.create().build(); } @Bean @ConfigurationProperties(prefix = "spring.datasource.tenant1") public DataSource tenant1DataSource() { return DataSourceBuilder.create().build(); } @Bean @ConfigurationProperties(prefix = "spring.datasource.tenant2") public DataSource tenant2DataSource() { return DataSourceBuilder.create().build(); } @Bean @Primary public DataSource dynamicDataSource() { DynamicDataSource dynamicDataSource = new DynamicDataSource(); Map<Object, Object> dataSourceMap = new HashMap<>(); dataSourceMap.put("master", masterDataSource()); dataSourceMap.put("tenant1", tenant1DataSource()); dataSourceMap.put("tenant2", tenant2DataSource()); dynamicDataSource.setTargetDataSources(dataSourceMap); dynamicDataSource.setDefaultTargetDataSource(masterDataSource()); return dynamicDataSource; } @Bean public SqlSessionFactory sqlSessionFactory(DataSource dynamicDataSource) throws Exception { SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean(); sessionFactory.setDataSource(dynamicDataSource); return sessionFactory.getObject(); } @Bean public PlatformTransactionManager transactionManager(DataSource dynamicDataSource) { return new DataSourceTransactionManager(dynamicDataSource); } } ``` 4. 创建一个多租户数据源切换器，用于在每次数据库操作前切换数据源。以下是一个简单的示例： ```java public class DynamicDataSource extends AbstractRoutingDataSource { @Override protected Object determineCurrentLookupKey() { return TenantContext.getTenantId(); } } ``` 5. 创建一个租户上下文类，用于保存当前租户的标识。以下是一个简单的示例： ```java public class TenantContext { private static final ThreadLocal<String> CONTEXT = new ThreadLocal<>(); public static void setTenantId(String tenantId) { CONTEXT.set(tenantId); } public static String getTenantId() { return CONTEXT.get(); } public static void clear() { CONTEXT.remove(); } } ``` 6. 在需要切换数据源的地方，调用TenantContext.setTenantId()方法设置当前租户的标识。例如： ```java @RestController public class UserController { @Autowired private UserService userService; @GetMapping("/users") public List<User> getUsers() { TenantContext.setTenantId("tenant1"); List<User> users = userService.getUsers(); TenantContext.clear(); return users; } } ``` 通过以上步骤，就可以实现Springboot+MyBatis-Plus的多租户动态数据源模式了。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值