1. Toy模板网首页
  2. > Toy博客

springboot+mybatis实现多数据源

9月前 作者：老F的技术屋 分类：Toy博客 阅读(40) 违法举报

这篇具有很好参考价值的文章主要介绍了springboot+mybatis实现多数据源。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1. 前言

最近做项目碰到了一个需要连4个不同数据库的需求，其中db1、db2表结构都不相同；另外两个数据库same_db_private、same_db_public表结构完全相同，一个对内一个对外，只是从物理上隔离了数据而已。

所以打算通过静态配置包路径的方式来实现db1、db2的操作，并且通过扩展Spring的AbstractRoutingDataSource的方式来实现same_db_private、same_db_public的动态切换数据源。

2. 数据准备

  • db1创建表并准备数据

    create table goods_info
(
    id bigint auto_increment comment '主键' primary key,
	name varchar(50) not null
)collate=utf8mb4_bin;

insert into db1.goods_info (id, name)
values  (1, '商品1'),
        (2, '商品2'),
        (3, '商品3');

  • db1创建表并准备数据

    create table user_info
(
    id bigint auto_increment comment '主键' primary key,
    name varchar(50) not null
)collate=utf8mb4_bin;

insert into db2.user_info (id, name)
values  (1, '用户1'),
        (2, '用户2'),
        (3, '用户3');

  • same_db_private创建表并准备数据

    create table brand_info
(
    id bigint auto_increment comment '主键' primary key,
    name varchar(50) not null
)collate=utf8mb4_bin;

insert into brand_info (id, name)
values  (1, '内部品牌1');

  • same_db_public创建表并准备数据

    create table brand_info
(
    id bigint auto_increment comment '主键' primary key,
    name varchar(50) not null
)collate=utf8mb4_bin;

insert into brand_info (id, name)
values  (1, '外部品牌1');

3. 代码细节

3.1 工程目录

springboot mybatis 多数据源,springboot,mybatis,spring boot,java

3.2 配置文件

spring.datasource.db1.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.db1.username=root
spring.datasource.db1.password=xxxxxx
spring.datasource.db1.jdbc-url=jdbc:mysql://localhost:3306/db1

spring.datasource.db2.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.db2.username=root
spring.datasource.db2.password=xxxxxx
spring.datasource.db2.jdbc-url=jdbc:mysql://localhost:3306/db2

spring.datasource.same-db-private.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.same-db-private.username=root
spring.datasource.same-db-private.password=xxxxxx
spring.datasource.same-db-private.jdbc-url=jdbc:mysql://localhost:3306/same_db_private

spring.datasource.same-db-public.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.same-db-public.username=root
spring.datasource.same-db-public.password=xxxxxx
spring.datasource.same-db-public.jdbc-url=jdbc:mysql://localhost:3306/same_db_public

3.3 静态配置数据源

在config中创建db1和db2的静态数据源配置

package com.aresbf.multi.config;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = "com.aresbf.multi.mapper.db1", sqlSessionFactoryRef = "db1SqlSessionFactory")
public class DataSource1 {

