SpringBoot动态数据源

最新推荐文章于 2024-05-20 18:04:59 发布
最新推荐文章于 2024-05-20 18:04:59 发布
阅读量330 收藏 2
点赞数
分类专栏： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43130451/article/details/107202986
版权

SpringBoot动态数据源

1、原理图

1、原理图
、

2、创建枚举类

package com.yeqm.demo.sys;

/**
*@Description 存数据源key值
*@Param 
*@Return 
*@Author 骑牛小道士
*@Date 2019/5/30
*@Time 17:43
*/
public enum DataSourceKey {
    master,salve,migration
}

3、创建自定义注解类

package com.yeqm.demo.sys;

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

/**
*@Description 自定义注解
*@Param
*@Return
*@Author 骑牛小道士
*@Date 2019/5/30
*@Time 17:45
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TargetDataSource {
    String value() default "master";
}

4、切换数据源类

package com.yeqm.demo.sys;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


/**
 *@Description 根据线程动态切换数据源
 *@Param 
 *@Return 
 *@Author 骑牛小道士
 *@Date 2019/5/30
 *@Time 17:47
 */
@Configuration
public class DynamicDataSourceContextHolder {
    private static final Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);

    /**
     * 设置默认数据源
     */
    public static  String DEFAULT_DS = "master";
    /**
     *用于轮训计数
     */
    private static int counter = 0;
    /*
     * 当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，
     * 所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
     */
    private static final ThreadLocal<String> contextHolder = ThreadLocal.withInitial(() -> DataSourceKey.master.name());

    /**
     *用于在切换数据源时保证不会被其他线程修改
     */
    public static Lock lock = new ReentrantLock();

    /**
     * 设置数据源
     */
    public static void setDB(String dbType){
        log.info("切换到{" + dbType + "}数据源");
        contextHolder.set(dbType);
    }

    /**
     * 得到数据源
     *
     */
    public static String getDB(){
        return contextHolder.get();
    }

    /**
     * 使用主数据源
     */
    public static void useMasterDataSource() {
        contextHolder.set(DataSourceKey.master.name());
    }
    /**
     * 移除数据源
     */
    public static void removeDB(){
        contextHolder.remove();
    }
    /**
     * The constant slaveDataSourceKeys.
     */
    public static List<Object> slaveDataSourceKeys = new ArrayList<>();
    /**
     * 当使用只读数据源时通过轮循方式选择要使用的数据源
     */
    public static String getSlaveDB(){
        lock.lock();
        try {
            int datasourceKeyIndex = counter % slaveDataSourceKeys.size();
            counter++;
            return String.valueOf(slaveDataSourceKeys.get(datasourceKeyIndex));
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            e.printStackTrace();
            return "master";
        } finally {
            lock.unlock();
        }
    }
}

5、获取数据源类

package com.yeqm.demo.sys;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
*@Description 多数据源的选择
*@Param 
*@Return 
*@Author 骑牛小道士
*@Date 2019/5/30
*@Time 17:48
*/
public class DynamicDataSource extends AbstractRoutingDataSource {
    private static final Logger log = LoggerFactory.getLogger(DynamicDataSource.class);

    @Override
    protected Object determineCurrentLookupKey() {
        log.info("Current DataSource is " + DynamicDataSourceContextHolder.getDB());
        return DynamicDataSourceContextHolder.getDB();
    }
}

6、Aop类

package com.yeqm.demo.sys;

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.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;


/**
 *@Description 自定义注解 + AOP的方式实现数据源动态切换。
 *@Param
 *@Return
 *@Author 骑牛小道士
 *@Date 2019/5/30
 *@Time 17:50
 */
@Aspect
@Component
public class DynamicDataSourceAspect {
    private static final Logger log = LoggerFactory.getLogger(DynamicDataSourceAspect.class);

    @Before("@annotation(TargetDataSource)")
    public void beforeSwitchDB(JoinPoint joinPoint, TargetDataSource TargetDataSource){
        //获取目标类的方法
        Class<?> aClass = joinPoint.getTarget().getClass();
        //获得访问的方法名
        String methodName = joinPoint.getSignature().getName();
        //得到方法的参数类型
        Class[] parameterTypes = ((MethodSignature) joinPoint.getSignature()).getParameterTypes();
        String dataSource = DynamicDataSourceContextHolder.DEFAULT_DS;
        try {
            Method method = aClass.getMethod(methodName, parameterTypes);
            if(method.isAnnotationPresent(TargetDataSource.class)){
                TargetDataSource db = method.getAnnotation(TargetDataSource.class);
                //指定数据源
                dataSource = db.value();
            }else{
                //轮训设置数据源
                dataSource = DynamicDataSourceContextHolder.getSlaveDB();
            }
        } catch (NoSuchMethodException e) {
            log.error(e.getMessage(), e);
        }
        //设置数据源
        DynamicDataSourceContextHolder.setDB(dataSource);
    }

