SpringBoot配置多数据源（结合Druid）

最新推荐文章于 2024-08-15 21:36:29 发布
最新推荐文章于 2024-08-15 21:36:29 发布
阅读量8.7k 收藏 3
点赞数 1
分类专栏： springboot 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34912469/article/details/77965198
版权

在单数据源的情况下，Spring Boot的配置非常简单，只需要在application.properties文件中配置连接参数即可。但是往往随着业务量发展，我们通常会进行数据库拆分或是引入其他数据库，从而我们需要配置多个数据源，下面介绍多数据源的配置方式。

主要目录结构：主要关注红色方框中与本节相关的类。
这里写图片描述

  1. pom.xml
<?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>com.easted</groupId>
    <artifactId>card</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>card</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.6.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Dalston.SR3</spring-cloud.version>
    </properties>

    <dependencies>
    <dependency>  <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency> 

            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- 阿里的druid依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.19</version>
        </dependency>
        <!-- 格式化对象，方便输出日志 -->  
        <dependency>  
            <groupId>com.alibaba</groupId>  
            <artifactId>fastjson</artifactId>  
            <version>1.1.41</version>  
        </dependency>  
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
         <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- lombok 在类上加@Data可以省略get、set方法 -->
        <!-- <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency> -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-rest</artifactId>
        </dependency>
        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>javax.persistence</artifactId>
            <version>2.0.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>2.11.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>
                spring-boot-starter-data-elasticsearch
            </artifactId>
        </dependency>

        <dependency>
            <groupId>com.sun.jna</groupId>
            <artifactId>jna</artifactId>
            <version>3.0.9</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.8</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-atomikos</artifactId>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>
  1. application.yml
# Server configuration
server:
  port: 8090
  contextPath:

# Spring configuration
spring:
  thymeleaf: 
    cache: false
  mvc: 
    favicon:
      enabled: false
  #Multi DataSource Config
  datasource: 
     primary:
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:postgresql://127.0.0.1/db_one
        username: wangh
        password: easted2013
        driverClassName: org.postgresql.Driver
        initialSize: 5
        minIdle: 5
        maxActive: 200
        maxWait: 60000
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: SELECT 'x'
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        poolPreparedStatements: true
        maxPoolPreparedStatementPerConnectionSize: 20
        filters: stat,wall,log4j
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
     slave:
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:postgresql://127.0.0.1/db_two
        username: wangh
        password: easted2013
        driverClassName: org.postgresql.Driver
        initialSize: 5
        minIdle: 5
        maxActive: 200
        maxWait: 60000
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: SELECT 'x'
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        poolPreparedStatements: true
        maxPoolPreparedStatementPerConnectionSize: 20
        filters: stat,wall,log4j
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
  jpa:
    show-sql: true 
    hibernate: 
      ddl-auto: update
    properties:
      hibernate: 
        dialect: org.hibernate.dialect.PostgreSQLDialect
  1. DataSourceConfig类
package com.easted.card.core.config;

import javax.sql.DataSource;

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.context.annotation.Primary;

import com.alibaba.druid.pool.DruidDataSource;

/**
 1. @ClassName:DataSourceConfig
 2. @author:wh
 3. @date: 2017年9月12日 上午10:33:39
 */
@Configuration
public class DataSourceConfig {

    @Bean(name = "primaryDataSource")
    @Qualifier("primaryDataSource")
    @Primary//配置该数据源为主数据源
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource(){
//      return DataSourceBuilder.create().build();
        return new DruidDataSource();
    }

    @Bean(name = "slaveDataSource")
    @Qualifier("slaveDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource secondDataSource(){
//      return DataSourceBuilder.create().build();
        return new DruidDataSource();
    }
}
  1. PrimaryConfig类
    新增对第一数据源的JPA配置，注意两处注释的地方，用于指定数据源对应的Entity实体和Repository定义位置，用@Primary区分主数据源。
package com.easted.card.core.config;

import java.util.HashMap;
import java.util.Map;

import javax.persistence.EntityManager;
import javax.sql.DataSource;

import org.hibernate.cfg.ImprovedNamingStrategy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;

