Springboot 多数据源整合的三种方式

已于 2024-01-20 22:52:07 修改
阅读量1.8k 收藏 25
点赞数 25
分类专栏： springboot 数据库 文章标签： spring boot mybatis 数据库
于 2024-01-20 22:50:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40352912/article/details/135721765
版权

方式一: 使用Spring提供的AbstractRoutingDataSource

配置文件

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    datasource1:
      url: jdbc:mysql://127.0.0.1:3306/dcytest?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF8&useSSL=false
      username: root
      password: root
      initial-size: 1
      min-idle: 1
      max-active: 20
      test-on-borrow: true
      driver-class-name: com.mysql.cj.jdbc.Driver
    datasource2:
      url: jdbc:mysql://127.0.0.1:3306/drools?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF8&useSSL=false
      username: root
      password: root
      initial-size: 1
      min-idle: 1
      max-active: 20
      test-on-borrow: true
      driver-class-name: com.mysql.cj.jdbc.Driver

主要依赖

       <!-- 阿里数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid.version}</version>
        </dependency>
         <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.1</version>
        </dependency>

核心代码

  • 定义数据源注解
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 DS {
	// 默认数据源
    String value() default "ds1";
}
  • 使用AbstractRoutingDataSource返回当前数据源
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * @description:
 * @author: dcy
 * @create: 2024-01-20 20:27
 */

public class DynamicDataSource extends AbstractRoutingDataSource {


    // 当前使用的数据源标识
    public static ThreadLocal<String> name=new ThreadLocal<>();

    // 返回当前数据源标识
    @Override
    protected Object determineCurrentLookupKey() {
        return name.get();
    }
}
  • 数据源配置
import cn.ac.zing.dyds.ds1.ds.DynamicDataSource;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

/**
 * @description:
 * @author: dcy
 * @create: 2024-01-20 20:22
 */
@Configuration
public class DataSourceConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.datasource1")
    public DataSource dataSource1() {
        // 底层会自动拿到spring.datasource中的配置， 创建一个DruidDataSource
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.datasource2")
    public DataSource dataSource2() {
        // 底层会自动拿到spring.datasource中的配置， 创建一个DruidDataSource
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    public DataSource myRoutingDataSource(@Qualifier("dataSource1") DataSource dataSource1,
                                          @Qualifier("dataSource2") DataSource dataSource2) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("ds1", dataSource1);
        targetDataSources.put("ds2", dataSource2);

        DynamicDataSource myRoutingDataSource = new DynamicDataSource();
        myRoutingDataSource.setDefaultTargetDataSource(dataSource1);
        myRoutingDataSource.setTargetDataSources(targetDataSources);
        return myRoutingDataSource;
    }
}
  • MyBatis xml配置
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
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 org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.annotation.Resource;
import javax.sql.DataSource;

/**
 * @description:
 * @author: dcy
 * @create: 2024-01-20 21:28
 */
@EnableTransactionManagement
@Configuration
public class MyBatisConfig {

    @Resource(name = "myRoutingDataSource")
    private DataSource myRoutingDataSource;


    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(myRoutingDataSource);
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/**/*.xml"));
        return sqlSessionFactoryBean.getObject();
    }

    @Bean
    public PlatformTransactionManager platformTransactionManager() {
        return new DataSourceTransactionManager(myRoutingDataSource);
    }
}
  • 使用AOP设置需要使用的数据源
import cn.ac.zing.dyds.ds1.annotation.DS;
import cn.ac.zing.dyds.ds1.ds.DynamicDataSource;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * @description:
 * @author: dcy
 * @create: 2024-01-20 20:35
 */
@Component
@Aspect
public class DynamicDataSourceAspect {

    // 前置
    @Before("within(cn.ac.zing.dyds.ds1.service.impl.*) && @annotation(ds)")
    public void before(JoinPoint point, DS ds){
        String name = ds.value();
        DynamicDataSource.name.set(name);

        System.out.println(name);
    }
}

使用

  • mapper
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;
import java.util.Map;

@Mapper
public interface DSMapper {


