springBoot集成多数据源mybatisPlus(自动切换数据源)

最新推荐文章于 2024-09-13 17:41:50 发布
最新推荐文章于 2024-09-13 17:41:50 发布
阅读量1.1k 收藏 5
点赞数
分类专栏： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55891090/article/details/114852649
版权

文章目录

1 背景

springboot配置mybatisPlus，mybatisPlus配置一主二从数据源。

数据源切换，通过mybatis的拦截器结合本地线程变量，自动切换数据源。

切换原则：不在事务中的查询，使用从库，其他情况均使用主库

流程图：

mybatisPlus自动切换数据源.jpg

2 版本

  • JDK：1.8
  • mysql：5.6
  • springboot：2.2.9.RELEASE
  • mybatis-plus：3.4.0

3 配置

路径说明：

用途路径
beancom.sa.example.mybatis2.ext.bean
mappercom.sa.example.mybatis2.ext.mapper；com.sa.example.mybatis2.auto.mapper
xmlcom.sa.example.mybatis2.ext.mapper.xml；com.sa.example.mybatis2.auto.mapper.xml
bean配置com.sa.example.mybatis2.config
3.1 pom配置
3.1.1 父类pom
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.9.RELEASE</version>
    <relativePath/>
</parent>
3.1.2 pom依赖
<!-- ==========mybatisPlus配置========== -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.30</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.23</version>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.3</version>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.0</version>
</dependency>
<!-- ==========springboot-web依赖========== -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<!-- ==========其他依赖========== -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.11</version>
</dependency>
3.1.3 插件

保证可以在src的包里配置mapper的xml文件，否则需要再resource文件夹中配置mapper的xml。

 <build>
     <plugins>
         <plugin>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
     </plugins>
     <resources>
         <resource>
             <directory>src/main/java</directory>
             <includes>
                 <include>**/*.*</include>
             </includes>
         </resource>
         <resource>
             <directory>src/main/resources</directory>
             <includes>
                 <include>**/**</include>
             </includes>
         </resource>
     </resources>
</build>
3.2 application.yml配置
#==========自定义mybatisPlus数据源========== 
datasource:
  #数据源类型
  type: com.alibaba.druid.pool.DruidDataSource
  #从库节点数量
  slaveNodeCount: 2
  #主库
  master:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test01?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=round&useAffectedRows=true
    username: root
    password: root
    pool-config:
      initialSize: 100
      minIdle: 1
      maxActive: 50
      maxWait: 60000
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 'x'
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      poolPreparedStatements: false
      maxPoolPreparedStatementPerConnectionSize: -1
      filters: stat,logback
  #从库1
  slave1:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test02?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=round&useAffectedRows=true
    username: root
    password: root
    pool-config:
      initialSize: 100
      minIdle: 1
      maxActive: 50
      maxWait: 60000
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 'x'
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      poolPreparedStatements: false
      maxPoolPreparedStatementPerConnectionSize: -1
      filters: stat,logback
  #从库2
  slave2:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test03?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=round&useAffectedRows=true
    username: root
    password: root
    pool-config:
      initialSize: 100
      minIdle: 1
      maxActive: 50
      maxWait: 60000
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 'x'
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      poolPreparedStatements: false
      maxPoolPreparedStatementPerConnectionSize: -1
      filters: stat,logback

#==========整合mybatisPlus==========
mybatis-plus:
  type-aliases-package: com.lx.ms.db.mybatis.bean.ext
  mapper-locations: classpath:com/sa/example/mybatis2/ext/mapper/xml/*.xml,classpath:com/sa/example/mybatis2/auto/mapper/xml/*.xml
  configuration:
    map-underscore-to-camel-case: true
    cache-enabled: true
    lazy-loading-enabled: false
    aggressive-lazy-loading: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
3.3 bean配置

mybatisPlus配置bean所在包：com.sa.example.mybatis2.config

3.3.1 数据源配置信息
/**
 * 数据源配置信息
 */
