springboot+mybatis实现多数据源

这篇具有很好参考价值的文章主要介绍了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实现多数据源

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

    2024年02月09日
    浏览(42)
  • 使用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日
    浏览(56)
  • MyBatis整合Springboot多数据源实现

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

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

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

    2024年02月09日
    浏览(38)
  • springboot+mybatis实现mysql和oracle多数据源

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

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

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

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

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

    2024年02月09日
    浏览(104)
  • 使用Spring Boot和JPA实现多数据源的方法

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

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

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

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

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

    2024年02月09日
    浏览(44)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包