    List<Map<String, Object>> selectStudentList();

    List<Map<String, Object>> selectRuleInfoList();

}
  • 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="cn.ac.zing.dyds.ds1.mapper.DSMapper">

<select id="selectStudentList" resultType="java.util.Map">
    select * from student
</select>

</mapper>

<?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="cn.ac.zing.dyds.ds1.mapper.DSMapper">

<select id="selectRuleInfoList" resultType="java.util.Map">
    select * from rule_info
</select>

</mapper>
  • service
import java.util.List;
import java.util.Map;

public interface DSService {

    List<Map<String, Object>> selectStudentList();

    List<Map<String, Object>> selectRuleInfoList();
}


import cn.ac.zing.dyds.ds1.annotation.DS;
import cn.ac.zing.dyds.ds1.mapper.DSMapper;
import cn.ac.zing.dyds.ds1.service.DSService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

/**
 * @description:
 * @author: dcy
 * @create: 2024-01-20 20:33
 */
@Service
public class DSServiceImpl implements DSService {

    @Resource
    DSMapper dsMapper;

    @DS("ds1")
    @Override
    public List<Map<String, Object>> selectStudentList() {
        return dsMapper.selectStudentList();
    }

    @DS("ds2")
    @Override
    public List<Map<String, Object>> selectRuleInfoList() {
        return dsMapper.selectRuleInfoList();
    }
}

方式二: 使用MyBatis注册多个SqlSessionFactory

配置文件

server:
  port: 8081
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    datasource1:
      url: jdbc:mysql://127.0.0.1:3306/dcytest?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF8&useSSL=false
      username: root
      password: root
      initial-size: 1
      min-idle: 1
      max-active: 20
      test-on-borrow: true
      driver-class-name: com.mysql.cj.jdbc.Driver
    datasource2:
      url: jdbc:mysql://127.0.0.1:3306/drools?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF8&useSSL=false
      username: root
      password: root
      initial-size: 1
      min-idle: 1
      max-active: 20
      test-on-borrow: true
      driver-class-name: com.mysql.cj.jdbc.Driver

主要依赖

       <!-- 阿里数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.1</version>
        </dependency>

数据源配置

  • 数据源1
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;

import javax.sql.DataSource;

/**
 * @description:
 * @author: dcy
 * @create: 2024-01-20 21:52
 */
@Configuration
// 继承mybatis:
// 1. 指定扫描的mapper接口包（主库）
// 2. 指定使用sqlSessionFactory是哪个（主库）
@MapperScan(basePackages = "cn.ac.zing.dyds.ds2.mapper.ds1",
        sqlSessionFactoryRef="ds1SqlSessionFactory")
