SpringBoot多数据源切换实现代码(Mybaitis)

2024-04-02 19:04:59 838人浏览安东尼

Python 官方文档：入门教程 => 点击学习

摘要

目录前言配置文件(YML)核心代码DynamicDataSourceDynamicDataSourceServiceDynamicDataSourceConfig加载YML数据库配置

前言

但是在实际业务场景中，数据量迅速增长，一个库一个表已经满足不了我们的需求的时候，我们就会考虑分库分表的操作，在SpringBoot中如何实现多数据源，动态数据源切换，读写分离等操作。当你看到这篇文件那么你幸运了,下面直接提供终极通用版代码

如果是非Mybaitis的那么可以进行参照,原理都差不多

配置文件(YML)

spring:
  datasource:
    default-db-key: voidme
    multi-db:
      - voidme:
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          passWord: root
          url: jdbc:mysql://192.168.42.153:3306/voidme?characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false&maxReconnects=10&useSSL=false
      - xcdef:
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: root
          url: jdbc:mysql://192.168.42.153:3306/xcdef?characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false&maxReconnects=10&useSSL=false


mybatis:
  #1.classpath：只会到你的classes路径中查找找文件。
  #2.classpath*：不仅会到classes路径，还包括jar文件中(classes路径)进行查找。
  mapper-locations: classpath*:/mapper*Mapper.xml    # mapper映射文件位置
  type-aliases-package: com.**.entity    # 实体类所在的位置
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl   #用于控制台打印sql语句
    map-underscore-to-camel-case: true #开启将带有下划线的表字段 映射为驼峰格式的实体类属性

核心代码

DynamicDataSource

这个类用于获取数据源的(核心)

package com.dynamicdatadource.dynamic;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Value("${spring.datasource.default-db-key}")
    private String defaultDbKey;

    @Override
    protected Object determineCurrentLookupKey() {
        String currentDb = DynamicDataSourceService.currentDb();
        if (currentDb == null) {
            return defaultDbKey;
        }
        return currentDb;
    }
}

DynamicDataSourceService

这个类是数据源切换工具,我们做了线程隔离了所以不用担心多线程数据源会混乱的问题

package com.dynamicdatadource.dynamic;

import com.application.ApplicationContextProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.jdbc.DataSourceBuilder;

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

public class DynamicDataSourceService  {
    private static final Logger log = LoggerFactory.getLogger(DynamicDataSourceService.class);

    private static final Map<Object, Object> dataSources = new HashMap<>();
    private static final ThreadLocal<String> dbKeys = ThreadLocal.withInitial(() -> null);

    
    public static void aDDDataSource(String name, DataSource dataSource) {
        DynamicDataSource dynamicDataSource = ApplicationContextProvider.getApplicationContext().getBean(DynamicDataSource.class);
        dataSources.put(name, dataSource);
        dynamicDataSource.setTargetDataSources(dataSources);
        dynamicDataSource.afterPropertiesSet();
        log.info("添加了数据源:{}",name);
    }

    
    public static void addDataSource(String name, String driverClassName,String url,String username,String password) {
        DataSourceBuilder<?> builder = DataSourceBuilder.create();
        builder.driverClassName(driverClassName);
        builder.username(username);
        builder.password(password);
        builder.url(url);
        addDataSource(name,builder.build());
        log.info("添加了数据源:{}",name);
    }
    
    public static void switchDb(String dbKey) {
        dbKeys.set(dbKey);
    }

    
    public static void resetDb() {
        dbKeys.remove();
    }

    
    public static String currentDb() {
        return dbKeys.get();
    }
}

DynamicDataSourceConfig

将数据源配置到springboot中和初始化Mybaitis配置

package com.dynamicdatadource.dynamic;

import lombok.Data;
import org.apache.ibatis.logging.Log;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatfORMTransactionManager;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@Configuration
@ConfigurationProperties(prefix = "mybatis")
@Data
public class DynamicDataSourceConfig {

    private String mapperLocations;
    private String typeAliasesPackage;
    @Data
    public class MybatisConfiguration{
        private String logImpl;
        private boolean mapUnderscoreToCamelCase;
    }
    private  MybatisConfiguration configuration=new MybatisConfiguration();


    
    @Bean
    public DynamicDataSource dynamicDataSource() {
        DynamicDataSource dataSource = new DynamicDataSource();
        Map<Object, Object> targetDataSources = new HashMap<>();
        dataSource.setTargetDataSources(targetDataSources);
        return dataSource;
    }

    
    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean() throws IOException, ClassNotFoundException {
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setMapUnderscoreToCamelCase(this.configuration.isMapUnderscoreToCamelCase()); //开启驼峰命名
        configuration.setLogImpl((Class<? extends Log>) Class.forName(this.configuration.getLogImpl())); //控制台打印sql日志
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dynamicDataSource());
        sqlSessionFactoryBean.setConfiguration(configuration);
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sqlSessionFactoryBean.setMapperLocations(resolver.getResources(mapperLocations));
        sqlSessionFactoryBean.setTypeAliasesPackage(typeAliasesPackage);
        return sqlSessionFactoryBean;
    }

    
    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dynamicDataSource());
    }
}