@Configuration
public class DataSourcePropertiesConfig { 
    /**
     * 主库配置
     * @return 数据源配置
     */
    @Primary
    @Bean
    @ConfigurationProperties("datasource.master")
    public DataSourceProperties masterDataSourceProperties() {
        return new DataSourceProperties();
    }
    
    /**
     * 从库配置
     * @return 数据源配置
     */
    @Bean
    @ConfigurationProperties("datasource.slave1")
    public DataSourceProperties slave1DataSourceProperties() {
        return new DataSourceProperties();
    }
    
    /**
     * 从库配置
     * @return 数据源配置
     */
    @Bean
    @ConfigurationProperties("datasource.slave2")
    public DataSourceProperties slave2DataSourceProperties() {
        return new DataSourceProperties();
    }
}
3.3.2 数据源配置
/**
 * 数据源配置
 */
@Configuration
public class DataSourceConfig {
    
    @Resource
    private DataSourceProperties masterDataSourceProperties;
    
    @Resource
    private DataSourceProperties slave1DataSourceProperties;
    
    @Resource
    private DataSourceProperties slave2DataSourceProperties;
    
    /**
     * 数据源类型
     */
    @Value("${datasource.type:}")
    private Class<? extends DataSource> dataSourceType;
    
    /**
     * 如果配置文件未配置，默认取Druid数据源配置
     *
     * @return
     */
    private Class<? extends DataSource> getDataSourceType() {
        if (this.dataSourceType == null) {
            this.dataSourceType = com.alibaba.druid.pool.DruidDataSource.class;
        }
        return this.dataSourceType;
    }
    
    /**
     * 主库数据源
     *
     * @return
     */
    @Bean
    @ConfigurationProperties("datasource.master.pool-config")
    public DataSource masterDataSource() {
        return masterDataSourceProperties.initializeDataSourceBuilder().type(getDataSourceType()).build();
    }
    
    /**
     * 从库1数据源
     *
     * @return
     */
    @Bean
    @ConfigurationProperties("datasource.slave1.pool-config")
    public DataSource slave1DataSource() {
        return slave1DataSourceProperties.initializeDataSourceBuilder().type(getDataSourceType()).build();
    }
    
    /**
     * 从库2数据源
     *
     * @return
     */
    @Bean
    @ConfigurationProperties("datasource.slave2.pool-config")
    public DataSource slave2DataSource() {
        return slave2DataSourceProperties.initializeDataSourceBuilder().type(getDataSourceType()).build();
    }
}
3.3.3 数据源句柄
/**
 * 数据源句柄（存储当前线程中绑定的数据源名称）
 */
class DataSourceHolder {
    
    static final String MASTER_DATASOURCE = "master";
    static final String SLAVER1_DATASOURCE = "slaver1";
    static final String SLAVER2_DATASOURCE = "slaver2";
    
    /**
     * 线程变量（缓存当前数据源名称）
     */
    private static final ThreadLocal<String> LOCAL = new ThreadLocal<>();
    
    /**
     * 设置数据源
     *
     * @param dataSource 数据源名称
     */
    static void putDataSource(String dataSource) {
        LOCAL.set(dataSource);
    }
    
    /**
     * 获取数据源
     *
     * @return 数据源名称
     */
    static String getDataSource() {
        return LOCAL.get();
    }
    
    /**
     * 清空缓存
     */
    static void clearDataSource() {
        LOCAL.remove();
    }
    
    /**
     * 随机获取读库
     *
     * @return
     */
    static String getRandomReadDataSourceName() {
        int randomVal = ThreadLocalRandom.current().nextInt(0, 2);
        if (randomVal == 0) {
            return SLAVER1_DATASOURCE;
        } else {
            return SLAVER2_DATASOURCE;
        }
    }
}
3.3.4 动态数据源路由
/**
 * 动态数据源路由（对于一次有读有写的事务，事务内的读操作也不应该在slave节点上，所有操作都应该在master节点上）
 */
@Component
public class ExtRoutingDataSource extends AbstractRoutingDataSource {
    
    @Qualifier("masterDataSource")
    @Autowired
    private DataSource masterDataSource;
    