    @After("@annotation(TargetDataSource)")
    public void afterSwitchDB(TargetDataSource TargetDataSource){
        DynamicDataSourceContextHolder.removeDB();
    }
}

7、application.yml文件

spring:
  datasource:
    druid:
      # 数据库访问配置, 使用druid数据源 1
      master:
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://62.234.72.109:3306/test11
        username: root
        password: ******
        initial-size: 1
        min-idle: 1
        max-active: 20
        test-on-borrow: true
        # MySQL 8.x: com.mysql.cj.jdbc.Driver


      # 数据库访问配置, 使用druid数据源 1
      salve:
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://62.234.72.109:3306/test12
        username: root
        password: ******
        initial-size: 1
        min-idle: 1
        max-active: 20
        test-on-borrow: true
        # MySQL 8.x: com.mysql.cj.jdbc.Driver

      # 数据库访问配置, 使用druid数据源 1
      migration:
        # MySQL 8.x: com.mysql.cj.jdbc.Driver
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://62.234.72.109:3306/test13
        username: root
        password: ******
        initial-size: 1
        min-idle: 1
        max-active: 20
        test-on-borrow: true

9、数据源配置类

package com.yeqm.demo.config;

import com.yeqm.demo.sys.DataSourceKey;
import com.yeqm.demo.sys.DynamicDataSource;
import com.yeqm.demo.sys.DynamicDataSourceContextHolder;
import org.mybatis.spring.SqlSessionFactoryBean;
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;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
*@Description 数据源配置类
*@Param 
*@Return 
*@Author 骑牛小道士
*@Date 2019/5/30
*@Time 17:57
*/
@Configuration
public class DataSourceConfig {


	/**
	 * 主数据
	 *
	 * @return data source
	 */
	@Bean("master")
	@Primary
	@ConfigurationProperties(prefix = "spring.datasource.druid.master")
	public DataSource master() {
		return DataSourceBuilder.create().build();
	}

	/**
	 * 从数据库
	 *
	 * @return data source
	 */
	@Bean("salve")
	@ConfigurationProperties(prefix ="spring.datasource.druid.salve")
	public DataSource slave() {
		return DataSourceBuilder.create().build();
	}
	/**
	 * 从数据库
	 *
	 * @return data source
	 */
	@Bean("migration")
	@ConfigurationProperties(prefix ="spring.datasource.druid.migration")
	public DataSource migration() {
		return DataSourceBuilder.create().build();
	}


	/**
	 * 配置动态数据源
	 *
	 * @return
	 */
	@Bean("dynamicDataSource")
	public DataSource dynamicDataSource() {
		DynamicDataSource dynamicRoutingDataSource = new DynamicDataSource();
		Map<Object, Object> dataSourceMap = new HashMap<>(4);
		dataSourceMap.put(DataSourceKey.master.name(), master());
		dataSourceMap.put(DataSourceKey.salve.name(), slave());
		dataSourceMap.put(DataSourceKey.migration.name(), migration());


		//设置默认的数据源
		dynamicRoutingDataSource.setDefaultTargetDataSource(master());
		// 多个slave数据源在此添加，自定义key，用于轮询
		dataSourceMap.put(DataSourceKey.salve.name() + "1", slave());
		//设置目标数据源
		dynamicRoutingDataSource.setTargetDataSources(dataSourceMap);
		//将数据源的key放在集合中判断是否正常
		DynamicDataSourceContextHolder.slaveDataSourceKeys.addAll(dataSourceMap.keySet());

		//实现负载均衡算法   将 Slave 数据源的 key 放在集合中，用于轮循
		DynamicDataSourceContextHolder.slaveDataSourceKeys.addAll(dataSourceMap.keySet());
		DynamicDataSourceContextHolder.slaveDataSourceKeys.remove(DataSourceKey.migration.name());
		return dynamicRoutingDataSource;
	}

