一文詳解SpringBoot實現(xiàn)多數(shù)據(jù)源的自動切換

更新時間：2025年10月23日 08:28:11 作者：牛肉胡辣湯

在現(xiàn)代企業(yè)級應(yīng)用中,為了提高系統(tǒng)的可維護性和擴展性,多數(shù)據(jù)源的配置和使用變得越來越常見,本文將,介紹如何在Spring Boot項目中實現(xiàn)多數(shù)據(jù)源的自動切換有需要的小伙伴可以了解下

在現(xiàn)代企業(yè)級應(yīng)用中，為了提高系統(tǒng)的可維護性和擴展性，多數(shù)據(jù)源的配置和使用變得越來越常見。特別是在處理跨數(shù)據(jù)庫操作、讀寫分離、分庫分表等場景時，動態(tài)數(shù)據(jù)源切換技術(shù)顯得尤為重要。本文將介紹如何在Spring Boot項目中實現(xiàn)多數(shù)據(jù)源的自動切換。

1. 引言

隨著業(yè)務(wù)的不斷增長，單一的數(shù)據(jù)源往往難以滿足高并發(fā)、大數(shù)據(jù)量的需求。通過引入多數(shù)據(jù)源，可以有效地解決這些問題。Spring Boot提供了靈活的配置機制，使得多數(shù)據(jù)源的管理變得更加簡便。

2. 環(huán)境準備

Java版本：1.8+

Spring Boot版本：2.3.4.RELEASE

數(shù)據(jù)庫：MySQL 5.7+

3. 添加依賴

首先，在??pom.xml??文件中添加必要的依賴：

<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring Boot JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- MySQL Connector -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!-- HikariCP 數(shù)據(jù)源 -->
    <dependency>
        <groupId>com.zaxxer</groupId>
        <artifactId>HikariCP</artifactId>
    </dependency>
</dependencies>

4. 配置多數(shù)據(jù)源

在??application.yml??中配置多個數(shù)據(jù)源：

spring:
  datasource:
    master:
      url: jdbc:mysql://localhost:3306/db_master?useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
    slave:
      url: jdbc:mysql://localhost:3306/db_slave?useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver

5. 創(chuàng)建數(shù)據(jù)源配置類

創(chuàng)建一個配置類來管理多個數(shù)據(jù)源，并將其注冊到Spring容器中：

import com.zaxxer.hikari.HikariDataSource;
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.lookup.AbstractRoutingDataSource;

@Configuration
public class DataSourceConfig {

    @Bean(name = "masterDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public HikariDataSource masterDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Bean(name = "slaveDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public HikariDataSource slaveDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Bean(name = "dynamicDataSource")
    public AbstractRoutingDataSource dynamicDataSource(@Qualifier("masterDataSource") HikariDataSource masterDataSource,
                                                      @Qualifier("slaveDataSource") HikariDataSource slaveDataSource) {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setDefaultTargetDataSource(masterDataSource);
        Map<Object, Object> dataSourceMap = new HashMap<>();
        dataSourceMap.put("master", masterDataSource);
        dataSourceMap.put("slave", slaveDataSource);
        dynamicDataSource.setTargetDataSources(dataSourceMap);
        return dynamicDataSource;
    }
}

6. 實現(xiàn)動態(tài)數(shù)據(jù)源切換

創(chuàng)建一個??DynamicDataSource??類繼承??AbstractRoutingDataSource??，并重寫??determineCurrentLookupKey??方法來決定當前使用的數(shù)據(jù)源：

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSource();
    }
}

創(chuàng)建一個??DataSourceContextHolder??類來管理數(shù)據(jù)源上下文：

public class DataSourceContextHolder {

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
    }

    public static String getDataSource() {
        return contextHolder.get();
    }

    public static void clearDataSource() {
        contextHolder.remove();
    }
}

7. 使用AOP實現(xiàn)自動切換

使用Spring AOP來實現(xiàn)數(shù)據(jù)源的自動切換：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class DataSourceAspect {

    @Pointcut("@annotation(com.example.demo.annotation.TargetDataSource)")
    public void dataSourcePointCut() {}

    @Before("dataSourcePointCut()")
    public void switchDataSource(JoinPoint point) {
        MethodSignature signature = (MethodSignature) point.getSignature();
        TargetDataSource targetDataSource = signature.getMethod().getAnnotation(TargetDataSource.class);
        if (targetDataSource != null) {
            DataSourceContextHolder.setDataSource(targetDataSource.value());
        }
    }
}

創(chuàng)建一個自定義注解??TargetDataSource??用于標記需要切換數(shù)據(jù)源的方法：

import java.lang.annotation.*;

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TargetDataSource {
    String value();
}

8. 測試

創(chuàng)建一些測試用的服務(wù)類和控制器來驗證多數(shù)據(jù)源切換是否正常工作：