加载YML数据库配置类

package com.dynamicdatadource.config;

import com.dynamicdatadource.dynamic.DynamicDataSourceService;
import lombok.Data;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.sql.DataSource;
import java.util.List;
import java.util.Map;
import java.util.Set;

@Component
@Data
@ConfigurationProperties(prefix = "spring.datasource")
public class YmlDataSourceProvider  {

    private List<Map<String, DataSourceProperties>> multiDb;

    private DataSource buildDataSource(DataSourceProperties prop) {
        DataSourceBuilder<?> builder = DataSourceBuilder.create();
        builder.driverClassName(prop.getDriverClassName());
        builder.username(prop.getUsername());
        builder.password(prop.getPassword());
        builder.url(prop.getUrl());
        return builder.build();
    }

    public void initDataSource() {
        multiDb.forEach(map -> {
            Set<String> keys = map.keySet();
            keys.forEach(key -> {
                DataSourceProperties properties = map.get(key);
                DataSource dataSource = buildDataSource(properties);
                DynamicDataSourceService.addDataSource(key, dataSource);
            });
        });
    }

    //在构造函数之后执行
    @PostConstruct
    public void init() {
        initDataSource();
    }
}

aop切换

package com.dynamicdatadource.aop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD,ElementType.TYPE})//作用:方法和类
@Retention(RetentionPolicy.RUNTIME)
public @interface DynamicDataSourceAnno {
    String key() default "";
}

package com.dynamicdatadource.aop;
import com.dynamicdatadource.dynamic.DynamicDataSourceService;
import org.apache.commons.lang.StringUtils;
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.stereotype.Component;

// 用于单独的请求或者类进行切换数据库
@Aspect
@Component
public class DynamicDataSourceAspect {
    @Pointcut("@annotation(com.dynamicdatadource.aop.DynamicDataSourceAnno)")
    public void dynamicDataSourceAnno() {
    }

    @Around("dynamicDataSourceAnno()")
    public Object DynamicDataSourceAspectAroundAnno(ProceedingJoinPoint joinPoint) {
        Object object = null;
        try {
            MethodSignature signature = (MethodSignature)joinPoint.getSignature();
            DynamicDataSourceAnno dynamicDataSourceAnno  = signature.getMethod().getAnnotation(DynamicDataSourceAnno.class);
            String key = dynamicDataSourceAnno.key();
            if (StringUtils.isNotBlank(key)) {
                //切换为指定数据库
                DynamicDataSourceService.switchDb(key);
            }
            object = joinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }finally {
            //还原为默认配置
            DynamicDataSourceService.resetDb();
        }
        return object;
    }
    // 还可以扩展包路径切换
}

效果

运行程序之后,就会将数据源加入到数据源列表中了

扩展

MysqlDataSourceInitialize

从数据库中将配置信息查询出来,然后动态添加到数据源列表中

package com.dao.config;

import com.dao.DatasourceDao;
import com.dynamicdatadource.aop.DynamicDataSourceAnno;
import com.dynamicdatadource.dynamic.DynamicDataSourceService;
import com.entity.DataSourceEneity;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.sql.DataSource;
import java.util.List;

//从数据库中查询出全部的数据源,添加到数据源容器中


@Component
public class MysqlDataSourceInitialize implements ApplicationRunner  {

    @Autowired
    private DatasourceDao datasourceDao;