/**
 1. @ClassName:PrimaryConfig
 2. @author:Wh
 3. @date: 2017年9月13日 上午10:11:40
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef="entityManagerFactoryPrimary",
        transactionManagerRef="transactionManagerPrimary",
        basePackages= { "com.easted.card.core.repository.primary"}) //设置Repository所在位置
public class PrimaryConfig {

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


    @Primary
    @Bean(name = "entityManagerPrimary")
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
        return entityManagerFactoryPrimary(builder).getObject().createEntityManager();
    }

    @Bean(name = "entityManagerFactoryPrimary")
    @Primary
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary (EntityManagerFactoryBuilder builder) {
        return builder.dataSource(primaryDataSource)
                .packages("com.easted.card.core.entity.postgre1")
                .persistenceUnit("primary")
                .properties(buildProperties())
                .build();
    } 

    @Bean(name="transactionManagerPrimary")
    @Autowired
    public PlatformTransactionManager primaryTransactionManager(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactoryPrimary(builder).getObject());
    }

 // 公共jpa设置
    @Value("${spring.jpa.hibernate.ddl-auto}")
    String dll;
    @Value("${spring.jpa.properties.hibernate.dialect}")
    String dialect;
    @Value("${spring.jpa.show-sql}")
    String showSql;

    private Map<String, Object> buildProperties() {
        Map<String, Object> properties = new HashMap<String, Object>();
        properties.put("hibernate.ejb.naming_strategy", ImprovedNamingStrategy.class.getName());
        properties.put("hibernate.hbm2ddl.auto", dll);
        properties.put("hibernate.dialect", dialect);
        properties.put("hibernate.show_sql", showSql);
        return properties;
    }
}
  1. SlaveConfig类
package com.easted.card.core.config;

import java.util.HashMap;
import java.util.Map;

import javax.persistence.EntityManager;
import javax.sql.DataSource;

import org.hibernate.cfg.ImprovedNamingStrategy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;

/**
 * SlaveConfig
 * @author:Wh
 * @date: 2017年9月13日 上午10:11:40
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef="entityManagerFactorySlave",
        transactionManagerRef="transactionManagerSlave",
        basePackages= { "com.easted.card.core.repository.slave"}) //设置Repository所在位置
public class SlaveConfig {

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


    @Bean(name = "entityManagerSlave")
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
        return entityManagerFactorySlave(builder).getObject().createEntityManager();
    }

    @Bean(name = "entityManagerFactorySlave")
    public LocalContainerEntityManagerFactoryBean entityManagerFactorySlave(EntityManagerFactoryBuilder builder) {
        return builder.dataSource(slaveDataSource)
                .packages("com.easted.card.core.entity.postgre2")
                .persistenceUnit("slave")
                .properties(buildProperties())
                .build();
    } 

    @Bean(name="transactionManagerSlave")
    @Autowired
    public PlatformTransactionManager slaveTransactionManager(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactorySlave(builder).getObject());
    }

 // 公共jpa设置
    @Value("${spring.jpa.hibernate.ddl-auto}")
    String dll;
    @Value("${spring.jpa.properties.hibernate.dialect}")
    String dialect;
    @Value("${spring.jpa.show-sql}")
    String showSql;

    private Map<String, Object> buildProperties() {
        Map<String, Object> properties = new HashMap<String, Object>();
        properties.put("hibernate.ejb.naming_strategy", ImprovedNamingStrategy.class.getName());
        properties.put("hibernate.hbm2ddl.auto", dll);
        properties.put("hibernate.dialect", dialect);
        properties.put("hibernate.show_sql", showSql);
        return properties;
    }
}
  1. DruidConfig类
package com.easted.card.core.config;

import java.util.HashMap;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;

/**
 1. 配置Druid监控
 2. @ClassName:DruidDBConfig
 3. @author:Wh
 4. @date: 2017年8月23日 下午3:21:51
 */
@Configuration
@EnableTransactionManagement
public class DruidConfig{
    private static final Logger log = LoggerFactory.getLogger(DruidConfig.class);

    @Bean 
    public ServletRegistrationBean druidServlet() { 
        log.info("开始Druid Servlet初始化配置..."); 
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(); 
        servletRegistrationBean.setServlet(new StatViewServlet());
        servletRegistrationBean.addUrlMappings("/druid/*"); 
        Map<String, String> initParameters = new HashMap<String, String>(); 
        //用户名 
        initParameters.put("loginUsername", "wangh");
        //密码
        initParameters.put("loginPassword", "easted"); 
        // 禁用HTML页面上的“Reset All”功能 
        initParameters.put("resetEnable", "false");
        // IP白名单 (没有配置或者为空，则允许所有访问) 
        initParameters.put("allow", "127.0.0.1"); 
        // IP黑名单 (存在共同时，deny优先于allow) 
        initParameters.put("deny", "");
        servletRegistrationBean.setInitParameters(initParameters); 
        return servletRegistrationBean; 
    } 

    @Bean 
    public FilterRegistrationBean filterRegistrationBean() { 
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(); 
        filterRegistrationBean.setFilter(new WebStatFilter()); 
        filterRegistrationBean.addUrlPatterns("/*"); 
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"); 
        return filterRegistrationBean; 
    } 

}
  1. 实体类

在postgre1和postgre2包下分别建实体类。

package com.easted.card.core.entity.postgre1;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;



@Entity
public class Book {
    @Id
    @GeneratedValue
    private Integer id;
    private String name;

    /**
     * @Title: getId <BR>
     * @return:Integer <BR>
     */
    public Integer getId() {
        return id;
    }
    /**
     * @param id the id to set
     */
    public void setId(Integer id) {
        this.id = id;
    }
    /**
     * @Title: getName <BR>
     * @return:String <BR>
     */
    public String getName() {
        return name;
    }
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }


}
  1. primary包下BookRepository接口
package com.easted.card.core.repository.primary;

import org.springframework.data.jpa.repository.JpaRepository;

import com.easted.card.core.entity.postgre1.Book;
public interface BookRepository extends JpaRepository<Book, Integer> {

}
  1. slave包下BookRepository接口
package com.easted.card.core.repository.slave;

import org.springframework.data.jpa.repository.JpaRepository;

import com.easted.card.core.entity.postgre2.Book;
public interface BookRepository extends JpaRepository<Book, Integer> {

}

然后启动springboot.就可以了。
浏览器输入http://localhost:8090/druid/login.html
这里写图片描述

输入druidconfig配置的用户名密码。
这里写图片描述

这里写图片描述

可以看到有两个数据源。