import com.example.demo.annotation.TargetDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @TargetDataSource("master")
    public List<Map<String, Object>> getUserFromMaster() {
        return jdbcTemplate.queryForList("SELECT * FROM user");
    }

    @TargetDataSource("slave")
    public List<Map<String, Object>> getUserFromSlave() {
        return jdbcTemplate.queryForList("SELECT * FROM user");
    }
}

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;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/master")
    public List<Map<String, Object>> getUsersFromMaster() {
        return userService.getUserFromMaster();
    }

    @GetMapping("/slave")
    public List<Map<String, Object>> getUsersFromSlave() {
        return userService.getUserFromSlave();
    }
}

9.方法補充

在實際應(yīng)用中，特別是在大型系統(tǒng)或微服務(wù)架構(gòu)中，經(jīng)常會遇到需要操作多個數(shù)據(jù)庫的情況。Spring Boot 提供了靈活的配置和擴展機制，可以方便地實現(xiàn)多數(shù)據(jù)源的支持。下面是一個簡單的示例，展示如何在 Spring Boot 應(yīng)用中配置和使用動態(tài)數(shù)據(jù)源。

添加依賴

首先，在 ??pom.xml?? 文件中添加必要的依賴：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>com.zaxxer</groupId>
        <artifactId>HikariCP</artifactId>
    </dependency>
</dependencies>

配置多數(shù)據(jù)源

在 ??application.yml?? 中配置兩個數(shù)據(jù)源：

spring:
  datasource:
    primary:
      url: jdbc:mysql://localhost:3306/db1?useSSL=false&serverTimezone=UTC
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
    secondary:
      url: jdbc:mysql://localhost:3306/db2?useSSL=false&serverTimezone=UTC
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver

創(chuàng)建數(shù)據(jù)源配置類

創(chuàng)建一個配置類來配置多個數(shù)據(jù)源，并將它們注冊到 Spring 容器中：

import com.zaxxer.hikari.HikariDataSource;
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.lookup.AbstractRoutingDataSource;

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

@Configuration
public class DataSourceConfig {

    @Bean
    @ConfigurationProperties("spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Bean
    @Primary
    public DynamicDataSource dataSource(@Qualifier("primaryDataSource") DataSource primaryDataSource,
                                        @Qualifier("secondaryDataSource") DataSource secondaryDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("primary", primaryDataSource);
        targetDataSources.put("secondary", secondaryDataSource);
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.setDefaultTargetDataSource(primaryDataSource);
        return dynamicDataSource;
    }
}

創(chuàng)建動態(tài)數(shù)據(jù)源類

創(chuàng)建一個繼承自 ??AbstractRoutingDataSource?? 的類來實現(xiàn)數(shù)據(jù)源的動態(tài)切換：

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSource();
    }
}

創(chuàng)建數(shù)據(jù)源上下文管理類

創(chuàng)建一個工具類來管理數(shù)據(jù)源的切換：

public class DataSourceContextHolder {

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
    }

    public static String getDataSource() {
        return contextHolder.get();
    }

    public static void clearDataSource() {
        contextHolder.remove();
    }
}

使用 AOP 切換數(shù)據(jù)源

使用 AOP 來切面管理數(shù)據(jù)源的切換，例如根據(jù)方法注解來切換數(shù)據(jù)源：

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class DataSourceAspect {

    @Before("@annotation(com.example.demo.annotation.TargetDataSource)")
    public void changeDataSource(JoinPoint point) {
        MethodSignature signature = (MethodSignature) point.getSignature();
        TargetDataSource targetDataSource = signature.getMethod().getAnnotation(TargetDataSource.class);
        if (targetDataSource != null) {
            DataSourceContextHolder.setDataSource(targetDataSource.value());
        }
    }

    @After("@annotation(com.example.demo.annotation.TargetDataSource)")
    public void restoreDataSource(JoinPoint point) {
        DataSourceContextHolder.clearDataSource();
    }
}

自定義注解

創(chuàng)建一個自定義注解來標記需要切換數(shù)據(jù)源的方法：

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TargetDataSource {
    String value();
}

使用示例

在服務(wù)層中使用自定義注解來切換數(shù)據(jù)源：

import com.example.demo.annotation.TargetDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @TargetDataSource("primary")
    public void doSomethingWithPrimaryDB() {
        jdbcTemplate.execute("SELECT * FROM user");
    }

    @TargetDataSource("secondary")
    public void doSomethingWithSecondaryDB() {
        jdbcTemplate.execute("SELECT * FROM user");
    }
}

方法二：

在Spring Boot應(yīng)用中實現(xiàn)多數(shù)據(jù)源的動態(tài)切換是一個常見的需求，尤其是在需要訪問多個數(shù)據(jù)庫或不同環(huán)境下的數(shù)據(jù)庫時。下面將詳細介紹如何在Spring Boot中配置和使用動態(tài)數(shù)據(jù)源。