    //项目启动后执行初始化数据源
    @Override
    public void run(ApplicationArguments args) throws Exception {
        try {
            List<DataSourceEneity> dataSources = datasourceDao.getDataSources();
            for (DataSourceEneity dataSource : dataSources) {
                DynamicDataSourceService.addDataSource(dataSource.geTKEy(),dataSource.getDataSource());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

DataSourceEneity实体类

@Data
public class DataSourceEneity {
    private int id;
    private String key;
    private String url;
    private String username;
    private String password;
    private String driverClassName;
    private String type;
    private int state;

    public  DataSource getDataSource() {
        DataSourceBuilder<?> builder = DataSourceBuilder.create();
        builder.driverClassName(driverClassName);
        builder.username(username);
        builder.password(password);
        builder.url(url);
        return  builder.build();
    }
}

总结

到此这篇关于SpringBoot多数据源切换实现的文章就介绍到这了,更多相关SpringBoot多数据源切换内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: SpringBoot多数据源切换实现代码(Mybaitis)

本文链接: https://www.lsjlt.com/news/145722.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

SpringBoot多数据源切换实现代码(Mybaitis)

目录前言配置文件(YML)核心代码DynamicDataSourceDynamicDataSourceServiceDynamicDataSourceConfig加载YML数据库配置...

99+

2024-04-02
SpringBoot多数据源切换怎么实现

本篇内容主要讲解“SpringBoot多数据源切换怎么实现”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“SpringBoot多数据源切换怎么实现”吧!配置文件(YML)spring: ...

99+

2023-06-30
Springboot实现多数据源切换详情

目录1. 实现效果1.1 controller1.2 mybatis.xml1.3 application.yml1.4 启动类2. 注解2.1 @Router3. 分库策略3.1 ...

99+

2024-04-02
SpringBoot实现多数据源的切换实践

目录前言工程结构编码实现yml文件主数据源MainDatasourceProperties其他数据源DynamicDatasourceProperties数据源配置类Datasour...

99+

2024-04-02
SpringBoot怎么实现多数据源的切换

这篇文章主要介绍“SpringBoot怎么实现多数据源的切换”，在日常操作中，相信很多人在SpringBoot怎么实现多数据源的切换问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”SpringBoot怎么实现多...

99+

2023-06-29
springboot中mybatis多数据源动态切换实现

目录多数据源配置引入动态数据源路由实现动态数据源切换使用案例源码在开发中，动态数据源配置还是用的比较多的，比如在多数据源使用方面，又或者是在多个DB之间切换方面。这里给出一个...

99+

2024-04-02
SpringBoot基于AbstractRoutingDataSource实现多数据源动态切换

目录一、场景二、原理三、代码示例一、场景在生产业务中，有一些任务执行了耗时较长的查询操作，在实时性要求不高的时候，我们希望将这些查询sql分离出来，去从库查询，以减少应用对主数据库...

99+

2024-04-02
SpringBoot +DynamicDataSource如何切换多数据源

小编给大家分享一下SpringBoot +DynamicDataSource如何切换多数据源，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！刚开始用一个数...

99+

2023-06-26
Springboot动态切换数据源怎么实现

这篇文章主要介绍“Springboot动态切换数据源怎么实现”，在日常操作中，相信很多人在Springboot动态切换数据源怎么实现问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Springboot动态切换数...

99+

2023-06-25
SpringBoot多数据源配置并通过注解实现动态切换数据源

目录1. 环境准备1.1 数据库准备1.2 项目创建2. ThreadLocal类介绍3. AbstractRoutingDataSource类介绍4. 具体实现4.1 定义数据源枚...

99+

2022-11-13

SpringBoot 动态切换数据源 SpringBoot 切换数据源
SpringBoot基于AbstractRoutingDataSource如何实现多数据源动态切换

本文小编为大家详细介绍“SpringBoot基于AbstractRoutingDataSource如何实现多数据源动态切换”，内容详细，步骤清晰，细节处理妥当，希望这篇“SpringBoot基于AbstractRoutingDataSour...

99+

2023-06-30
【Java多数据源实现教程】实现动态数据源、多数据源切换方式

前言本文为【Java多数据源实现教程】相关知识，由于自己最近在做导师的项目的时候需要使用这种技术，于是自学了相关技术原理与实现，并将其整理如下，具体包含：多数据源的典型使用场景（包含业务复杂场景、读写分离场景），多数据源实现原理及实...

99+

2023-08-16

java mybatis spring
SpringBoot +DynamicDataSource切换多数据源的全过程

目录固定多个数据源切换1.由于我这个版本的自带DynamicDataSource包2.在yml中配置两个数据源3.启动时启动连接池的方法获取4.载入各个连接池5.dynamicDat...

99+

2024-04-02
详解SpringBoot+Mybatis实现动态数据源切换

业务背景电商订单项目分正向和逆向两个部分：其中正向数据库记录了订单的基本信息，包括订单基本信息、订单商品信息、优惠卷信息、发票信息、账期信息、结算信息、订单备注信息、收货人信息等...

99+

2024-04-02
SpringBoot+Mybatis如何实现动态数据源切换

这篇文章主要介绍了SpringBoot+Mybatis如何实现动态数据源切换，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。springboot是什么springboot一种全...

99+

2023-06-14
Spring AOP实现多数据源动态切换

目录需求背景分析及实现配置多数据源信息Spring如何获取配置好的多个数据源信息？Spring如何选择使用数据源？结语需求背景去年底，公司项目有一个需求中有个接口需要用到平台、算法...

99+

2024-04-02
Java注解实现动态数据源切换的实例代码

当一个项目中有多个数据源（也可以是主从库）的时候，我们可以利用注解在mapper接口上标注数据源，从而来实现多个数据源在运行时的动态切换。实现原理在Spring 2.0.1中引入了AbstractRoutingDataSource, 该类充...

99+

2023-05-31

java 数据源切换
Springboot实现根据用户ID切换动态数据源

首先在application.yml 文件添加一下配置 #每个库可连接最大用户数 dynamic-server: #每个服务最大建库数 database-max-num...

99+

2024-04-02
springboot+dynamicDataSource怎么实现动态添加切换数据源

今天小编给大家分享一下springboot+dynamicDataSource怎么实现动态添加切换数据源的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，...

99+

2023-06-26
springboot怎么集成@DS注解实现数据源切换

这篇文章主要介绍“springboot怎么集成@DS注解实现数据源切换”，在日常操作中，相信很多人在springboot怎么集成@DS注解实现数据源切换问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”sprin...

99+

2023-06-29