Spring Boot 多数据源配置

已于 2024-08-22 11:17:50 修改
阅读量139 收藏 4
点赞数 2
文章标签： spring boot java 数据库
于 2024-08-22 11:13:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dream_snow2012/article/details/141422966
版权

1. 项目结构

src
├── main
│   ├── java
│   │   └── org
│   │       └── songtang
│   │           └── springbootdynamic
│   │               ├── config
│   │               ├── controller
│   │               ├── entity
│   │               ├── mapper
│   │               │   ├── master
│   │               │   └── slave
│   │               └── service
│   └── resources
│       └── mapper
│           ├── master
│           └── slave
└── test

pom配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.2</version>
        <relativePath/>
    </parent>

    <groupId>org.songtang</groupId>
    <artifactId>springboot-dynamic</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <java.version>17</java.version>
        <mysql.version>8.4.0</mysql.version>
        <mybatisplus.version>3.5.7</mybatisplus.version>
    </properties>

    <dependencies>
        <!-- SpringBoot相关 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--mybatisplus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
            <version>${mybatisplus.version}</version>
        </dependency>
        <!--mysql 数据库相关-->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.34</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
            </resource>
        </resources>
    </build>

</project>

2. 数据源配置类 (DataSourceConfig)

此类用于配置多个数据源，并将其分别标记为 Primary 和 Secondary，以便在需要时进行区分。

package org.songtang.springbootdynamic.config;

