springboot+mybatis实现多数据源

已于 2022-11-07 21:21:42 修改
阅读量3.6k 收藏 22
点赞数 4
分类专栏： springboot 文章标签： mybatis spring boot java
于 2022-11-07 21:19:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32603429/article/details/127739634
版权

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 工程目录

image-20221107204456257

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代码重复写

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"}]}
老F的技术屋
关注
  • 4
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
springboot mybatis多数据源加事务嵌套
06-21
springboot mybatis多数据源加事务嵌套 事务之间的调用 回滚 亲测可用 定义2个库分别建立 CREATE TABLE `user` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '用户编号', `user_name` varchar(25) DEFAULT NULL COMMENT '用户名称', `description` varchar(25) DEFAULT NULL COMMENT '描述', PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8; CREATE TABLE `city` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '城市编号', `province_id` int(10) unsigned NOT NULL COMMENT '省份编号', `city_name` varchar(25) DEFAULT NULL COMMENT '城市名称', `description` varchar(25) DEFAULT NULL COMMENT '描述', PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
SpringBoot+MyBatis 配置多数据源 (两种方式实现)
热门推荐
qq_38167579的博客
01-19 2万+
在项目的开发中 , 有时候会涉及到多个数据库的访问 , 也就是多个数据源; 下面记录一下如何使用SpringBoot + MyBatis配置多数据源. 首先使用IDEA搭建一个SpringBoot项目 , 我使用的是JDK1.8 ,SpringBoot版本为1.5.12.RELEASE , 另外添加一些起步依赖 &lt;dependency&gt; &lt;groupId&gt;org...
Spring Boot整合MyBatis配置多数据源
最新发布
null
03-03 1135
多数据源即动态数据源，随着项目开发逐渐扩大，单个数据源、单一数据源已经无法满足需求项目的支撑需求。或是单一数据库无法承载大数据量的访问，需使用多个数据库进行数据的读写分离；或是某些特殊业务需求，需操作不同的数据库。在文章中，展示了Spring Boot整合MyBatis连接数据库的方法，基于此，Spring Boot 整合MyBatis 配置多数据源。
SpringBoot+MyBatis操作多数据源
08-18
SpringBoot+MyBatis操作多数据源示例工程，亲测可用，请放心下载使用。
springboot+mybatis整合多个数据源
曾哥的博客
06-04 489
本文章实现同一个项目，使用不同的参数，来调取不同数据库的数据。 jar依赖 pom.xml <!-- springboot的父类依赖 --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.
实战指南，SpringBoot + Mybatis 如何对接多数据源
GitHub质检员
08-22 794
数据源（Data Source）是指数据存储的地方，大多数情况是指数据库，不过文件服务器、传感器、API等也能算数据源，主要是提供了对数据的访问和操作。数据源中存储了所有建立数据库连接的信息。就像通过指定文件名称可以在文件系统中找到文件一样，通过提供正确的数据源名称，你可以找到相应的数据库连接经过上述的操作，我们已经成功把项目对接了多数据源。当然，方案肯定不止这一种，后续围绕该问题，我们还会讲解其他方式。
springboot mybatis 集成多数据源 两种实现方式
06-30
springboot mybatis 集成多数据源 两种实现方式，一种静态添加，一种动态添加，后者能够支持很好的拓展。使用注解的方式实现，项目打包了一个module
Springboot 之 Mybatis 多数据源实现
天行健，君子以自强不息；地势坤，君子以厚德载物。
09-11 777
简介上篇讲解了 JPA 多数据源实现；这篇讲解一下 Mybatis 多数据源实现 。主要采用将不同数据库的 Mapper 接口分别存放到不同的 package，Spring 去扫描不同的包，注入不同的数据源来实现多数据源。原理跟 JPA 多数据源实现基本一致。创建 mybatis-multip-datasource 项目数据库脚本参考： Springboot 之 JPA 多数据源实...
springboot mybatis 多数据源
qq_42744664的博客
08-23 441
坑点1：在创建SqlSessionFactory的时候需要指定mapper.xml文件的路径，原因：在我们使用多数据源的时候，因为关闭了springboot的默认数据源配置，使用我们自己定义的数据源，此时我们在配置文件中配置的路径是不会生效的，需要我们在定义数据源代码的时候，手动指向一下mapper.xml的位置。一个是getResource，一个是getResources。4.创建两个数据源的DataSource。1.先看一下项目结构。
Springboot +Mybatis实现多数据源配置
weixin_43066287的博客
02-20 3699
Springboot +Mybatis实现多数据源配置
springboot+mybatis配置多数据源，mysql+mysql+oracle
05-07
springboot+mybatis的整合，配置多数据源多数据库连接。里边先进行了mysql+mysql的库2个数据源连接，后边又加了oracle 的库进行连接，总共3个连接，后续所有的库连接都一样，照模子套就可以！
SpringBoot整合Mybatis多数据源配置
12-14
直接开撸 假如存在数据源a和b 一、配置文件配置数据源a和b：(这里使用的是springboot2.0+ 默认数据库连接池hikari) spring: datasource: a: driver-class-name: oracle.jdbc.OracleDriver jdbc-url: username: password: pool-name: b: driver-class-name: oracle.jdbc.OracleDriver jdbc-url: username
Springboot实现mybatis多数据源配置
12-18
SpringBootDemo_mutilDatasource是springboot基于mybatis多数据源实现的Demo
Springboot mybatis多数据源配置项目实例
11-19
Springboot mybatis 多数据源配置 项目实例·················
基于Springboot+MyBatis-Plus实现多租户动态数据源模式源码.zip
12-20
基于Springboot+MyBatis-Plus实现多租户动态数据源模式源码.zip 基于Springboot+MyBatis-Plus实现多租户动态数据源模式源码.zip 基于Springboot+MyBatis-Plus实现多租户动态数据源模式源码.zip 【备注】 主要针对...
springboot + mybatis-plus + oracle + 多数据源 + redis + hutool
04-06
springboot + mybatis-plus + database+ 多数据源 + redis + hutool 框架干净，没有其他冗余的成分； 配置了MP的代码生成器，意见生成代码，节省开发时间！ 可用于各种定时任务处理，各种夸库操作， 多数据源支持...
Springboot2.7.0 + mybatis 搭建多数据源
06-20
Springboot2.7.0 + mybatis 搭建多数据源
详解springboot+mybatis多数据源最简解决方案
08-30
本篇文章主要介绍了详解springboot+mybatis多数据源最简解决方案，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
springboot+mybatis+hikari实现多数据源
06-06
在Spring Boot应用中使用Mybatis和Hikari实现多数据源，可以按照以下步骤进行操作： 1. 在pom.xml文件中添加相关依赖，包括spring-boot-starter-jdbc、mybatis-spring-boot-starter、hikariCP等。 2. 在application.yml配置文件中配置多个数据源，例如： ``` spring: datasource: master: jdbc-url: jdbc:mysql://localhost:3306/master username: root password: root driver-class-name: com.mysql.jdbc.Driver slave: jdbc-url: jdbc:mysql://localhost:3306/slave username: root password: root driver-class-name: com.mysql.jdbc.Driver ``` 3. 创建多个数据源的配置类，例如： ``` @Configuration @MapperScan(basePackages = "com.example.demo.master.mapper", sqlSessionTemplateRef = "masterSqlSessionTemplate") public class MasterDataSourceConfig { @Primary @Bean(name = "masterDataSource") @ConfigurationProperties(prefix = "spring.datasource.master") public DataSource masterDataSource() { return DataSourceBuilder.create().type(HikariDataSource.class).build(); } @Primary @Bean(name = "masterSqlSessionFactory") public SqlSessionFactory masterSqlSessionFactory(@Qualifier("masterDataSource") DataSource dataSource) throws Exception { SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dataSource); return bean.getObject(); } @Primary @Bean(name = "masterTransactionManager") public DataSourceTransactionManager masterTransactionManager(@Qualifier("masterDataSource") DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } @Primary @Bean(name = "masterSqlSessionTemplate") public SqlSessionTemplate masterSqlSessionTemplate(@Qualifier("masterSqlSessionFactory") SqlSessionFactory sqlSessionFactory) { return new SqlSessionTemplate(sqlSessionFactory); } } ``` ``` @Configuration @MapperScan(basePackages = "com.example.demo.slave.mapper", sqlSessionTemplateRef = "slaveSqlSessionTemplate") public class SlaveDataSourceConfig { @Bean(name = "slaveDataSource") @ConfigurationProperties(prefix = "spring.datasource.slave") public DataSource slaveDataSource() { return DataSourceBuilder.create().type(HikariDataSource.class).build(); } @Bean(name = "slaveSqlSessionFactory") public SqlSessionFactory slaveSqlSessionFactory(@Qualifier("slaveDataSource") DataSource dataSource) throws Exception { SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dataSource); return bean.getObject(); } @Bean(name = "slaveTransactionManager") public DataSourceTransactionManager slaveTransactionManager(@Qualifier("slaveDataSource") DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } @Bean(name = "slaveSqlSessionTemplate") public SqlSessionTemplate slaveSqlSessionTemplate(@Qualifier("slaveSqlSessionFactory") SqlSessionFactory sqlSessionFactory) { return new SqlSessionTemplate(sqlSessionFactory); } } ``` 4. 在需要使用数据源的地方使用@Qualifier注解指定数据源，例如： ``` @Service public class UserService { @Autowired @Qualifier("masterSqlSessionTemplate") private SqlSessionTemplate masterSqlSessionTemplate; @Autowired @Qualifier("slaveSqlSessionTemplate") private SqlSessionTemplate slaveSqlSessionTemplate; public List<User> getUsersFromMaster() { return masterSqlSessionTemplate.selectList("com.example.demo.master.mapper.UserMapper.selectAll"); } public List<User> getUsersFromSlave() { return slaveSqlSessionTemplate.selectList("com.example.demo.slave.mapper.UserMapper.selectAll"); } } ``` 这样就可以在Spring Boot应用中使用Mybatis和Hikari实现多数据源了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值