    @Qualifier("slave1DataSource")
    @Autowired
    private DataSource slave1DataSource;
    
    @Qualifier("slave2DataSource")
    @Autowired
    private DataSource slave2DataSource;
    
    @Override
    public void afterPropertiesSet() {
        
        //设置默认数据源
        this.setDefaultTargetDataSource(masterDataSource);
        
        Map<Object, Object> dataSourceMap = new HashMap<>();
        dataSourceMap.put(DataSourceHolder.MASTER_DATASOURCE, masterDataSource);
        dataSourceMap.put(DataSourceHolder.SLAVER1_DATASOURCE, slave1DataSource);
        dataSourceMap.put(DataSourceHolder.SLAVER2_DATASOURCE, slave2DataSource);
        //指定目标数据源的映射，并使用查找键作为键
        this.setTargetDataSources(dataSourceMap);
        
        super.afterPropertiesSet();
    }
    
    @Override
    protected Object determineCurrentLookupKey() {
        确定当前查找键
        String key = DataSourceHolder.getDataSource();
        if (StringUtils.isEmpty(key)) {
            //返回默认数据源
            return DataSourceHolder.MASTER_DATASOURCE;
        }
        //读取后，清空内存变量
        DataSourceHolder.clearDataSource();
        return key;
    }
}
3.3.5 重写mybatis自动加载
/**
 * 重写mybatis自动加载（重新指定数据源）
 */
@Configuration
public class ExtMybatisPlusAutoConfiguration extends MybatisPlusAutoConfiguration {
    
    @Autowired
    private ExtRoutingDataSource extRoutingDataSource;
    
    public ExtMybatisPlusAutoConfiguration(MybatisPlusProperties properties, ObjectProvider<Interceptor[]> interceptorsProvider, ObjectProvider<TypeHandler[]> typeHandlersProvider, ObjectProvider<LanguageDriver[]> languageDriversProvider, ResourceLoader resourceLoader, ObjectProvider<DatabaseIdProvider> databaseIdProvider, ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider, ObjectProvider<List<MybatisPlusPropertiesCustomizer>> mybatisPlusPropertiesCustomizerProvider, ApplicationContext applicationContext) {
        super(properties, interceptorsProvider, typeHandlersProvider, languageDriversProvider, resourceLoader, databaseIdProvider, configurationCustomizersProvider, mybatisPlusPropertiesCustomizerProvider, applicationContext);
    }
    
    /**
     * 自定义session工厂
     *
     * @return
     * @throws Exception
     */
    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        return super.sqlSessionFactory(extRoutingDataSource);
    }
    
    /**
     * 自定义事务管理器
     *
     * @return
     */
    @Bean
    public DataSourceTransactionManager dataSourceTransactionManager() {
        return new DataSourceTransactionManager(extRoutingDataSource);
    }
}
3.3.6 Mybatis数据源拦截器
/**
 * Mybatis数据源拦截器（用户切换线程变量中指定的数据源）
 */
@Intercepts({
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class})
})
@Component
public class MybatisDataSourceInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        boolean synchronizationActive = TransactionSynchronizationManager.isSynchronizationActive();
        if (!synchronizationActive) {
            Object[] objects = invocation.getArgs();
            MappedStatement ms = (MappedStatement) objects[0];
            if (ms.getSqlCommandType().equals(SqlCommandType.SELECT)) {
                //不在事务中，且调用的sql是select类型时，选择从库。其他情况，默认选择主库
                DataSourceHolder.putDataSource(DataSourceHolder.getRandomReadDataSourceName());
            }
        }
        return invocation.proceed();
    }
    
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }
    
    @Override
    public void setProperties(Properties properties) {
        
    }
}
3.4 启动类配置
@SpringBootApplication(scanBasePackages = "com.sa.example")
@MapperScan(basePackages = {"com.sa.example.mybatis2.ext.mapper", "com.sa.example.mybatis2.auto.mapper"})
public class Mybatis2Application {
    public static void main(String[] args) {
        SpringApplication.run(Mybatis2Application.class, args);
    }
}