添加依賴

首先，確保你的??pom.xml??文件中包含必要的依賴項。通常情況下，你需要Spring Boot的Web和JPA/MyBatis等ORM框架的依賴，以及相應(yīng)的數(shù)據(jù)庫驅(qū)動依賴。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.23</version>
    </dependency>
    <!-- 其他數(shù)據(jù)庫驅(qū)動依賴 -->
</dependencies>

配置數(shù)據(jù)源

在??application.yml??或??application.properties??文件中配置多個數(shù)據(jù)源。

spring:
  datasource:
    primary:
      url: jdbc:mysql://localhost:3306/db1?useSSL=false&serverTimezone=UTC
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
    secondary:
      url: jdbc:mysql://localhost:3306/db2?useSSL=false&serverTimezone=UTC
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver

創(chuàng)建數(shù)據(jù)源配置類

創(chuàng)建一個配置類來定義和配置多個數(shù)據(jù)源。

import org.apache.commons.dbcp2.BasicDataSource;
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 org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

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

@Configuration
public class DataSourceConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
        return new BasicDataSource();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return new BasicDataSource();
    }

    @Bean
    public DataSource dynamicDataSource(@Qualifier("primaryDataSource") DataSource primaryDataSource,
                                        @Qualifier("secondaryDataSource") DataSource secondaryDataSource) {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("primary", primaryDataSource);
        targetDataSources.put("secondary", secondaryDataSource);
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.setDefaultTargetDataSource(primaryDataSource);
        return dynamicDataSource;
    }

    @Bean
    public PlatformTransactionManager transactionManager(DynamicDataSource dynamicDataSource) {
        return new DataSourceTransactionManager(dynamicDataSource);
    }
}

創(chuàng)建動態(tài)數(shù)據(jù)源類

創(chuàng)建一個自定義的??DynamicDataSource??類，用于管理多個數(shù)據(jù)源的切換。

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSource();
    }
}

創(chuàng)建數(shù)據(jù)源上下文持有類

創(chuàng)建一個線程安全的上下文持有類，用于存儲當前線程的數(shù)據(jù)源標識。

public class DataSourceContextHolder {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
    }

    public static String getDataSource() {
        return contextHolder.get();
    }

    public static void clearDataSource() {
        contextHolder.remove();
    }
}

創(chuàng)建數(shù)據(jù)源切換注解

創(chuàng)建一個注解，用于在方法或類上標記數(shù)據(jù)源切換。

import java.lang.annotation.*;

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
    String value() default "";
}

創(chuàng)建切面類

創(chuàng)建一個切面類，用于攔截帶有??@DataSource??注解的方法或類，并進行數(shù)據(jù)源切換。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class DataSourceAspect {

    @Pointcut("@annotation(com.example.demo.DataSource)")
    public void dataSourcePointCut() {}

    @Before("dataSourcePointCut() && @annotation(dataSource)")
    public void switchDataSource(DataSource dataSource) {
        DataSourceContextHolder.setDataSource(dataSource.value());
    }
}

使用示例

在Service層或Controller層使用??@DataSource??注解來切換數(shù)據(jù)源。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @DataSource("primary")
    public User getUserFromPrimary(int id) {
        return userRepository.findById(id).orElse(null);
    }

    @DataSource("secondary")
    public User getUserFromSecondary(int id) {
        return userRepository.findById(id).orElse(null);
    }
}

配置JPA或MyBatis

如果你使用的是JPA或MyBatis，需要確保它們能夠正確地使用動態(tài)數(shù)據(jù)源。對于JPA，你可能需要配置實體管理器工廠；對于MyBatis，需要配置SqlSessionFactory。

JPA配置

import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
    basePackages = "com.example.demo.repository",
    entityManagerFactoryRef = "entityManagerFactory",
    transactionManagerRef = "transactionManager"
)
public class JpaConfig {

    @Autowired
    private JpaProperties jpaProperties;

    @Autowired
    @Qualifier("dynamicDataSource")
    private DataSource dynamicDataSource;

    @Primary
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(dynamicDataSource)
                .properties(jpaProperties.getProperties())
                .packages("com.example.demo.entity")
                .persistenceUnit("default")
                .build();
    }

    @Primary
    @Bean
    public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }
}

MyBatis配置

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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = "com.example.demo.mapper", sqlSessionTemplateRef = "sqlSessionTemplate")
public class MyBatisConfig {

    @Autowired
    @Qualifier("dynamicDataSource")
    private DataSource dynamicDataSource;

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

    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

通過以上步驟，你可以在Spring Boot應(yīng)用中實現(xiàn)多數(shù)據(jù)源的動態(tài)切換。

到此這篇關(guān)于一文詳解SpringBoot實現(xiàn)多數(shù)據(jù)源的自動切換的文章就介紹到這了,更多相關(guān)SpringBoot數(shù)據(jù)源自動切換內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: