springboot配置Druid多数据源并解决循环依赖

最新推荐文章于 2024-08-01 11:31:44 发布
最新推荐文章于 2024-08-01 11:31:44 发布
阅读量2.6k 收藏 4
点赞数 1
分类专栏： SpringBoot高级 文章标签： spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41587516/article/details/121786973
版权

目录

我的springboot web项目工程目录如下：

在这里插入图片描述

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>

  <groupId>cn.example</groupId>
  <artifactId>SpringBootStudy</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>SpringBootStudy Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>

    <!--自定义配置-->
    <druid.starter.version>1.1.16</druid.starter.version>
  </properties>

  <!-- Inherit defaults from Spring Boot -->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.3.RELEASE</version>
  </parent>

  <!-- Add typical dependencies for a web application -->
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- 配置注解执行器配置完成后，当执行类中已经定义了对象和该对象的字段后，在配置文件中对该类赋值时，便会非常方便的弹出提示信息 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-configuration-processor</artifactId>
      <optional>true</optional>
    </dependency>

    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
    </dependency>

    <!-- jdbcTemplate -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <!-- MySQL连接 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <scope>runtime</scope>
    </dependency>

    <!--引入druid数据源-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid-spring-boot-starter</artifactId>
      <version>${druid.starter.version}</version>
    </dependency>

    <!-- 测试 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>

    <!-- 切面 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
    </dependency>
  </dependencies>

  <!-- Package as an executable jar -->
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>
YAML配置文件如下：
spring:
  profiles:
    active: dev
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource  #修改数据源为Druid
    druid:
      master:
        url: jdbc:mysql://localhost:3306/study?autoReconnect=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&zeroDateTimeBehavior=convertToNull
        username: root
        password: root
      slave:
        enable: true
        url: jdbc:mysql://localhost:3306/study?autoReconnect=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&zeroDateTimeBehavior=convertToNull
        username: root
        password: root
      initialSize: 3  #修改Druid的默认连接配置
      minIdle: 10   # 最小连接池数量
      maxActive: 20   # 最大连接池数量
      maxWait: 60000   # 配置获取连接等待超时的时间
      timeBetweenEvictionRunsMillis: 60000  # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      minEvictableIdleTimeMillis: 300000  # 配置一个连接在池中最小生存的时间，单位是毫秒
      maxEvictableIdleTimeMillis: 900000  # 配置一个连接在池中最大生存的时间，单位是毫秒
在annotation包中创建自定义注解DataSource：
package cn.xhh.study.common.annotation;

import cn.xhh.study.common.enums.DataSourcesType;

import java.lang.annotation.*;

/**
 * 数据源自定义注解
 * @author Administrator
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataSource {
    DataSourcesType name() default DataSourcesType.MASTER;
}
在enums包中创建枚举类DataSourcesType：
package cn.xhh.study.common.enums;

/**
 * 数据源类型
 * @author Administrator
 */
public enum  DataSourcesType {
    /**
     * 主库
     */
    MASTER,

    /**
     * 从库
     */
    SLAVE
}
在core.aop包中创建切面类DynamicDataSourceAspect：
package cn.xhh.study.core.aop;

import cn.xhh.study.common.annotation.DataSource;
import cn.xhh.study.core.datasource.DynamicDataSourceContextHolder;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 1.@Order(-1)保证该AOP在@Transactional之前执行
 * @author Administrator
 */
@Aspect
@Component
@Order(-1)
public class DynamicDataSourceAspect {

    protected Logger logger = LoggerFactory.getLogger(getClass());


    @Pointcut("@annotation(cn.xhh.study.common.annotation.DataSource)"
            + "|| @within(cn.xhh.study.common.annotation.DataSource)")
    public void dsPointCut()  {
    }

    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Method targetMethod = this.getTargetMethod(point);
        //获取要切换的数据源
        DataSource dataSource = targetMethod.getAnnotation(DataSource.class);
        if (dataSource != null)  {
            DynamicDataSourceContextHolder.setDataSourceType(dataSource.name().name());
        }
        try {
            return point.proceed();
        }
        finally  {
            // 销毁数据源 在执行方法之后
            DynamicDataSourceContextHolder.removeDataSourceType();
        }
    }

    /**
     * 获取目标方法
     */
    private Method getTargetMethod(ProceedingJoinPoint pjp) throws NoSuchMethodException {
        Signature signature = pjp.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method agentMethod = methodSignature.getMethod();
        return pjp.getTarget().getClass().getMethod(agentMethod.getName(), agentMethod.getParameterTypes());
    }
}
在core.datasource包中创建动态数据源类DynamicDataSource和数据源切换处理类DynamicDataSourceContextHolder：
package cn.xhh.study.core.datasource;

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

/**
 * 获取数据源（依赖于 spring）
 * 定义一个类继承AbstractRoutingDataSource实现determineCurrentLookupKey方法，该方法可以实现数据库的动态切换
 * @author Administrator
 */
public class DynamicDataSource extends AbstractRoutingDataSource {

    public static  DynamicDataSource build() {
        return new DynamicDataSource();
    }

    /**
     * 获取与数据源相关的key
     * 此key是Map<String,DataSource> resolvedDataSources 中与数据源绑定的key值
     * 在通过determineTargetDataSource获取目标数据源时使用
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceType();
    }

}


package cn.xhh.study.core.datasource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 数据源切换处理
 * @author Administrator
 */
public class DynamicDataSourceContextHolder {

    public static final Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);

    /**
     *此类提供线程局部变量。这些变量不同于它们的正常对应关系是每个线程访问一个线程(通过get、set方法),有自己的独立初始化变量的副本。
     */
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    /**
     * 设置当前线程的数据源变量
     */
    public static void setDataSourceType(String dataSourceType) {
        log.info("已切换到{}数据源", dataSourceType);
        contextHolder.set(dataSourceType);
    }

    /**
     * 获取当前线程的数据源变量
     */
    public static String getDataSourceType() {
        return contextHolder.get();
    }

    /**
     * 删除与当前线程绑定的数据源变量
     */
    public static void removeDataSourceType() {
        contextHolder.remove();
    }

}
在core.druid包中创建数据源配置类DataSourceConfiguration和数据源配置文件类DataSourceProperties：
package cn.xhh.study.core.druid;


import cn.xhh.study.common.enums.DataSourcesType;
import cn.xhh.study.core.datasource.DynamicDataSource;
import cn.xhh.study.core.druid.DataSourceProperties;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Primary;

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

/**
 * 数据源配置类
 * @author Administrator
 */
@Configuration
public class DataSourceConfiguration {

    /**
     * 主库
     */
    @Bean
    @ConfigurationProperties("spring.datasource.druid.master")
    public DataSource masterDataSource(DataSourceProperties dataSourceProperties) {
        return dataSourceProperties.setDataSource(DruidDataSourceBuilder.create().build());
    }

    /**
     * 从库
     * @param dataSourceProperties
     * @return DataSource
     */
    @Bean
    @ConditionalOnProperty( prefix = "spring.datasource.druid.slave", name = "enable", havingValue = "true")//是否开启数据源开关---若不开启 默认适用默认数据源
    @ConfigurationProperties("spring.datasource.druid.slave")
    public DataSource slaveDataSource(DataSourceProperties dataSourceProperties) {
        return dataSourceProperties.setDataSource(DruidDataSourceBuilder.create().build());
    }

    /**
     * 1.@DependsOn({"masterDataSource","slaveDataSource"})配合Springboot启动类，解决Druid多数据源循环依赖的问题
     * 设置数据源
     */
    @Bean(name = "dynamicDataSource")
    @Primary
    @DependsOn({"masterDataSource","slaveDataSource"})
    public DynamicDataSource dynamicDataSource(DataSource masterDataSource, DataSource slaveDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        DynamicDataSource dynamicDataSource = DynamicDataSource.build();
        targetDataSources.put(DataSourcesType.MASTER.name(), masterDataSource);
        targetDataSources.put(DataSourcesType.SLAVE.name(), slaveDataSource);
        //默认数据源配置 DefaultTargetDataSource
        dynamicDataSource.setDefaultTargetDataSource(masterDataSource);
        //额外数据源配置 TargetDataSources
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.afterPropertiesSet();
        return dynamicDataSource;
    }
}


package cn.xhh.study.core.druid;

import com.alibaba.druid.pool.DruidDataSource;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

/**
 * 数据源配置文件
 * @author Administrator
 */
@Setter
@Configuration
@ConfigurationProperties(prefix = "spring.datasource.druid")
public class DataSourceProperties {

    private int initialSize;

    private int minIdle;

    private int maxActive;

    private int maxWait;

    private int timeBetweenEvictionRunsMillis;

    private int minEvictableIdleTimeMillis;

    private int maxEvictableIdleTimeMillis;

    private String validationQuery;

    private boolean testWhileIdle;

    private boolean testOnBorrow;

    private boolean testOnReturn;

    public DruidDataSource setDataSource(DruidDataSource datasource) {

        // 配置初始化大小、最小、最大
        datasource.setInitialSize(initialSize);
        datasource.setMaxActive(maxActive);
        datasource.setMinIdle(minIdle);

        // 配置获取连接等待超时的时间
        datasource.setMaxWait(maxWait);

        // 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);

        // 配置一个连接在池中最小、最大生存的时间，单位是毫秒
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis);

        /**
         * 用来检测连接是否有效的sql，要求是一个查询语句，常用select 'x'。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。
         */
        datasource.setValidationQuery(validationQuery);

        /** 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。 */
        datasource.setTestWhileIdle(testWhileIdle);

        /** 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnBorrow(testOnBorrow);

        /** 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnReturn(testOnReturn);

        return datasource;
    }
}
在启动类StudyApplication加入注解，解决循环依赖：
package cn.xhh.study;

import cn.xhh.study.servlet.listener.MyListener;
import cn.xhh.study.servlet.MyServlet;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;

/**
 * 1.@ServletComponentScan：启动对自定义servlet的扫描
 * 2.添加(exclude = {DataSourceAutoConfiguration.class})，解决在配置Druid多数据源时，出现循环依赖的问题
 * @author Administrator
 */
@ServletComponentScan
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class StudyApplication {
    public static void main(String[] args) {
        SpringApplication.run(StudyApplication.class, args);
    }
}
添加Controller测试类：
package cn.xhh.study.controller;

import cn.xhh.study.common.annotation.DataSource;
import cn.xhh.study.common.enums.DataSourcesType;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

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

/**
 * @author Administrator
 */
@Controller
public class JdbcTemplateController {

    private JdbcTemplate jdbcTemplate;

    public JdbcTemplateController(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @ResponseBody
    @RequestMapping("queryUserForList")
    @DataSource(name = DataSourcesType.SLAVE)
    public List<Map<String, Object>> getData() {
        String sql = "select * from user";
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
        return maps;
    }
}
自己在mysql中建立一个user表，进行测试。
在浏览器输入地址，查看结果：
http://localhost:8081/queryUserForList
后台程序打印日志：
2021-12-08 10:58:13.400  INFO 7284 --- [nio-8081-exec-1] c.x.s.c.d.DynamicDataSourceContextHolder : 已切换到SLAVE数据源

Druid多数据源配置成功！

Mr_青青子衿
关注
专栏目录
SpringBoot整合多数据源
冲出仁川，走出马德里，故事还会再继续
01-24 533
我们在调用任何持久层的框架，都是基于JDBC进行操作的，只要集成了Spring框架就一定会注入配置的DataSource获取连接。既然是我们配置的，我们可以实现一个自定义的DataSource,然后动态提供数据源。说干就干那我们实现DataSource这个接口，实现方法即可，会返回一个Connection对象。我们在这个方法中根据业务需求动态提供不同数据源的Connection对象即可。实现逻辑如下：我们可以通过一个静态的标识去判断，比如如果是Write,那就返回,如果是Read，就返回。
Springboot整合Druid多数据源遇到的依赖循环问题
chenxue843400447的博客
02-27 2222
报错信息： Description: The dependencies of some of the beans in the application context form a cycle: modelEditorJsonRestResource (field private org.activiti.engine.RepositoryService com.example.de...
SpringBoot初始化数据源循环依赖 The dependencies of some of the beans in the application context form a cycle:...
chensihan0726的博客
03-27 2835
使用druid多数据源时，项目启动出现数据源循环依赖，百度半天没找到解决办法，最后只能去Google了，一下子就出来了，还是Google靠谱啊！！！ sprintboot 低版本可以使用 spring.datasource.initialize=false （默认为true） 来解决，升级到...
解决Spring Boot项目中的循环依赖问题
最新发布
心猿意码
08-01 648
循环依赖是指两个或多个类互相依赖对方，形成了一个闭环。例如，类A依赖于类B，而类B又依赖于类A。循环依赖是Spring Boot项目中常见的问题之一。虽然Spring框架本身提供了一定程度的支持来帮助开发者解决这类问题，但最佳的做法还是尽可能地避免循环依赖的发生。通过合理设计系统架构和遵循良好的编码实践，可以有效地降低循环依赖的风险。通过全局配置默认的懒加载选项，我们可以减少对单个类添加@Lazy注解的需求，从而简化代码。此外，重构代码以减少不必要的依赖关系也是一个很好的实践。
springboot配置多数据源时的循环依赖问题
qq_22533661的博客
12-09 1715
解决方式1： 添加 @Import({DruidDBConfig.class}) @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class }) //排除DataSource自动配置类，使用我们自定义的DataSource 解决方式2： 升级版本号 ...
SpringBoot多数据源启动出现循环依赖问题
奕辰杰的博客
05-20 567
SpringBoot多数据源启动出现循环依赖问题
多数据源循环依赖问题
weixin_45168162的博客
09-14 404
使用springboot + druid + mybatisplus完成多数据源配置 The dependencies of some of the beans in the application context form a cycle: spring中依赖进入循环的解决办法 只需要再application.properties 文件中 加入 一行代码 spring.datasource.initialize=false 重新运行 就ojbk 了 ...
springboot+mybats多数据源时依赖循环问题
少健终望成，波中取千金----张少波
04-23 1885
环境 maven依赖 <?xml version="1.0" encoding="UTF-8"?> 4.0.0 org.springframework.boot spring-boot-starter-parent 2.1.4.RELEASE com.microservice dbandcache 0.0.1-SNAPSHOT dbandcache Demo project ...
springboot使用Druid配置多数据源
在2025年等你的博客
09-10 912
参考文档：https://www.cnblogs.com/wangkongming/p/12878221.html 之前没有使用过多数据源，由于项目需求需要，学习记录一下 按照参考的文档配置完之后，启动有警告 [ restartedMain] o.mybatis.spring.SqlSessionFactoryBean : Property ‘mapperLocations’ was specified but matching resources are not found. 查询了一下，是因为两个
SpringBoot集成Druid 动态切换数据源
qq_46237915的博客
07-14 887
SpringBoot集成Druid 动态切换数据源 主要逻辑 通过继承 AbstractRoutingDataSource 类覆写其 determineCurrentLookupKey() 方法来设置数据源，动态切换则基于aop实现。通过自定义一个注解，传入我们需要的数据源名称，在切面中获取到数据源名称并将其存储到当前线程的私有内存（ThreadLocal）中。在调用方法时读取当前线程存储的数据源名称，并根据这个名称去设置数据源. 依赖： <parent> <groupId>
集成fescar数据源循环依赖错误解决方案
一步一步往上爬
05-09 2685
集成fescar数据源循环依赖错误解决方案。
年结功能实现（二） - SpringBoot整合Druid实现多个动态数据源按特定需求切换
全干攻城狮
05-13 455
需求 实现年度结转功能 思路 如上： 根据系统数据库存储的数据源信息，生成多个DataSource Bean 按BeanName为key，DataSource为value将数据源信息存入Map集合 用户发起请求时携带年度参数 根据年度生成的BeanName在Map中查找对应的DataSource 设置当前数据源为上一步查找到的DataSource 获取数据库连接执行请求操作并返回结果 相关源码解析 如不需要看此部分，请下拉查看代码实现 // org.springframework.jdbc.d
springboot+druid多数据源切换循环依赖问题记录
不回头的博客
04-24 368
简单记录循环依赖问题 循环依赖问题 在启动类上面加注解可解决循环依赖问题，如下： @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class}) 报错如下：
springcloud spring-boot-starter-actuator与datasource引起的循环依赖问题
热门推荐
sinat
11-28 3万+
在部署springcloud微服务的时候，使用了SR2版本，出现spring默认数据源Hikari注入的循环依赖问题 最后是如何解决的呢？ 在当前微服务中添加 spring: cloud: refresh: refreshable: none 即可  ...
Hikari默认连接池出现dataSource循环依赖问题
qq_34886456的博客
07-06 932
2021-07-06 22:07:25.964 INFO 2640 --- [ main] o.apache.catalina.core.StandardService : Stopping service [Tomcat] 2021-07-06 22:07:26.056 WARN 2640 --- [ main] ConfigServletWebServerApplicationContext : Exception encountered during c
动态数据源循环依赖问题
m0_37607945的博客
12-25 2570
假如在项目中定义动态数据源，以下配置中DynamicDataSource是org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource的子类 @ConfigurationProperties("spring.datasource.source") @Bean public DataSource sourceDataSource() { return DruidDataSourceBuilder
折腾了我两天的springboot数据源datasource循环依赖问题，都被搞疯掉了
weixin_30341745的博客
01-05 616
在做项目重构的时候增加了两个功能 　　1、多数据源。 　　2、token的验证从以前的数据库验证，移到了redis端。 1、多数据源使用druid-spring-boot-starter套件 　　其核心代码如下 　　 @Configuration public class DynamicDataSourceConfig { @Bean @Configu...
基于 Flyway + Druid + dynamic 做的多数据源自动创建数据库和表结构维护
qq_15631813的博客
06-23 1171
基于 Flyway + Druid + dynamic 做的多数据源自动创建数据库和表结构维护 使用 Flyway 配合多数据源来创建数据库和表结构最终实现的效果就是 当启动的时候会自动创建数据库 然后再创建表结构 然后剩下的就是Flyway的基础用法 ...
SpringBoot+Mybatis+Druid动态数据源配置实战
"通过springboot+mybatis+druid配置动态数据源" 在现代企业级应用中，经常需要处理多个数据库，比如分离读写操作、分布式系统或是多租户环境。在这种情况下，动态数据源的配置变得至关重要。本教程将详细讲解如何在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值