4 使用

4.1 建表脚本
CREATE TABLE `c_m_phone` (
  `id` int(10) NOT NULL COMMENT 'id',
  `phone_first` varchar(20) DEFAULT NULL COMMENT '前缀号段',
  `phone_provence` varchar(20) DEFAULT NULL COMMENT '手机所在省份',
  `phone_city` varchar(20) DEFAULT NULL COMMENT '手机所在城市',
  `service` varchar(20) DEFAULT NULL COMMENT '服务商',
  PRIMARY KEY (`id`)
) COMMENT='电话区域表';
4.2 实体类
//包名：com.sa.example.mybatis2.ext.bean
@Data
public class CMPhone {
    private Integer id;
    private String phoneFirst;
    private String phoneProvence;
    private String phoneCity;
    private String service;
}
4.3 mapper
// 包名：com.sa.example.mybatis2.ext.mapper
public interface CMPhoneMapper {
    /**
     * 保存（配置主库）
     * @param model
     * @return
     */
    int save(CMPhone model);
    
    /**
     * 查询（配置从库）
     * @param model
     * @return
     */
    List<CMPhone> findList(CMPhone model);
}
4.4 mapper映射
<!-- 包名：com.sa.example.mybatis2.ext.mapper.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.sa.example.mybatis2.ext.mapper.CMPhoneMapper">
    <resultMap id="BaseResultMap" type="com.sa.example.mybatis2.ext.bean.CMPhone">
        <id column="id" property="id" jdbcType="INTEGER"/>
        <result column="phone_first" property="phoneFirst" jdbcType="VARCHAR"/>
        <result column="phone_provence" property="phoneProvence" jdbcType="VARCHAR"/>
        <result column="phone_city" property="phoneCity" jdbcType="VARCHAR"/>
        <result column="service" property="service" jdbcType="VARCHAR"/>
    </resultMap>

    <select id="findList" parameterType="com.sa.example.mybatis2.ext.bean.CMPhone" resultMap="BaseResultMap">
        select id,phone_first,phone_provence,phone_city,service from c_m_phone
    </select>

    <insert id="save" parameterType="com.sa.example.mybatis2.ext.bean.CMPhone">
        INSERT INTO `c_m_phone` (`id`, `phone_first`, `phone_provence`, `phone_city`, `service`) VALUES (
            #{id},#{phoneFirst},#{phoneProvence},#{phoneCity},#{service}
        )
    </insert>
</mapper>
4.5 使用
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MybatisApplication.class)
public class MybatisTest {
    
    @Autowired
    private CMPhoneMapper cmPhoneMapper;
    
    @Test
    public void testMapper() {
        List<CMPhone> cmPhoneList = cmPhoneMapper.findList(new CMPhone());
        System.out.println(cmPhoneList);
    }
    
    @Test
    public void testSave(){
        CMPhone model = new CMPhone();
        model.setId(1000);
        model.setPhoneCity("PhoneCity test");
        model.setPhoneFirst("PhoneFirst test");
        model.setPhoneProvence("PhoneProvence test");
        model.setService("Service test");
        cmPhoneMapper.save(model);
    }
}
4.6 事务中的查询

事务中的查询，连接的为主库master

4.6.1 service
public interface CMPhoneService {
    List<CMPhone> doSomething();
}

@Service
public class CMPhoneServiceImpl implements CMPhoneService {
    @Autowired
    private CMPhoneMapper cmPhoneMapper;
    
    @Transactional(rollbackFor = RuntimeException.class)
    @Override
    public List<CMPhone> doSomething() {
        return cmPhoneMapper.findList(new CMPhone());
    }
}
4.6.2 单元测试
@Test
public void testTransaction(){
    List<CMPhone> cmPhoneList = cmPhoneService.doSomething();
    System.out.println(cmPhoneList);
}
4.6.3 输出日志
Creating a new SqlSession
Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@79c5460e]
JDBC Connection [com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl@7ab4ae59] will be managed by Spring
==>  Preparing: select id,phone_first,phone_provence,phone_city,service from c_m_phone
==> Parameters: 
<==    Columns: id, phone_first, phone_provence, phone_city, service
<==        Row: 1, 1300000, 山东, 济南, 中国联通
<==      Total: 1
Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@79c5460e]
Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@79c5460e]
Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@79c5460e]
Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@79c5460e]
水煮鱼又失败了
关注
专栏目录
Springboot/MybatisPlus动态切换数据源
sunnyday0426的博客
05-12 6107
Springboot/MybatisPlus动态切换数据源：通过配置多个数据源，并在运行时根据条件选择不同的数据源，实现动态切换。
Spring + Mybatis环境实现Mysql数据库主从切换
kidQ的博客
11-01 6698
一、简述：数据库应用场景中，经常是“读多写少”，也就是对数据库读取数据压力比较大。有一个解决方案是采用数据库集群方案。 一个数据库是主库，负责写；其他为从库，负责读。实现：读写分离。 那么，对我们的要求是： 1. 读库和写库的数据一致； 2. 写数据必须写到写库； 3. 读数据必须到读库；二、方案：实现读写分离有两种方案：应用层解决和中间件解决； 本篇，介绍使用Spring方式，实现应用
springboot+mybatis/mybatis-plus拦截器实现多数据源切换
DJYDFT2831djydft的专栏
12-12 3906
1、数据源配置 spring.datasource.master.driver-class-name = com.mysql.jdbc.Driver spring.datasource.master.filters = wall,stat spring.datasource.master.initial-size = 50 spring.datasource.master.max-active = 100 spring.datasource.master.max-open-prepared-statem
SpringBoot+mybatis-plus 整合多个数据库
最新发布
wxsoxsok的博客
09-13 654
引入上文的依赖后，项目启动会出现上述问题，原因是sharding-jdbc没有配置默认的连接数据库，需要在启动类中屏蔽自动装载的类。此类问题就是springboot的版本引入数据的类型变动的问题，1.x用url ,2.x用jdbc-url.注意:我这使用的是springboot2.0以上的配置路径用jdbc-url，1.0用url。driver-class-name这里使用的是mysql的，可根据数据类型的不同添加。框架环境：springboot：2.7.2 mybatis-plus:2.3。
SpringBoot+mybatisPlus实现多数据源
qimowei的博客
08-08 414
SpringBoot+mybatisPlus实现多数据源curd 适用场景：一个项目需要连接多个数据库的时候 dynamic-datasource-spring-boot-starter 是一个基于springboot的快速集成多数据源的启动器。 其支持 Jdk 1.7+, SpringBoot 1.4.x 1.5.x 2.x.x。 示例项目 可参考项目下的samples...
springboot集成mybatis-plus多数据源事务
felon527的专栏
06-09 369
1.引入依赖 <?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....
SpringBoot整合MyBatisPlus配置动态数据源的方法
08-26
SpringBoot 整合 MyBatisPlus 配置动态数据源的方法可以满足我们在实际开发中遇到的各种需求，例如读写分离、数据源切换等。通过使用 DynamicDataSource 插件，我们可以实现动态数据源的配置，提高应用程序的灵活性...
SpringBoot整合mybatis-plus实现多数据源的动态切换且支持分页查询.pdf
10-07
在实际的业务代码中，可以通过`DynamicDataSourceContextHolder`来切换数据源，如在Service层根据业务逻辑选择合适的数据源，而在Mapper层则可以直接使用Mybatis-Plus的分页查询功能，如`BaseMapper.selectPage()`...
springboot mybatisplus 多数据源源码
10-22
本篇文章将详细讲解如何利用SpringBoot集成MyBatisPlus实现多数据源配置，并通过源码解析来加深理解。 首先，SpringBoot以其"约定优于配置"的理念简化了Spring的应用启动过程，而MyBatisPlus则是MyBatis的增强工具...
springboot+mybatisplus+mysql 多数据源
10-27
4. **动态数据源**: 动态数据源允许程序在运行时动态地切换数据源。在Spring Boot中，这通常通过`AbstractRoutingDataSource`实现，它可以基于某些条件（如线程绑定、请求上下文等）来决定使用哪个数据源。 5. **...
springboot整合mybatisplus配置多数据源
热门推荐
congge
11-24 1万+
前言 业务中，有一个需求，需要定时将一个库的部分业务表的数据同步到另一个库中，由于在现有的项目中进行改造比较麻烦，因此索性使用springboot和mybatisplus完成一个多数据源的环境搭建 简单说明一下，使用mybatis也是可以的，但项目中有技术要求，同时使用过mybatisplus之后，发现功能更加强大，而且使用很灵活，因此就选择了这个组件 搭建流程 开发步骤： 新建springbo...
【mybatis-plus】多数据源切换[dynamic-datasource] 手动切换数据源
日拱一卒无有尽，功不唐捐终入海
09-04 1万+
苞米豆团队支持多种数据源切换方案，核心都是基于。本文我们利用filter和拦截器，以及方法中硬编码 这三种方式动态手动切换数据源。在使用 dynamic-datasource 库时，您可以通过过滤器（Filter）来实现在请求处理过程中切换数据源。创建在过滤器的doFilter方法中，获取当前请求的上下文信息，例如请求参数、请求头等。根据上下文信息，判断应该使用哪个数据源，然后调用方法设置数据源标识。@Component@Override// 获取上下文信息，判断应该使用哪个数据源。
SpringBoot+Mybatis-Plus实现mysql读写分离方案
Abean
12-08 3467
SpringBoot+Mybatis-plus实现读写分离方案1. 引入mybatis-plus相关包，pom.xml文件2. 配置文件application.property增加多库配置mysql 数据源配置3. 配置数据源及注解数据源配置 MultiDataSourceConfig.Java数据库枚举类注解4. Mybatis-plus配置5. 增加数据源管理类指定选择数据源6. 增加aop切面6. 实际应用 1. 引入mybatis-plus相关包，pom.xml文件 2. 配置文件applica
SpringBoot+Mybatis-plus实现多数据源动态切换的两种方式
SongFeifei_S的博客
06-22 4041
SpringBoot+Mybatis-plus实现多数据源动态切换的两种方式
SpringBoot+mybatisPlus + dynamic-datasource实现真正的动态切换数据源（附核心代码）
ybb_ymm的专栏
06-13 3780
系统要调整为S A S S版实现多 租 户功能，首先想到的两个解决方案就是：1、通过表字段隔离租户数据信息2、通过分库来隔离租户数据（这种方案还是比较安全的）方案最终确定为第二种实现。接下来就是要实现动 态 切 换 数 据 源，以满足不同租户访问自己的数据源了定一个新的数据源继承一个抽象类AbstractRoutingDataSource。其中,必须实现一个方法protected Object determineCurrentLookupKey()，
mybatis-plus动态数据源切换不生效的问题解决
qq_46552655的博客
12-23 4129
mybatis-puls动态数据源切换不生效的问题
springboot+mybatisplus+mysql双数据源动态切换（详细版）
zkr1234562的博客
11-20 1878
Springboot+mybatisplus+mysql双数据源动态配置
MyBatis拦截器 Interceptor 实现多数据源切换
qq_34922830的博客
10-20 3299
http://AbstractRoutingDataSource详解数据源配置与切换// 主库-读数据源master,// 主库-写数据源slave,// 多数据源readmore}/*** 数据源路由器*/// 也可以指定 ThreadLocal 的 initialValue 的具体实现}/***将targetDataSources映射中指定的给定查找键对象解析为用于与当前查找键匹配的实际查找键。
AbstractRoutingDataSource+Mybatis拦截器实现动态切换数据源
okmgao1995的博客
02-15 1495
切换数据源+切换库
掌握SpringBoot多数据源切换实战技巧
然后通过AOP切面来在方法执行前后切换数据源。 ```java @Configuration public class DataSourceConfig { // 定义数据源 @Bean @ConfigurationProperties(prefix = "spring.datasource.master") public ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值