import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import org.apache.ibatis.session.SqlSessionFactory;
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.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {

    @Primary
    @Bean(name = "mainDateSource")
    @ConfigurationProperties(prefix = "spring.datasource.main")
    public DataSource mainDateSource(){
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "targetDateSource")
    @ConfigurationProperties(prefix = "spring.datasource.target")
    public DataSource targetDateSource(){
        return DataSourceBuilder.create().build();
    }

    @Primary
    @Bean(name = "mainSessionFactory")
    public SqlSessionFactory mainSessionFactory(@Qualifier("mainDateSource")DataSource dataSource) throws Exception{
        MybatisSqlSessionFactoryBean mybatisSqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
        mybatisSqlSessionFactoryBean.setDataSource(dataSource);
        mybatisSqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/master/*.xml"));
        return mybatisSqlSessionFactoryBean.getObject();
    }

    @Bean(name = "targetSessionFactory")
    public SqlSessionFactory SessionFactory(@Qualifier("targetDateSource")DataSource dataSource) throws Exception{
        MybatisSqlSessionFactoryBean sqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/slave/*.xml"));
        return sqlSessionFactoryBean.getObject();
    }

    @Bean(name = "mainTransactionManager")
    public DataSourceTransactionManager mainTransactionManager(@Qualifier("mainDateSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "targetTransactionManager")
    public DataSourceTransactionManager targetTransactionManager(@Qualifier("targetDateSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

3. 数据源映射配置类

MasterMapperConfig 和 SlaveMapperConfig 分别配置主数据源和从数据源的 Mapper。

主数据源配置 (MasterMapperConfig)

package org.songtang.springbootdynamic.config;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan(basePackages = "org.songtang.springbootdynamic.mapper.master", sqlSessionFactoryRef = "mainSessionFactory")
public class MasterMapperConfig {
}

从数据源配置 (SlaveMapperConfig)

package org.songtang.springbootdynamic.config;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan(basePackages = "org.songtang.springbootdynamic.mapper.slave", sqlSessionFactoryRef = "targetSessionFactory")
public class SlaveMapperConfig {
}

4. 实体类 (Member)

Member 实体类用于表示数据库中的成员数据，并与 master 和 slave 两个数据源交互。

package org.songtang.springbootdynamic.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@TableName("member")
@Data
public class Member extends BaseEntity{
    private String name;
    private String phone;
    private Double amount;
}

5. Mapper 接口

Mapper 接口用于定义与数据库交互的方法。

主数据源 Mapper (MasterMapper)

package org.songtang.springbootdynamic.mapper.master;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.songtang.springbootdynamic.entity.Member;

@Mapper
public interface MasterMapper extends BaseMapper<Member> {
    // 主数据源相关操作
}

从数据源 Mapper (SlaveMapper)

package org.songtang.springbootdynamic.mapper.slave;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.songtang.springbootdynamic.entity.Member;

@Mapper
public interface SlaveMapper extends BaseMapper<Member> {
    // 从数据源相关操作
}

6. 控制器 (Controller)

控制器类用于定义对外暴露的 API 接口，用于操作不同数据源的数据。

package org.songtang.springbootdynamic.controller;

import org.songtang.springbootdynamic.entity.Member;
import org.songtang.springbootdynamic.service.YourService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api")
public class MultiDataSourceController {

    @Autowired
    private YourService yourService;

    // 使用主数据源插入数据
    @PostMapping("/master")
    public void addMasterEntity(@RequestBody Member masterEntity) {
        yourService.addMaster(masterEntity);
    }

    // 使用从数据源插入数据
    @PostMapping("/slave")
    public void addSlaveEntity(@RequestBody Member slaveEntity) {
        yourService.addSlave(slaveEntity);
    }
}

7. 使用示例

在项目中，可以通过调用控制器的 API 来测试不同数据源的功能：

  • 插入主数据源的数据: 通过 /api/master 接口插入数据
  • 插入从数据源的数据: 通过 /api/slave 接口插入数据

8. application.yml 配置 

application.yml 文件中需要配置主数据源和从数据源的连接信息：

spring:
  datasource:
    main:
      url: jdbc:mysql://localhost:3306/masterdb
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
    target:
      url: jdbc:mysql://localhost:3306/slavedb
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver

总结

通过以上配置，您可以在 Spring Boot 项目中成功实现多数据源的管理，分离不同的数据库操作。这样可以轻松处理不同数据源之间的事务以及数据交互，确保应用的高效性和可扩展性。

清晨细雨~
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot入门(20)：使用Mybatis-plus实现Spring Boot多数据源配置，轻松实现数据库读写分离！
**My Coding Family**
08-22 1万+
如何实现多数据源的配置及项目使用，此文教会你，超级简单，开箱即用。
spring boot多数据源配置
08-14
首先，我们需要在`pom.xml`或`build.gradle`文件中添加相应的Spring Boot数据源依赖，例如MySQL和Oracle： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-jpa <groupId>...
Spring Boot多数据源配置详解及报错问题解决
qq_57794788的博客
02-20 7050
SpringBoot多数据源配置流程及报错解决
Spring Boot配置多数据源的四种方式
qq_45515182的博客
08-14 3万+
在日常的项目中我们的开发都是采用单数据库的模式，但是在高并发的时代，单数据库已经无法承载大数据量的访问，所以就需要使用多个数据库进行对数据的读写分离。
Spring Boot整合Mybatis配置多数据源
qq_37759895的博客
01-22 3952
工作中难免需要做几个工具方便自己偷懒，加上之前的挡板，数据源肯定没法单一配置，所以需要多数据源配置。这里介绍两种配置：动态数据源和固定数据源模式。这两种我在目前的工作的工具开发中都有用到。
Spring Boot多数据源配置并通过注解实现动态切换数据源
huangjhai的博客
07-31 5923
Spring Boot提供了AbstractRoutingDataSource 根据用户定义的规则选择使用的数据源，这样我们可以在每次数据库操作前设置使用的数据源，实现可动态路由的数据源，从而实现读写分离的功能。
Spring Boot整合MyBatis配置多数据源
null
03-03 2161
多数据源即动态数据源，随着项目开发逐渐扩大，单个数据源、单一数据源已经无法满足需求项目的支撑需求。或是单一数据库无法承载大数据量的访问，需使用多个数据库进行数据的读写分离；或是某些特殊业务需求，需操作不同的数据库。在文章中，展示了Spring Boot整合MyBatis连接数据库的方法，基于此，Spring Boot 整合MyBatis 配置多数据源。
Spring Boot 配置多数据源
Practitioner
11-30 1614
注：本示例基于 JdbcTemplate，如果使用 JPA，Hiberante 或者 Mybatis 等，方法类似。脚本和数据源配置好以后，接下来要准备两个数据源的配置类信息，以任意一个数据源的配置类信息为例（另外一个同理）首先，配置两个数据源，这里我们基于 H2 配置了两个简单数据源，由于 H2 是内存数据库，无需手动新建。参数定义了该数据源是主数据源，也就是说，调用数据源的时候，如果没有指定名称默认就是用这个数据源。完成上述配置后，在启动类中注入这两个数据源对应的。取的是 foo 数据源的信息。
SpringBoot多数据源配置
热门推荐
上善若泪
03-27 3万+
文章目录1 SpringBoot分库配置1.1 准备数据1.2 springboot+mybatis使用分包方式整合1.2.1 pom.xml1.2.2 application.yml 配置文件1.2.3 连接数据源配置文件1.2.3.1 连接源配置一1.2.3.2 连接源配置二1.2.4 项目结构1.3 springboot+druid+mybatisplus使用注解整合1.3.1 pom.xml1.3.2 application.yml 配置文件1.3.3 使用@DS区分数据源1.4 读写分离库1.4.
Spring Boot 多数据源配置（mysql和sqlServer）
Zarathusa的博客
08-30 1893
Spring Boot 多数据源配置（mysql和sqlServer） 1. pom添加依赖 <!-- mysql --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <sc...
Spring Boot多数据源配置
03-27
Spring Boot作为Java领域的一款微服务框架，提供了强大的数据源配置能力，使得开发者能够轻松处理多数据源的问题。本篇文章将详细介绍如何在Spring Boot中进行多数据源配置，以及与Mybatis框架的集成，包括Mybatis的...
Spring boot配置多数据源代码实例
08-18
Spring Boot 配置多数据源代码实例详解 Spring Boot 框架在实际应用中经常需要连接多个数据源，以满足不同的业务需求。配置多数据源可以使得应用程序更加灵活和可靠。本文详细介绍了 Spring Boot 配置多数据源代码...
Spring Boot+Jpa多数据源配置Demo（支持不同数据库）
04-11
总结来说，Spring Boot + JPA 的多数据源配置需要对Spring的配置机制有深入理解，包括自动配置、bean的创建、数据源的切换等。同时，合理组织实体类和数据库访问层，确保代码的可维护性和扩展性。这个名为`...
Spring boot 连接多数据源过程详解
08-25
使用 Spring Boot 连接多数据源需要配置多个数据源，手动初始化数据源，使用事务管理机制，配置 mapper_scan，并实现数据源切换。通过这些步骤，我们可以轻松地连接多个数据源，并实现数据源的切换和事务管理。
Spring Boot 中动态数据源配置与使用详解
最新发布
weixin_44976692的博客
08-22 1171
通过动态数据源配置，Spring Boot 应用可以轻松应对多数据源的复杂需求。无论是业务隔离、读写分离，还是数据库迁移，动态数据源都能够提供灵活且高效的解决方案。在实际应用中，合理规划和使用多数据源，可以显著提升系统的可扩展性和可靠性。在实现过程中，需要特别注意事务管理和异常处理，以确保数据的一致性和完整性。通过本文的介绍，相信你已经掌握了在 Spring Boot 中配置和使用动态数据源的基本方法。在实际项目中，可以根据业务需求，进一步优化和扩展动态数据源的使用。希望本文能对你有所帮助。
深入理解Spring Boot日志框架与配置
fudaihb的博客
08-17 1185
Spring Boot 是一个简化了基于Spring框架的应用程序开发的框架。日志记录是任何应用程序中不可或缺的一部分，它不仅可以帮助开发者调试和排查问题，还可以在生产环境中监控应用程序的运行状态。Spring Boot 提供了丰富的日志框架支持和简化的配置方式，让开发者能够轻松地集成和使用日志功能。 本文将深入介绍Spring Boot中日志框架的使用和配置，包括常用的日志框架、日志配置文件的格式、如何进行日志级别的调整、如何将日志输出到不同的目标（如控制台、文件、数据库等），以及一些常见的日志管理工具
Spring Boot密码加密
m0_70066267的博客
08-22 447
Spring Boot密码加密是一个涉及多个步骤的过程，包括引入加密依赖、配置加密工具、生成加密密钥和加密密码、配置解密以及在配置文件中使用加密后的密码等。通过遵循这些步骤，你可以有效地保护Spring Boot应用程序中的敏感信息，提高应用程序的安全性。同时，也需要注意安全存储加密密钥、定期更换加密密钥、备份加密信息以及测试加密解密功能等安全措施。
(转)怎么下载spring boot
cleble的专栏
08-19 345
https://blog.51cto.com/u_16213321/7735255
spring boot 多数据源配置
06-28
### 回答1： Spring Boot 多数据源配置可以通过以下步骤实现： 1. 在 application.properties 或 application.yml 文件中配置多个数据源的连接信息，例如： ``` spring.datasource.primary.url=jdbc:mysql://localhost:3306/db1 spring.datasource.primary.username=root spring.datasource.primary.password=123456 spring.datasource.secondary.url=jdbc:mysql://localhost:3306/db2 spring.datasource.secondary.username=root spring.datasource.secondary.password=123456 ``` 2. 创建多个数据源的配置类，分别注入不同的数据源连接信息，例如： ``` @Configuration public class PrimaryDataSourceConfig { @Bean(name = "primaryDataSource") @Primary @ConfigurationProperties(prefix = "spring.datasource.primary") public DataSource primaryDataSource() { return DataSourceBuilder.create().build(); } } @Configuration public class SecondaryDataSourceConfig { @Bean(name = "secondaryDataSource") @ConfigurationProperties(prefix = "spring.datasource.secondary") public DataSource secondaryDataSource() { return DataSourceBuilder.create().build(); } } ``` 3. 在需要使用的地方注入对应的数据源，例如： ``` @Service public class UserService { @Autowired @Qualifier("primaryDataSource") private DataSource primaryDataSource; @Autowired @Qualifier("secondaryDataSource") private DataSource secondaryDataSource; // ... } ``` 通过以上步骤，就可以实现 Spring Boot 多数据源配置。 ### 回答2： Spring Boot是一个快速开发框架，其简便的配置方法吸引了越来越多的开发人员。在开发应用过程中，经常需要配置多个数据源以进行不同类型的数据操作。本文将介绍如何在Spring Boot中实现多数据源配置。 1. 添加依赖项 在pom.xml中添加以下依赖项： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <dependency> <groupId>com.zaxxer</groupId> <artifactId>HikariCP</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> ``` 2. 创建数据源配置类 我们可以通过编写一个配置类来声明不同的数据源。Spring Boot已经提供了DataSourceBuilder类来帮助我们创建数据源，它支持多种数据源类型，比如HikariCP，Tomcat JDBC等。以下是一个简单的数据源配置类的示例： ``` @Configuration public class DataSourceConfig { @Bean(name = "dataSource1") @ConfigurationProperties("spring.datasource.dataSource1") public DataSource dataSource1() { return DataSourceBuilder.create().type(HikariDataSource.class).build(); } @Bean(name = "dataSource2") @ConfigurationProperties("spring.datasource.dataSource2") public DataSource dataSource2() { return DataSourceBuilder.create().type(HikariDataSource.class).build(); } } ``` 请注意，我们通过使用@ConfigurationProperties注解将属性文件中的相关配置与Bean进行了绑定。 3. 配置JPA 如果您需要使用JPA来访问数据库，您需要在您的配置文件中配置JPA属性： ``` spring.jpa.show-sql=true spring.jpa.hibernate.ddl-auto=update spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect ``` 4. 配置事务管理器 由于我们将使用多个数据源，因此需要一个事务管理器来控制跨多个数据源的事务。我们可以使用Spring Boot的PlatformTransactionManager来实现这一点。以下是一个简单的事务管理器配置： ``` @Configuration @EnableTransactionManagement public class TransactionConfig { @Autowired @Qualifier("dataSource1") private DataSource dataSource1; @Autowired @Qualifier("dataSource2") private DataSource dataSource2; @Bean(name = "transactionManager1") public PlatformTransactionManager transactionManager1() { JpaTransactionManager transactionManager = new JpaTransactionManager(); transactionManager.setEntityManagerFactory(entityManagerFactory1().getObject()); transactionManager.setDataSource(dataSource1); return transactionManager; } @Bean(name = "transactionManager2") public PlatformTransactionManager transactionManager2() { JpaTransactionManager transactionManager = new JpaTransactionManager(); transactionManager.setEntityManagerFactory(entityManagerFactory2().getObject()); transactionManager.setDataSource(dataSource2); return transactionManager; } @Bean(name = "entityManagerFactory1") public LocalContainerEntityManagerFactoryBean entityManagerFactory1() { LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean(); em.setDataSource(dataSource1); em.setPackagesToScan("com.example.entity1"); em.setPersistenceUnitName("dataSource1"); HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter(); em.setJpaVendorAdapter(vendorAdapter); HashMap<String, Object> properties = new HashMap<>(); properties.put("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect"); properties.put("hibernate.show_sql", true); em.setJpaPropertyMap(properties); return em; } @Bean(name = "entityManagerFactory2") public LocalContainerEntityManagerFactoryBean entityManagerFactory2() { LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean(); em.setDataSource(dataSource2); em.setPackagesToScan("com.example.entity2"); em.setPersistenceUnitName("dataSource2"); HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter(); em.setJpaVendorAdapter(vendorAdapter); HashMap<String, Object> properties = new HashMap<>(); properties.put("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect"); properties.put("hibernate.show_sql", true); em.setJpaPropertyMap(properties); return em; } } ``` 请注意，我们在此处使用了两个JpaTransactionManager Bean和两个LocalContainerEntityManagerFactoryBean Bean。我们使用@Qualifier注解明确表示了我们是使用哪个数据源配置的事务管理器或者实体管理器工厂Bean。 5. 配置数据库操作模板 最后一步是创建数据库操作模板，它可以使我们在实现数据库访问时更容易。同样，我们需要声明两个不同的模板，每个模板都使用不同的数据源： ``` @Configuration public class JdbcTemplateConfig { @Autowired @Qualifier("dataSource1") private DataSource dataSource1; @Autowired @Qualifier("dataSource2") private DataSource dataSource2; @Bean(name = "jdbcTemplate1") public JdbcTemplate jdbcTemplate1() { return new JdbcTemplate(dataSource1); } @Bean(name = "jdbcTemplate2") public JdbcTemplate jdbcTemplate2() { return new JdbcTemplate(dataSource2); } } ``` 到这里，我们已经完成了Spring Boot的多数据源配置。我们可以使用这些数据源来访问不同的数据库，并使用声明的模板来执行数据库操作。这种方法可以更好地控制事务和并发，并提高应用的可伸缩性。 ### 回答3： 在实际开发中，我们常常需要使用多个数据源来实现数据的存储和读取。而Spring Boot框架提供了很方便的方式来配置多数据源。 Spring Boot支持使用两种方式来配置多数据源：使用Spring Boot自带的多数据源配置和手动配置多数据源。 使用Spring Boot自带的多数据源配置 Spring Boot已经为我们提供了一种默认的多数据源配置方式，我们只需要在application.properties或application.yml中指定多个数据源的配置信息即可。 以application.properties文件中配置MySQL和Oracle数据库为例： ``` spring.datasource.url=jdbc:mysql://localhost:3306/test1 spring.datasource.username=root spring.datasource.password=123456 spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.datasource.secondary.url=jdbc:oracle:thin:@localhost:1521:orcl spring.datasource.secondary.username=system spring.datasource.secondary.password=123456 spring.datasource.secondary.driver-class-name=oracle.jdbc.driver.OracleDriver ``` 在该示例中，我们定义了两个数据源：一个为MySQL，一个为Oracle。每个数据源有自己的配置信息，如url、username、password以及驱动等，这里省略了其他的配置项。 使用时我们只需要在代码中使用@Qualifier注解指定使用的数据源即可。 手动配置多数据源 如果我们需要更精细的控制多个数据源，我们可以手动配置多数据源。具体实现过程如下： 1.定义多个数据源配置信息类 我们可以创建多个数据源配置信息类，分别对应不同的数据源。每个类中包括了该数据源的一些配置信息，例如url、用户名、密码等。 示例代码： ``` @Configuration @MapperScan(basePackages = "com.example.demo.mapper.mysql", sqlSessionTemplateRef = "test1SqlSessionTemplate") public class Test1DataSourceConfig { @Bean(name = "test1DataSource") @ConfigurationProperties(prefix = "spring.datasource.test1") public DataSource test1DataSource() { return DataSourceBuilder.create().build(); } @Bean(name = "test1SqlSessionFactory") public SqlSessionFactory test1SqlSessionFactory(@Qualifier("test1DataSource") DataSource dataSource) throws Exception { SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dataSource); return bean.getObject(); } @Bean(name = "test1TransactionManager") public DataSourceTransactionManager test1TransactionManager(@Qualifier("test1DataSource") DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } @Bean(name = "test1SqlSessionTemplate") public SqlSessionTemplate test1SqlSessionTemplate(@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception { return new SqlSessionTemplate(sqlSessionFactory); } } ``` 示例代码中，我们使用@Configuration注解声明该类为配置类。同时我们使用@MapperScan注解声明了该数据源对应的Mapper类路径以及使用的SqlSessionTemplate，其中test1对应了我们之前定义的一个数据源。 在该类中，我们分别定义了该数据源对应的DataSource、SqlSessionFactory、DataSourceTransactionManager和SqlSessionTemplate。 2.配置多数据源 在上一步中，我们分别定义了多个数据源，下一步是将它们集成到一起。 Spring Boot提供了一个DynamicDataSource类，可以动态的创建数据源和切换数据源。我们可以在其中定义应用中所使用的所有数据源信息。 示例代码： ``` @Configuration public class DataSourceConfig { @Bean @ConfigurationProperties(prefix = "spring.datasource.master") public DataSource masterDataSource() { return DataSourceBuilder.create().build(); } @Bean @ConfigurationProperties(prefix = "spring.datasource.slave") public DataSource slaveDataSource() { return DataSourceBuilder.create().build(); } @Primary @Bean(name = "dynamicDataSource") public DataSource dynamicDataSource(@Qualifier("masterDataSource") DataSource masterDataSource, @Qualifier("slaveDataSource") DataSource slaveDataSource) { Map<Object, Object> targetDataSources = new HashMap<>(); targetDataSources.put(DatabaseType.MASTER, masterDataSource); targetDataSources.put(DatabaseType.SLAVE, slaveDataSource); MyRoutingDataSource dataSource = new MyRoutingDataSource(); dataSource.setDefaultTargetDataSource(masterDataSource); dataSource.setTargetDataSources(targetDataSources); return dataSource; } } ``` 我们在该类中分别定义了两个数据源masterDataSource和slaveDataSource，并通过注解@ConfigurationProperties(prefix="...")来指定相关的配置信息。 在dynamicDataSource方法中创建了一个MyRoutingDataSource对象，并以masterDataSource作为默认数据源。同时将所有数据源，即masterDataSource和slaveDataSource都添加到了一个HashMap中，并调用setTargetDataSources()方法设置到MyRoutingDataSource对象中。此时，我们就完成了对于多数据源的一个完整配置。 在访问数据库时，我们仍然可以像上一种方式那样，使用@Qualifier注解来指定使用哪个数据源: ``` public interface UserMapper { //使用test1数据源查询 @Select("SELECT * FROM user") @ResultType(User.class) @DataSourceType(MyContextHolder.DatabaseType.MYSQL) List<User> selectAll(); //使用test2数据源查询 @DataSourceType(MyContextHolder.DatabaseType.ORACLE) List<User> selectAll2(); } ``` 总结 Spring Boot实现多数据源的方式有两种，一种是使用Spring Boot自带的多数据源配置，另一种是手动配置多数据源。不管使用哪种方式，记得在使用时需要指定使用哪个具体的数据源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值