wangtuoyuan
关注
专栏目录
springboot中Druid多数据源配置
u011036433的专栏
02-28 933
1.application.properties配置如下： #数据源1 spring.jdbc.datasource.ds1.driver-class-name=com.mysql.jdbc.Driver spring.jdbc.datasource.ds1.url=jdbc:mysql://localhost:3306/test?zeroDateTimeBehavior=convertToN...
springboot 配置DRUID数据源的方法实例分析
08-25
本文详细介绍了 SpringBoot 配置 Druid 数据源的方法，包括添加 Druid 依赖项、编辑配置数据源代码、Druid 数据源配置和使用 Druid 数据源。Druid 数据源提供了高性能和多功能的数据库连接池解决方案，适合大型应用...
SpringBoot+Druid多数据源配置
从入门到放弃的博客
01-20 5079
以下内容转载自：https://my.oschina.net/u/3681868/blog/1813011 一.引入Jar包: <dependency> <!-- MySql驱动 --> <groupId>mysql</groupId> <artifactId>mysql-connector-java</art...
springBoot+ druid配置多数据源
最新发布
darlene2929的博客
08-15 831
里面有3个类，分别：DruidConfigFirst ，DruidConfigSecond ，TwoDataSourceConfig。dao 里面分开对应mysql的Mapper，oracle的Mapper。springBoot+ druid配置多数据源。应用：正常注入就行，他会自己去对应数据库。2.新建一个config文件。
SpringBoot多数据源配置（Druid）
qq_31263039的博客
04-13 336
记录转载： https://my.oschina.net/u/3681868/blog/1813011
SpringBoot+Mybatis 整合多数据源 (druid)
吉他程序员的博客
03-11 290
作为一个合格的架构师，今天这篇文章算是划水，但是又是不得不会的。 我的项目是SpringBoot+Mybatis通用Mapper + 多数据源（druid），如果连基本Mybatis都没整合的，请先见我这篇文章： SpringCloud+Nacos+Mybatis+Redis+Kafka 微服务整套框架环境搭建​githubs.xyz 准备两个数据源 spring: datasource: type: com.alibaba.druid.pool.DruidDataSource .
JAVA：Springboot 集成 Druid 多数据源配置教程
木头
06-26 4096
简要的阐述了springboot+druid配置多数据源的实现。
springboot整合druid数据源 在多数据源的搭建上改造而来
a_liuren的博客
11-26 350
场景：利用springboot整合druid数据源主要是可以对多次连接数据库中的连接起到反复利用的效果，性能也是最好的，同时还能提供监控的功能，是在前面的代码之上改造过来的，同时我们也用druid来搭配多数据源来使用： 流程： 导入pom包， 配置好文件， 编写配置类， controller层访问： pom包的导入：这次只是添加一个druid包 <dependency> <groupId>com.alibaba</groupId>
springboot2.0多数据源集成hibernate配置hibernateDaoSupport示例
04-12
本示例主要介绍如何实现Spring Boot 2.0多数据源的集成，并结合Hibernate进行配置，特别是在DAO层使用`HibernateDaoSupport`进行操作，而非使用JPA（Java Persistence API）。 首先，让我们了解Spring Boot 2.0的...
springboot连接池、动态配置多数据源连接池，特别适合大数据部门、数据中台服务的多数据源连接池.zip
03-04
1. **配置数据源**：在`application.properties`或`application.yml`文件中，为每个数据源定义相应的属性，如URL、用户名、密码和驱动类名。 2. **创建数据源bean**：利用@ConfigurationProperties绑定配置文件中的...
Springboot Druid多数据源 多线程
05-14
总结起来，这个项目展示了如何利用Spring Boot和Druid实现多数据源切换，以及如何在Spring Boot中配置和使用多线程来提升数据库操作的并发性能。对于初学者，这是一个很好的学习资源，可以深入理解Spring Boot的自动...
spring boot + mybatis(通用mapper) druid多数据源切换配置
08-14
1.配置数据源，2.动态数据源切换，3.注册动态数据源，4.动态数据源注解切点，5.通过切点切换数据源，6.在service层通过注解切换不同数据源，7.启动项目
springboot druid 多数据源demo
12-05
springboot开发,使用阿里druid-spring-boot-starter包,配置的多数据源demo,可自由加入多个数据源
Spring Boot整合Mybatis使用druid实现多数据源自动切换
08-24
Spring Boot整合Mybatis使用druid实现多数据源自动切换
完整Demo：springboot集成多数据源
07-28
完整Demo：springboot集成多数据源，是一个完整的项目，直接下载下来导入eclipse或idea，启动后运行即可。
Springboot整合Druid与Mybatis的多数据源切换
10-17
踩坑实录 亲测可用的springboot 整合mybatis druid 多数据源切换方案 使用注解方式更加灵活
springboot实现多数据源而且加上事务不会使aop切换数据源失效
04-03
本示例主要讲解如何使用Spring Boot结合MyBatis实现多数据源切换，并确保AOP事务管理仍然有效。 首先，我们需要配置多数据源。在Spring Boot中，可以使用`DataSource`接口的实现类，如`HikariCP`或`Druid`，创建两...
spring boot中使用druid多数据源配置Mybatis
喧闹的博客
03-16 2345
首选必须吐槽下，不知道是我读书太少，还是Spring boot确实对druid和mybatis的支持不好，奈何用怪了druid的数据库、sql、url监控和mybatis数据源，只有硬着头皮上了。相关配置常例先给出build.gradle配置"org.mybatis.spring.boot:mybatis-spring-boot-starter:1.2.0", "mysql:mysql-connec
SpringBoot 整合多数据源 （MyBats + Druid）
欢迎来到Gorit的博客
09-20 637
文章目录SpringBoot 整合多数据源 （MyBatis + Druid）一、项目环境准备二、项目配置初始化2.0 项目结构2.1 坐标依赖2.2 application.yml2.3 创建数据库三、MVC 三层编写3.1 mapper 编写3.2 entity 实体类编写3.3 config 配置类3.4 控制层 controller四、测试运行 SpringBoot 整合多数据源 （MyBatis + Druid） 大家在写项目的时候有没有遇到过这样的情况，当你需要你的好基友电脑上，服务器上的数据的
SpringBoot+Mybatis+Druid动态数据源配置实战
"通过springboot+mybatis+druid配置动态数据源" 在现代企业级应用中，经常需要处理多个数据库，比如分离读写操作、分布式系统或是多租户环境。在这种情况下，动态数据源的配置变得至关重要。本教程将详细讲解如何在...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值