	/**
	 * 设置工厂类
	 */
	@Bean
	public SqlSessionFactoryBean sqlSessionFactoryBean() {
		SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
		sqlSessionFactoryBean.setDataSource(dynamicDataSource());

		//此处设置为了解决找不到mapper文件的问题
		try {
			sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/*Mapper.xml"));
		} catch (IOException e) {
			e.printStackTrace();
		}
		return sqlSessionFactoryBean;
	}

	/**
	 * 事物管理器
	 */
	@Bean("transactionManager")
	public DataSourceTransactionManager transactionManager() {
		return new DataSourceTransactionManager(dynamicDataSource());
	}
}

10、启动类

package com.yeqm.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
 *@Description springboot入口类,此类需要在所有用到的package上层 exclude ={DataSourceAutoConfiguration.class}
 *@Param  禁用springboot默认加载的application.properties单数据源配置
 *@Return 
 *@Author 骑牛小道士
 *@Date 2019/5/30
 *@Time 17:57
*/
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

11、测试

controller类

package com.yeqm.demo.controller;

import com.yeqm.demo.biz.TBdUserBiz;
import com.yeqm.demo.entity.TBdUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.List;

/**
 * @description:
 * @author: 骑牛小道士
 * @date: 2019-05-30 11:48
 */
@Controller
public class TBdUserController {

    @Autowired
    private TBdUserBiz tBdUserBiz;

    @RequestMapping("/999")
    public List<TBdUser> selectList1 (TBdUser param){
        List<TBdUser> list1 =tBdUserBiz.selectList1(param);
        List<TBdUser> list2 =tBdUserBiz.selectList2(param);
        List<TBdUser> list3 =tBdUserBiz.selectList3(param);
        return list1;
    }
}

biz 类

package com.yeqm.demo.biz;

import com.yeqm.demo.entity.TBdUser;
import com.yeqm.demo.mapper.TBdUserMapper;
import com.yeqm.demo.sys.TargetDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

/**
 * @description:
 * @author: 骑牛小道士
 * @date: 2019-05-30 11:49
 */

@Service
public class TBdUserBiz {

    @Autowired
    private TBdUserMapper tBdUserMapper;

    @TargetDataSource("migration")
    public List<TBdUser> selectList3(TBdUser param) {
        List<TBdUser> list= tBdUserMapper.selectList(param);
        System.out.println("migration");
        System.out.println(list.get(0).getUserCode());
        return list;
    }

    @TargetDataSource("salve")
    public List<TBdUser> selectList2(TBdUser param) {
        List<TBdUser> list= tBdUserMapper.selectList(param);
        System.out.println("salve");
        System.out.println(list.get(0).getUserCode());
        return list;
    }

    @TargetDataSource("master")
    public List<TBdUser> selectList1(TBdUser param) {
        List<TBdUser> list= tBdUserMapper.selectList(param);
        System.out.println("master");
        System.out.println(list.get(0).getUserCode());
        return list;
    }
}

mapper 类

package com.yeqm.demo.mapper;

import com.yeqm.demo.entity.TBdUser;
import com.yeqm.utils.MyMapper;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;

/**
*@Description 
*@Param 
*@Return 
*@Author 骑牛小道士
*@Date 2019/5/30
*@Time 18:04
*/
@Mapper
public interface TBdUserMapper extends MyMapper<TBdUser> {
    List<TBdUser> selectList(TBdUser param);
}

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="com.yeqm.demo.mapper.TBdUserMapper">
  <resultMap id="BaseResultMap" type="com.yeqm.demo.entity.TBdUser">
    <!--
      WARNING - @mbg.generated
    -->
    <id column="row_id" jdbcType="INTEGER" property="rowId" />
    <result column="user_code" jdbcType="VARCHAR" property="userCode" />
    <result column="user_name" jdbcType="VARCHAR" property="userName" />
    <result column="pass_word" jdbcType="VARCHAR" property="passWord" />
    <result column="created_by" jdbcType="VARCHAR" property="createdBy" />
    <result column="creation_date" jdbcType="TIMESTAMP" property="creationDate" />
    <result column="last_updated_by" jdbcType="VARCHAR" property="lastUpdatedBy" />
    <result column="last_update_date" jdbcType="TIMESTAMP" property="lastUpdateDate" />
  </resultMap>


  <select id="selectList" resultMap="BaseResultMap"
          parameterType="com.yeqm.demo.entity.TBdUser">
        select t.* from t_bd_user t
  </select>
</mapper>
效果
2019-05-30 14:25:39.788  INFO 12228 --- [nio-9990-exec-1] c.y.d.s.DynamicDataSourceContextHolder   : 切换到{master}数据源
2019-05-30 14:25:39.915  INFO 12228 --- [nio-9990-exec-1] com.yeqm.demo.sys.DynamicDataSource      : Current DataSource is master
2019-05-30 14:25:39.917  INFO 12228 --- [nio-9990-exec-1] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
2019-05-30 14:25:42.189  INFO 12228 --- [nio-9990-exec-1] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
master
zs
2019-05-30 14:25:43.361  INFO 12228 --- [nio-9990-exec-1] c.y.d.s.DynamicDataSourceContextHolder   : 切换到{salve}数据源
2019-05-30 14:25:43.362  INFO 12228 --- [nio-9990-exec-1] com.yeqm.demo.sys.DynamicDataSource      : Current DataSource is salve
2019-05-30 14:25:43.363  INFO 12228 --- [nio-9990-exec-1] com.zaxxer.hikari.HikariDataSource       : HikariPool-2 - Starting...
2019-05-30 14:25:44.011  INFO 12228 --- [nio-9990-exec-1] com.zaxxer.hikari.HikariDataSource       : HikariPool-2 - Start completed.
salve
we
2019-05-30 14:25:48.393  INFO 12228 --- [nio-9990-exec-1] c.y.d.s.DynamicDataSourceContextHolder   : 切换到{migration}数据源
2019-05-30 14:25:48.394  INFO 12228 --- [nio-9990-exec-1] com.yeqm.demo.sys.DynamicDataSource      : Current DataSource is migration
2019-05-30 14:25:48.394  INFO 12228 --- [nio-9990-exec-1] com.zaxxer.hikari.HikariDataSource       : HikariPool-3 - Starting...
2019-05-30 14:25:49.040  INFO 12228 --- [nio-9990-exec-1] com.zaxxer.hikari.HikariDataSource       : HikariPool-3 - Start completed.
migration
sd
星辰 Stars
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot 动态数据源
Vincent Vic
06-21 3146
动态数据源流程说明 Spring Boot 的动态数据源，本质上是把多个数据源存储在一个 Map 中，当需要使用某个数据源时，从 Map 中获取此数据源进行处理。 而在 Spring 中，已提供了抽象类 AbstractRoutingDataSource 来实现此功能。......
springboot 动态数据源的实现方法(Mybatis+Druid)
08-26
在Spring Boot应用中，动态数据源的实现是一个重要的特性，它允许程序在运行时根据不同的业务需求切换数据源。在本例中，我们将探讨如何利用Mybatis和Druid实现Spring Boot的动态数据源。 首先，Spring Boot动态...
Spring Boot 动态数据源（多数据源自动切换）
热门推荐
小单的博客专栏
01-24 12万+
本文实现案例场景： 某系统除了需要从自己的主要数据库上读取和管理数据外，还有一部分业务涉及到其他多个数据库，要求可以在任何方法上可以灵活指定具体要操作的数据库。为了在开发中以最简单的方法使用，本文基于注解和AOP的方法实现，在spring boot框架的项目中，添加本文实现的代码类后，只需要配置好数据源就可以直接通过注解使用，简单方便。一配置二使用 1. 配置文件中配置多个数据源 2. 在需要
SpringBoot中动态数据源的实现与探究
最新发布
Belove1ong的博客
05-20 1352
数据库环境中demo1库中有A表，demo2库中有B表，demo3库中有C表，默认的数据源是Demo1，这里切换到demo3数据源并查询对应的C表数据。首先，什么是动态数据源，网上其实已经有很多回答了。本文将会利用Druid数据源实现动态的数据源，并且使用注解实现。作用：管理线程的数据源，可以进行数据源的切换。中配置的默认的数据源，这是为什么呢？
Spring Boot 动态数据源（Spring 注解数据源）
weixin_34216196的博客
03-17 410
本文实现案例场景：某系统除了需要从自己的主要数据库上读取和管理数据外，还有一部分业务涉及到其他多个数据库，要求可以在任何方法上可以灵活指定具体要操作的数据库。 为了在开发中以最简单的方法使用，本文基于注解和AOP的方法实现，在spring boot框架的项目中，添加本文实现的代码类后，只需要配置好数据源就可以直接通过注解使用，简单方便。 一配置二使用1....
SpringBoot 动态数据源
默存
03-11 1217
SpringBoot 实现动态数据源切换 Spring Boot + Mybatis Plus + Druid + MySQL 实现动态数据源切换及动态 SQL 语句执行。 项目默认加载 application.yml 中配置的数据源，只有在调用数据源切换时创建数据连接。 Druid 实现动态数据源切换 相关依赖 <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector
基于 SpringBoot 多数据源 动态数据源 主从分离 快速启动器 支持分布式事务
01-05
基于 SpringBoot 多数据源 动态数据源 主从分离 快速启动器 支持分布式事务。一个基于springboot的快速集成多数据源的启动器。支持 数据源分组 ，适用于多种场景 纯粹多库 读写分离 一主多从 混合模式。支持数据库...
基于springboot整理的分布式事务及动态数据源切换
04-17
整理的分布式事务 及动态数据源切换 基于数据库XA协议 maven 包可直接使用 maven 引入路径: <groupId>com.maple</groupId> <artifactId>DCSDataSourcesServer <version>0.0.1-SNAPSHOT 事务及数据源标签...
SpringBoot配置多数据源实现动态切换数据源
06-29
本文将深入探讨如何在SpringBoot项目中配置多数据源，并实现数据源的动态切换，帮助你理解和掌握这一核心技能。 首先，我们理解"多数据源"的概念。在SpringBoot应用中，多数据源意味着系统能够连接并操作多个不同的...
springboot动态数据源代码实现，动态数据源代码，租户系统动态数据源代码
07-17
项目实现了使用SpringBoot实现动态数据源，实现步骤： 1.租户通过域名访问接口，用filter获取租户独立标识，比如 zhangsan.localhost.com 、lisi.localhost.com 2.实现AbstractRoutingDataSource类来跟进当前访问的...
SpringBoot+Mybatis实现数据源动态切换
12-27
springboot实现数据源动态切换 注意事项： 1. 该demo采用yml配置数据库信息，注意url标签为jdbc-url 2.项目中加了日志输出，可看到完整执行过程 3.在Service中应用事务时，自定义的注解将失效，解决办法：可将注解配置到Controller方法中
springboot 实现 动态数据源
m0_74295055的博客
03-27 787
*** 切换数据源名称.*//*** 多数据源处理*/@Aspect@Order(1)@Componenttry {// 销毁数据源 在执行方法之后/*** 获取需要切换的数据源*/
Java SpringBoot 动态数据源
qq_44704799的博客
05-10 1004
SpringBoot 基于 AbstractRoutingDataSource 实现动态数据源，实现使用注解切换当前数据源
Spring Boot实现多数据源，可做CRUD操作
酷爱编程的小猿同学
11-10 478
在项目中，随着业务复杂度提高，我们可能要同时操作多个数据库，这个时候我们就需要配置多个数据源了。这里做个笔记，以免忘记！！！ 废话不说太多，直接上代码 项目结构 1.数据源配置文件 在application.yml配置文件中配置两个数据源，如下： datasource: pre : jdbc-url: jdbc:mysql://localhost:3306/xiaxia1?useUnicode=true&amp;characterEncoding=utf8&.
springboot动态数据源
sinat_30356443的博客
06-25 2498
基于spring-boot2.0.0版本实现多数据源注册 功能点:一,可以通过配置控制数据源注册个数,实现事先不知道数据源个数和别名,在不修改任何有关数据库相关代码条件下,仅仅在使用时按照规则添加配置来注册多数据源.可以将其作为基础jar提供公共服务. 二,实现了多数据源中,调用单个数据源的事务控制(同一个方法中只调用一个数据库的事务),同一个方法中调用不同数据源就是分布式事务,以下代码没有实...
springboot 动态数据源
04-03
SpringBoot动态数据源是指在应用程序运行时根据需要动态地切换数据源，而不是在应用程序启动时就确定使用哪个数据源。动态数据源可以根据业务需求，灵活配置多个数据源，实现读写分离、多租户等功能。 SpringBoot动态数据源的实现通常包括以下步骤： 1. 配置多个数据源：在应用程序启动时，配置多个数据源，包括数据源的基本信息和连接池等参数。 2. 实现数据源路由：通过AOP、自定义注解等方式，拦截数据源访问的方法，并根据业务需求选择使用哪个数据源。 3. 动态切换数据源：在需要切换数据源的时候，通过调用切换数据源的方法，切换到指定的数据源。 SpringBoot的动态数据源实现方式有很多种，可以根据具体业务需求选择合适的方式。常见的实现方式包括使用AbstractRoutingDataSource、使用JdbcTemplate、使用Mybatis等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值