    /**
     * 配置db1数据库
     *
     * @return
     */
    @Bean(name = "db1Datasource")
    @ConfigurationProperties(prefix = "spring.datasource.db1")
    public DataSource testDatasource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 创建SqlSessionFactory
     *
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "db1SqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("db1Datasource") DataSource dataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.getObject().getConfiguration().setMapUnderscoreToCamelCase(true);
        return bean.getObject();
    }

    /**
     * 配置事务管理
     *
     * @param dataSource
     * @return
     */
    @Bean(name = "db1TransactionManager")
    public DataSourceTransactionManager testTransactionManager(
            @Qualifier("db1Datasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "db1SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("db1SqlSessionFactory")
                                                             SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

package com.aresbf.multi.config;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = "com.aresbf.multi.mapper.db2", sqlSessionFactoryRef = "db2SqlSessionFactory")
public class DataSource2 {

    /**
     * 配置db2数据库
     *
     * @return
     */
    @Bean(name = "db2Datasource")
    @ConfigurationProperties(prefix = "spring.datasource.db2")
    public DataSource testDatasource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 创建SqlSessionFactory
     *
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "db2SqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("db2Datasource") DataSource dataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.getObject().getConfiguration().setMapUnderscoreToCamelCase(true);
        return bean.getObject();
    }

    /**
     * 配置事务管理
     *
     * @param dataSource
     * @return
     */
    @Bean(name = "db2TransactionManager")
    public DataSourceTransactionManager testTransactionManager(
            @Qualifier("db2Datasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "db2SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("db2SqlSessionFactory")
                                                             SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

3.4 动态切换数据源

  1. 创建动态数据源配置

    package com.aresbf.multi.config;

import com.aresbf.multi.dynamicdatasource.DataSourceRouting;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

/**
 * @description:sameDb动态数据源
 * @author: aresbf
 * @createDate: 2022/10/21
 */
@Configuration
@Slf4j
@MapperScan(basePackages = "com.aresbf.multi.mapper.same_db", sqlSessionTemplateRef = "sameDbDynamicSqlSessionTemplate")
public class SameDbDynamicDataSourceConfig {

    /**
     * 自定义动态datasource
     *
     * @param sameDbPrivateDataSource 对内datasource
     * @param sameDbPublicDataSource  对外datasource
     * @return DataSource
     */
    @Bean(name = "sameDbDynamicDataSource")
    @Primary
    public DataSource dataSource(@Qualifier("sameDbPrivateDataSource") DataSource sameDbPrivateDataSource, @Qualifier("sameDbPublicDataSource") DataSource sameDbPublicDataSource) {
        DataSourceRouting routingDataSource = new DataSourceRouting();
        routingDataSource.initDatasource(sameDbPrivateDataSource,
                sameDbPublicDataSource);
        return routingDataSource;
    }

    /**
     * 对内datasource
     *
     * @return DataSource
     */
    @Bean(name = "sameDbPrivateDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.same-db-private")
    public DataSource sameDbPrivateDataSource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 对外datasource
     *
     * @return DataSource
     */
    @Bean(name = "sameDbPublicDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.same-db-public")
    public DataSource sameDbPublicDataSource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 自定义SqlSessionFactory
     *
     * @param dataSource 自定义datasource
     * @return SqlSessionFactory
     * @throws Exception
     */
    @Bean(name = "sameDbDynamicSqlSessionFactory")
    public SqlSessionFactory customSqlSessionFactory(@Qualifier("sameDbDynamicDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        //实现数据库下划线字段到POJO类驼峰形式的自动映射
        bean.getObject().getConfiguration().setMapUnderscoreToCamelCase(true);
        return bean.getObject();
    }

    /**
     * 自定义DataSourceTransactionManager
     *
     * @param dataSource 自定义datasource
     * @return DataSourceTransactionManager
     */
    @Bean(name = "sameDbDynamicTransactionManager")
    @Primary
    public DataSourceTransactionManager customTransactionManager(@Qualifier("sameDbDynamicDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     * 自定义SqlSessionTemplate
     *
     * @param sqlSessionFactory 自定义SqlSessionFactory
     * @return SqlSessionTemplate
     */
    @Bean(name = "sameDbDynamicSqlSessionTemplate")
    @Primary
    public SqlSessionTemplate customSqlSessionTemplate(@Qualifier("sameDbDynamicSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

  2. 创建区分动态数据源枚举项

    package com.aresbf.multi.dynamicdatasource;

import lombok.Getter;

/**
 * @description: 动态数据源枚举
 * @author: aresbf
 * @createDate: 2022/10/26
 */
public enum DynamicDataSourceEnum {
    /**
     * 对内系统数据库
     */
    SAME_DB_PRIVATE("SAME_DB_PRIVATE", "对内系统数据库"),
    /**
     * 对外系统数据库
     */
    SAME_DB_PUBLIC("SAME_DB_PUBLIC", "对外系统数据库"),
    ;

    /**
     * 数据源code
     */
    @Getter
    private final String dataSource;
    /**
     * 描述
     */
    private final String description;

    /**
     * 构造器
     *
     * @param dataSource  数据源标识
     * @param description 描述
     */
    DynamicDataSourceEnum(String dataSource, String description) {
        this.dataSource = dataSource;
        this.description = description;
    }
}

  3. 动态数据源切换上下文

    package com.aresbf.multi.dynamicdatasource;

import lombok.extern.slf4j.Slf4j;

/**
 * @description: 动态数据源切换用上下文
 * @author: aresbf
 * @createDate: 2022/10/26
 */
@Slf4j
public class DataSourceContextHolder {

    /**
     * 用于存在数据源切换标识
     */
    private static ThreadLocal<DynamicDataSourceEnum> datasourceContext = new ThreadLocal<>();

    /**
     * 切换数据源
     *
     * @param dynamicDataSourceEnum 要切换的数据源标识
     */
    public static void switchDataSource(DynamicDataSourceEnum dynamicDataSourceEnum) {
        log.debug("switchDataSource: {}", dynamicDataSourceEnum.getDataSource());
        datasourceContext.set(dynamicDataSourceEnum);
    }

    /**
     * 获取当前的数据源标识
     *
     * @return
     */
    public static DynamicDataSourceEnum getDataSource() {
        return datasourceContext.get();
    }

    /**
     * 清理上下文中的数据源标识
     */
    public static void clear() {
        datasourceContext.remove();
    }
}

  4. 动态路由

    package com.aresbf.multi.dynamicdatasource;

import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

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

/**
 * @description:动态数据源路由
 * @author: aresbf
 * @createDate: 2022/10/26
 */
@Slf4j
public class DataSourceRouting extends AbstractRoutingDataSource {

    /**
     * 决定使用哪个数据源标识
     *
     * @return 数据源标识
     */
    @Override
    protected Object determineCurrentLookupKey() {
        DynamicDataSourceEnum dynamicDataSourceEnum = DataSourceContextHolder.getDataSource();
        //如果没有设置数据源标识，默认使用对内数据源标识
        if (dynamicDataSourceEnum == null) {
            dynamicDataSourceEnum = DynamicDataSourceEnum.SAME_DB_PRIVATE;
        }
        log.debug("use{}", dynamicDataSourceEnum.getDataSource());
        return dynamicDataSourceEnum;
    }

    /**
     * 初始化数据源列表
     *
     * @param sameDbPrivate 对内数据源
     * @param sameDbPublic  对外数据源
     */
    public void initDatasource(DataSource sameDbPrivate,
                               DataSource sameDbPublic) {
        Map<Object, Object> dataSourceMap = new HashMap<>();
        dataSourceMap.put(DynamicDataSourceEnum.SAME_DB_PRIVATE, sameDbPrivate);
        dataSourceMap.put(DynamicDataSourceEnum.SAME_DB_PUBLIC, sameDbPublic);
        this.setTargetDataSources(dataSourceMap);
        this.setDefaultTargetDataSource(sameDbPrivate);
    }
}

  5. 自定义动态数据源注解

    package com.aresbf.multi.dynamicdatasource;

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

/**
 * @description:自定义动态数据源注解
 * @author: aresbf
 * @createDate: 2022/10/26
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface SameDbDynamicDataSource {
    /**
     * 数据源标识
     *
     * @return DynamicDataSourceEnum
     */
    DynamicDataSourceEnum name() default DynamicDataSourceEnum.SAME_DB_PRIVATE;
}

  6. 动态数据源拦截

    package com.aresbf.multi.dynamicdatasource;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @description:动态数据源拦截
 * @author: aresbf
 * @createDate: 2022/10/26
 */
@Aspect
@Component
public class HandleDatasourceAspect {

    /**
     * 所有标识sameDbDynamicDataSource注解的类和方法
     */
    @Pointcut("@annotation(com.aresbf.multi.dynamicdatasource.SameDbDynamicDataSource)||@within(com.aresbf.multi.dynamicdatasource.SameDbDynamicDataSource)")
    public void pointcut() {
    }

    /**
     * 方法执行前
     *
     * @param joinPoint 拦截点
     */
    @Before("pointcut()")
    public void beforeExecute(JoinPoint joinPoint) {
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        SameDbDynamicDataSource annotation = method.getAnnotation(SameDbDynamicDataSource.class);
        if (null == annotation) {
            annotation = joinPoint.getTarget().getClass().getAnnotation(SameDbDynamicDataSource.class);
        }
        if (null != annotation) {
            // 切换数据源
            DataSourceContextHolder.switchDataSource(annotation.name());
        }
    }

    /**
     * 方法执行后
     */
    @After("pointcut()")
    public void afterExecute() {
        DataSourceContextHolder.clear();
    }
}

3.5 编写测试类

通过SameDbDynamicDataSource动态指定需要访问的数据源，避免相同的mapper代码重复写文章来源地址https://www.toymoban.com/news/detail-700221.html

package com.aresbf.multi.controller;

import com.aresbf.multi.dynamicdatasource.DynamicDataSourceEnum;
import com.aresbf.multi.dynamicdatasource.SameDbDynamicDataSource;
import com.aresbf.multi.entity.BrandInfoPO;
import com.aresbf.multi.entity.GoodsInfoPO;
import com.aresbf.multi.entity.UserInfoPO;
import com.aresbf.multi.service.BrandInfoService;
import com.aresbf.multi.service.GoodsInfoService;
import com.aresbf.multi.service.UserInfoService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.List;

/**
 * @description: 测试
 * @author: aresbf
 * @createDate: 2022/10/24
 */
@RestController
@RequestMapping
@Slf4j
public class TestController {
    @Autowired
    private GoodsInfoService goodsInfoService;
    @Autowired
    private UserInfoService userInfoService;
    @Autowired
    private BrandInfoService brandInfoService;

    /**
     * 查内部
     *
     * @return ok
     */
    @GetMapping("/queryPrivate")
    @SameDbDynamicDataSource(name = DynamicDataSourceEnum.SAME_DB_PRIVATE)
    public String queryPrivate() throws JsonProcessingException {
        List<GoodsInfoPO> goodsInfoPOS = goodsInfoService.queryAll();
        List<UserInfoPO> userInfoPOS = userInfoService.queryAll();
        List<BrandInfoPO> brandInfoPOS = brandInfoService.queryAll();
        HashMap<String, List> resultMap = new HashMap<>();
        resultMap.put("goodsInfo", goodsInfoPOS);
        resultMap.put("userInfo", userInfoPOS);
        resultMap.put("brandInfo", brandInfoPOS);
        ObjectMapper objectMapper = new ObjectMapper();
        return objectMapper.writeValueAsString(resultMap);
    }

    /**
     * 查外部
     *
     * @return ok
     */
    @GetMapping("/queryPublic")
    @SameDbDynamicDataSource(name = DynamicDataSourceEnum.SAME_DB_PUBLIC)
    public String queryPublic() throws JsonProcessingException {
        List<GoodsInfoPO> goodsInfoPOS = goodsInfoService.queryAll();
        List<UserInfoPO> userInfoPOS = userInfoService.queryAll();
        List<BrandInfoPO> brandInfoPOS = brandInfoService.queryAll();
        HashMap<String, List> resultMap = new HashMap<>();
        resultMap.put("goodsInfo", goodsInfoPOS);
        resultMap.put("userInfo", userInfoPOS);
        resultMap.put("brandInfo", brandInfoPOS);
        ObjectMapper objectMapper = new ObjectMapper();
        return objectMapper.writeValueAsString(resultMap);
    }
}

3.6 测试结果

3.6.1 请求http://localhost:8080/queryPublic

{"userInfo":[{"id":1,"name":"用户1"},{"id":2,"name":"用户2"},{"id":3,"name":"用户3"}],"brandInfo":[{"id":1,"name":"外部品牌1"}],"goodsInfo":[{"id":1,"name":"商品1"},{"id":2,"name":"商品2"},{"id":3,"name":"商品3"}]}

3.6.2 请求http://localhost:8080/queryPrivate

{"userInfo":[{"id":1,"name":"用户1"},{"id":2,"name":"用户2"},{"id":3,"name":"用户3"}],"brandInfo":[{"id":1,"name":"内部品牌1"}],"goodsInfo":[{"id":1,"name":"商品1"},{"id":2,"name":"商品2"},{"id":3,"name":"商品3"}]}

到了这里，关于springboot+mybatis实现多数据源的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • springboot+mybatis实现多数据源

    springboot+mybatis实现多数据源

    最近做项目碰到了一个需要连4个不同数据库的需求，其中db1、db2表结构都不相同；另外两个数据库same_db_private、same_db_public表结构完全相同，一个对内一个对外，只是从物理上隔离了数据而已。 所以打算通过静态配置包路径的方式来实现db1、db2的操作，并且通过扩展Spring的

    2024年02月09日
    浏览(40)

  • 使用dynamic-datasource-spring-boot-starter动态切换数据源操作数据库(MyBatis-3.5.9)

    记录 ：383 场景 ：使用dynamic-datasource-spring-boot-starter动态切换数据源，使用MyBatis操作数据库。提供三种示例：一，使用@DS注解作用到类上。二，使用@DS注解作用到方法上。三，不使用注解，使用DynamicDataSourceContextHolder类在方法内灵活切换不同数据源。 源码： https://github.com/

    2024年01月20日
    浏览(52)
  • MyBatis整合Springboot多数据源实现

    MyBatis整合Springboot多数据源实现

    数据源，实际就是数据库连接池，负责管理数据库连接，在 Springboot 中，数据源通常以一个 bean 的形式存在于 IOC 容器中，也就是我们可以通过依赖注入的方式拿到数据源，然后再从数据源中获取数据库连接。 那么什么是多数据源呢，其实就是 IOC 容器中有多个数据源的 bea

    2023年04月22日
    浏览(61)
  • SpringBoot结合MyBatis实现多数据源配置

    SpringBoot结合MyBatis实现多数据源配置

    SpringBoot框架实现多数据源操作，首先需要搭建Mybatis的运行环境。 由于是多数据源，也就是要有多个数据库，所以，我们创建两个测试数据库，分别是：【sp-demo01】和【sp-demo02】，如下图所示： 具体SQL代码： 创建【sp-demo01】数据库。 创建【sp-demo02】数据库。 MyBatis框架中，

    2024年02月09日
    浏览(37)

  • springboot+mybatis实现mysql和oracle多数据源

    在实际项目中很多时候会涉及到多个数据库的访问，或者数据库读写分离的形式。 下面通过使用 Aspect+注解来实现mysql+oracle的多数据源配置（注意：事务一致性未提供） 首先要去oracle官网下载ojdbc的jar包，根据oracle的版本去下载，或者在下载的oracle的jdbc包下的lib里面有，然后

    2024年02月07日
    浏览(57)
  • springBoot-Mybatis-Plus 多数据源切换实现

    springBoot-Mybatis-Plus 多数据源切换实现

    前言：本文主要通过AbstractRoutingDataSource，实现根据 http 访问携带的标识动态切换数据源； 1 AbstractRoutingDataSource 介绍： AbstractRoutingDataSource 是 Spring 框架中的一个抽象类，它可以用来实现动态数据源切换。在多数据源场景下，AbstractRoutingDataSource 可以根据不同的请求来动态地选

    2024年02月03日
    浏览(49)
  • SpringBoot整合Mybatis-Plus+Druid实现多数据源

    SpringBoot整合Mybatis-Plus+Druid实现多数据源

    🌺本文主要讲解 springboot +mybatisplus + druid 实现多数据源配置功能 🌺 主页传送门：📀 传送 Spring Boot：    Spring Boot是一个基于Spring框架的开源Java开发框架，旨在简化Spring应用程序的开发、配置和部署。它提供了一种快速、敏捷的方式来构建独立的、生产级别的Spring应用程

    2024年02月09日
    浏览(102)

  • 使用Spring Boot和JPA实现多数据源的方法

    使用Spring Boot和JPA实现多数据源的方法： 添加相关依赖：在pom.xml文件中添加Spring Boot和JPA的依赖项，例如Spring Boot Starter Data JPA和相应的数据库驱动。 配置数据源：在application.properties（或application.yml）文件中，配置多个数据源的连接信息，如数据库URL、用户名和密码。 创建数

    2024年01月21日
    浏览(72)
  • Spring Boot集成Druid实现多数据源的两种方式

    Spring Boot集成Druid实现多数据源的两种方式

    目录 项目场景： 一、集成com.baomidou的方式 1、maven依赖： 2、 配置文件： 3、 使用注解切换数据源：  二、基于AOP手动实现多数据源原生的方式 1、maven依赖： 2、 配置文件： 3、 多数据源名称类 4、自定义注解  5、配置类 6、动态数据源配置  7、AOP切面拦截注解 8、Dao层，

    2024年02月09日
    浏览(43)
  • 如何在Spring Boot应用中使用Nacos实现动态更新数据源

    如何在Spring Boot应用中使用Nacos实现动态更新数据源

    🌷🍁 博主猫头虎 带您 Go to New World.✨🍁 🦄 博客首页——猫头虎的博客🎐 🐳《面试题大全专栏》 文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~🌺 🌊 《IDEA开发秘籍专栏》学会IDEA常用操作，工作效率翻倍~💐 🌊 《100天精通Golang(基础入门篇）》学会Golang语言

    2024年02月10日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包