public class DS1Config {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.datasource1")
    public DataSource dataSource1() {
        // 底层会自动拿到spring.datasource中的配置， 创建一个DruidDataSource
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @Primary
    public SqlSessionFactory ds1SqlSessionFactory()
            throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        // 指定主库
        sessionFactory.setDataSource(dataSource1());
        // 指定主库对应的mapper.xml文件
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:mapper/ds1/*.xml"));
        return sessionFactory.getObject();
    }

    @Bean
    @Primary
    public DataSourceTransactionManager ds1TransactionManager(){
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dataSource1());
        return dataSourceTransactionManager;
    }


    @Bean
    public TransactionTemplate ds1TransactionTemplate(){
        return new TransactionTemplate(ds1TransactionManager());
    }
}
  • 数据源2
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;

import javax.sql.DataSource;

/**
 * @description:
 * @author: dcy
 * @create: 2024-01-20 21:52
 */
@Configuration
// 继承mybatis:
// 1. 指定扫描的mapper接口包（主库）
// 2. 指定使用sqlSessionFactory是哪个（主库）
@MapperScan(basePackages = "cn.ac.zing.dyds.ds2.mapper.ds2",
        sqlSessionFactoryRef="ds2SqlSessionFactory")
public class DS2Config {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.datasource2")
    public DataSource dataSource2() {
        // 底层会自动拿到spring.datasource中的配置， 创建一个DruidDataSource
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @Primary
    public SqlSessionFactory ds2SqlSessionFactory()
            throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        // 指定主库
        sessionFactory.setDataSource(dataSource2());
        // 指定主库对应的mapper.xml文件
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:mapper/ds2/*.xml"));
        return sessionFactory.getObject();
    }

    @Bean
    @Primary
    public DataSourceTransactionManager ds2TransactionManager(){
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dataSource2());
        return dataSourceTransactionManager;
    }


    @Bean
    public TransactionTemplate ds2TransactionTemplate(){
        return new TransactionTemplate(ds2TransactionManager());
    }
}

使用

  • DS1Mapper
import java.util.List;
import java.util.Map;

public interface DS1Mapper {

    List<Map<String, Object>> selectStudentList();
}
  • DS2Mapper
import java.util.List;
import java.util.Map;

public interface DS2Mapper {

    List<Map<String, Object>> selectRuleInfoList();
}
  • service
import java.util.List;
import java.util.Map;

public interface DSService {

    List<Map<String, Object>> selectStudentList();

    List<Map<String, Object>> selectRuleInfoList();
}

import cn.ac.zing.dyds.ds2.mapper.ds1.DS1Mapper;
import cn.ac.zing.dyds.ds2.mapper.ds2.DS2Mapper;
import cn.ac.zing.dyds.ds2.service.DSService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

/**
 * @description:
 * @author: dcy
 * @create: 2024-01-20 20:33
 */
@Service
public class DSServiceImpl implements DSService {

    @Resource
    DS1Mapper ds1Mapper;

    @Resource
    DS2Mapper ds2Mapper;


    @Override
    public List<Map<String, Object>> selectStudentList() {
        return ds1Mapper.selectStudentList();
    }

    @Override
    public List<Map<String, Object>> selectRuleInfoList() {
        return ds2Mapper.selectRuleInfoList();
    }
}
  • 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="cn.ac.zing.dyds.ds2.mapper.ds1.DS1Mapper">

<select id="selectStudentList" resultType="java.util.Map">
    select * from student
</select>

</mapper>

<?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="cn.ac.zing.dyds.ds2.mapper.ds2.DS2Mapper">

<select id="selectRuleInfoList" resultType="java.util.Map">
    select * from rule_info
</select>

</mapper>

方式三: 使用dynamic-datasource框架

配置文件

server:
  port: 8081
spring:
  datasource:
    dynamic:
      #设置默认的数据源或者数据源组,默认值即为datasource1
      primary: ds1
      #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源
      strict: false
      datasource:
        ds1:
          url: jdbc:mysql://127.0.0.1:3306/dcytest?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF8&useSSL=false
          username: root
          password: root
          initial-size: 1
          min-idle: 1
          max-active: 20
          test-on-borrow: true
          driver-class-name: com.mysql.cj.jdbc.Driver
        ds2:
          url: jdbc:mysql://127.0.0.1:3306/drools?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF8&useSSL=false
          username: root
          password: root
          initial-size: 1
          min-idle: 1
          max-active: 20
          test-on-borrow: true
          driver-class-name: com.mysql.cj.jdbc.Driver

#配置mapper xml文件的路径
mybatis:
  mapper-locations: mapper/**/*.xml

核心依赖

    <dependencies>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.1</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
            <version>3.5.0</version>
        </dependency>
    </dependencies>

使用

  • Mapper
import com.baomidou.dynamic.datasource.annotation.DS;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;
import java.util.Map;

@Mapper
public interface DSMapper {


    @DS("ds1")
    List<Map<String, Object>> selectStudentList();

    @DS("ds2")
    List<Map<String, Object>> selectRuleInfoList();

}
  • service
import java.util.List;
import java.util.Map;

public interface DSService {

    List<Map<String, Object>> selectStudentList();

    List<Map<String, Object>> selectRuleInfoList();
}

import cn.ac.zing.dyds.ds3.mapper.DSMapper;
import cn.ac.zing.dyds.ds3.service.DSService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

/**
 * @description:
 * @author: dcy
 * @create: 2024-01-20 20:33
 */
@Service
public class DSServiceImpl implements DSService {

    @Resource
    DSMapper dsMapper;

    @Override
    public List<Map<String, Object>> selectStudentList() {
        return dsMapper.selectStudentList();
    }

    @Override
    public List<Map<String, Object>> selectRuleInfoList() {
        return dsMapper.selectRuleInfoList();
    }
}
  • 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="cn.ac.zing.dyds.ds3.mapper.DSMapper">

<select id="selectStudentList" resultType="java.util.Map">
    select * from student
</select>

</mapper>

<?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="cn.ac.zing.dyds.ds3.mapper.DSMapper">

<select id="selectRuleInfoList" resultType="java.util.Map">
    select * from rule_info
</select>

</mapper>
9527dddcy
关注
专栏目录
SpringBoot整合多数据源
冲出仁川，走出马德里，故事还会再继续
01-24 631
我们在调用任何持久层的框架，都是基于JDBC进行操作的，只要集成了Spring框架就一定会注入配置的DataSource获取连接。既然是我们配置的，我们可以实现一个自定义的DataSource,然后动态提供数据源。说干就干那我们实现DataSource这个接口，实现方法即可，会返回一个Connection对象。我们在这个方法中根据业务需求动态提供不同数据源的Connection对象即可。实现逻辑如下：我们可以通过一个静态的标识去判断，比如如果是Write,那就返回,如果是Read，就返回。
SpringBoot配置多数据源实现动态切换数据源
06-29
通过简单的demo实现SpingBoot多数据源配置并动态切换多数据源
springboot 多数据源的实现(最简单的整合方式)
08-25
主要介绍了springboot 多数据源的实现(最简单的整合方式)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Springboot-多数据源
最新发布
huiguo_的博客
09-24 691
实现Springboot功能，在不同的文件夹使用不同的数据库。
【Spring Boot】Spring Boot整合多数据源
DreamSun的博客
08-24 2142
在实际的开发工作中，我们经常会遇到需要整合多个数据源的情况，比如同时连接多个数据库、读写分离、跨数据库查询等。本文将介绍如何使用Spring Boot来实现多数据源的整合，对于刚刚接触开发的小伙伴可能有一些帮助。在一个应用程序中使用多个数据源意味着我们需要在不同的数据源之间进行切换，以便从不同的数据源中获取数据。多数据源可以是关系数据库、NoSQL 数据库、平面文件、XML 文件等。在一个应用程序中使用多数据源的好处是，我们可以根据应用程序的需求选择最合适的数据源，从而提高应用程序的性能和可扩展性。
SpringBoot如何整合多个数据源，看这篇就够了
chengkun4890的博客
07-01 2667
SpringBoot现在是很多很多公司应用的后端框架，因为它搭建快，能更好、更快速的整合其他第三方。那么随着业务的不断扩展，业务量的增加，这时候就会牵扯到分库分表，虽然这个词听起来很熟悉，作为程序员也很容易理解，但是我想应该也有不少读者没接触过分库分表，今天我们不聊如何分库分表，而是聊Spri...
SpringBoot整合多数据源实现
qq_38983002的博客
04-06 166
项目架构 1.导入相关依赖 1 <dependency> 2 <groupId>org.springframework.boot</groupId> 3 <artifactId>spring-boot-starter-web</artifactId> ...
SpringBoot多数据源
大老杨的博客
04-11 5899
很多业务场景都需要使用到多数据库，本文介绍springboot对多数据源的使用。 这次先说一下application.properties文件，分别连接了2个数据库test和test1。完整代码如下： ##端口号 server.port=8888 ##数据库url spring.datasource.test.url=jdbc:mysql://localhost:3306/test?c...
完整Demo：springboot集成多数据源
07-28
完整Demo：springboot集成多数据源，是一个完整的项目，直接下载下来导入eclipse或idea，启动后运行即可。
springboot项目连接多个数据库
05-22
springboot项目，内有mybatis逆向工程，swagger2配置，不同数据库操作在不同的mapper中， 如第一个数据库在mapper中操作，第二个数据库在mapper2中操作，第三个数据库在mapper3中操作
SpringBoot 多数据源
07-03
springboot 多数据源 MySQL 分库分表策略。 springboot 多数据源 MySQL 分库分表策略。
springboot多数据源整合
06-03
在Spring Boot应用中，"springboot多数据源整合"是一个重要的技术主题，它涉及到如何在一个项目中同时管理多个数据库连接，以实现不同业务场景的数据隔离或者读写分离。这一技术通常用于大型分布式系统，以便更好地...
springboot多数据源整合sqlserver
04-20
本项目是关于如何在Spring Boot环境中整合三个数据源，其中两个是MySQL数据库，另一个是SQL Server数据库。 首先，我们需要了解Spring Boot的自动配置特性。Spring Boot通过`@EnableAutoConfiguration`注解自动配置...
Springboot实现多数据源整合的两种方式
m0_63550462的博客
11-02 6590
一、前言 大家好，我是小诚，不知不觉上一次更文已经是20多天前了！其实这段时间也一直没有闲着，一个是在梳理之前的文章知识和资源，用于搭建技术圈子，另外一个就是在思考自己的一个输出方向，社区发展得很迅速，热榜各种各类的文章都有，深思熟虑后，还是坚持文章在精不在多，质量标准更加重要，所以今后博文的方向会更加偏向实战和经验，争取分享更加有价值的博文！ 如果文章对你有帮助，可以帮忙一键三连和专栏订阅哦！ 技术圈子经过这段时间的筹划，已经初步成型！有兴趣、志同道合的小伙伴可以查看左边导航栏的技术圈子介
SpringBoot 整合多数据源
qq_38845271的博客
11-08 267
1，SpringBoot 整合多数据源介绍 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20201108121258578.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4ODQ1Mjcx,size_16,color_FFFFFF,t_70#pic_center) 2，application.yml
SpringBoot多数据源集成
zwrlj527的专栏
05-18 1414
前言 今天分享下SpringBoot多数据源集成，我怕麻烦，这里我觉得我的集成也应该是最简单的，清晰明了。 一、多数据源使用场景与弊端 1.场景 业务系统跨数据库 数据转存（这个现在太low了，应该高级点都不用） 系统集成 2.弊端 跨库业务事务问题 service、dao不能重复注入数据源 二、使用步骤 1.引入库 <!-- 多数据源支持 --> <dependency> <groupId>com.baomidou</groupId&
springboot 整合多数据源
08-20
springboot可以通过使用dynamic-datasource-spring-boot-starter来实现多数据源的整合。该启动器基于springboot，可以快速集成多个数据源。一般的思路是根据自定义的配置数据源信息初始化数据源，并使用druid连接池和mybatis进行相关配置。引用 具体步骤可以包括以下几个方面： 1. 引入相关依赖：在项目的pom.xml文件中添加dynamic-datasource-spring-boot-starter、druid-spring-boot-starter和mybatis-spring-boot-starter等依赖。引用 2. 配置数据源信息：在application.yml或application.properties文件中配置多个数据源的信息，包括数据库的连接地址、用户名、密码等。可以使用@ConfigurationProperties注解来绑定配置文件中的数据源信息到对应的实体类中。 3. 初始化数据源：使用Configuration类来初始化数据源。可以自定义一个DynamicDataSourceConfig类，并在其中使用@Bean注解来配置数据源。在该类中可以通过读取配置文件的方式来获取数据源信息，并将其初始化为对应的数据源。 4. 配置mybatis：在application.yml或application.properties文件中配置mybatis的相关信息，如mapper的扫描路径等。 通过以上步骤，就可以实现springboot的多数据源整合。当然，以上只是一个基本的思路，具体实现还需要根据项目的实际需求进行调整和扩展。引用<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [SpringBoot实现多数据源的两种方式](https://blog.csdn.net/m0_67401761/article/details/126114612)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [SpringBoot整合多数据源的两种方式](https://blog.csdn.net/hongs468/article/details/128469985)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值