springboot+mybatisplus+mysql双数据源动态切换（详细版）

最新推荐文章于 2024-05-24 17:01:09 发布
最新推荐文章于 2024-05-24 17:01:09 发布
阅读量1.8k 收藏 4
点赞数 1
分类专栏： java 文章标签： spring boot mysql mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zkr1234562/article/details/127942510
版权

此项目也是借助网上各种双数据源动态切换改编的（参考人人代码开源），暂没考虑数据库事务。

1、首先引入各种jar，springboot、mybatisplus等，配置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>com.hualife</groupId>
    <artifactId>springboot</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
    </parent>
    <properties>
        <java.version>1.8</java.version>
        <mybatis.spring.boot.version>2.2.2</mybatis.spring.boot.version>
        <pagehelper.spring.boot.version>1.4.5</pagehelper.spring.boot.version>
        <druid.version>1.2.22</druid.version>
        <commons.io.version>2.11.0</commons.io.version>
        <commons.configuration.version>1.10</commons.configuration.version>
        <mysql.version>8.0.30</mysql.version>
        <druid.version>1.2.13</druid.version>
        <mybatisplus.version>3.5.2</mybatisplus.version>
    </properties>
    <dependencies>
        <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-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>${pagehelper.spring.boot.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.4</version>
            <exclusions>
                <exclusion>
                    <artifactId>druid</artifactId>
                    <groupId>com.alibaba</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatisplus.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>com.baomidou</groupId>
                    <artifactId>mybatis-plus-generator</artifactId>
                </exclusion>
                <exclusion>
                    <artifactId>jsqlparser</artifactId>
                    <groupId>com.github.jsqlparser</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>mybatis</artifactId>
                    <groupId>org.mybatis</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.22</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.7.5</version>
            </plugin>
        </plugins>
    </build>
</project>

2、在yml中配置数据源信息如下（可多配置一些数据库连接池信息，自行百度吧有很多可以借鉴）：

server:
  port: 8080
spring:
  datasource:
    dynamic:
      datasource:
        master:
          #MySQL配置
          driver-class-name: com.mysql.cj.jdbc.Driver
          url: jdbc:mysql://localhost:3306/DB1?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true
          username: root
          password:
          initial-size: 2
          max-active: 20
          min-idle: 1
        slave:
          #MySQL配置
          driver-class-name: com.mysql.cj.jdbc.Driver
          url: jdbc:mysql://localhost:3306/DB2?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true
          username: root
          password:
          initial-size: 2
          max-active: 20
          min-idle: 1
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath:mapper/**/*.xml

3、建数据库，建表（不会的百度吧），并且生成对应的Java实体及mapper及xml等（可使用开源版人人代码生成器）。

4、搭建springboot项目，项目结构如下图（除了config以外，其他的包应该都知道是啥）：

 

5、在config目录下创建Java类，CurrDataSource.java（注解类，可用于项目中区分数据源），DataSourceAspect.java(切面类，根据切面选择不同的数据源)，DataSourceFactory.java（数据源工厂，包含数据库连接池信息），DataSourceProperties.java（数据源信息封装的实体类），DBTypeName.java（数据源名称常量），DynamicContextHolder.java（数据源上下文切换用的，实际是队列），
DynamicDataSourceProperties.java(双数据源信息对应的map，具体看下文中的代码吧)，MyDynamicDataSourceConfig.java（动态数据源配置类），MyRoutingDataSource.java(数据源路由类)

6、数据源切换的注解：

import java.lang.annotation.*;
/**
 * 多数据源注解
 * 自己项目中添加
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface CurrDataSource {
    String value() default "master";
}

7、aop切面类：

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
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.springframework.core.Ordered;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
/**
 * 多数据源，切面处理类
 */
@Aspect
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
@Slf4j
public class DataSourceAspect {

    @Pointcut("@annotation(com.hualife.modules.config.CurrDataSource) "  //方法包含注解
            +"|| @within(com.hualife.modules.config.CurrDataSource)"    //类包含注解
            +"|| within(com.baomidou.mybatisplus.core.mapper.BaseMapper+)")
  // 切BaseMapper及其子类，因为在mapper加注解但调用父类的方法切不到，故加了within，这样就可以切到父类了
  //其实只要within表达式就行，因为不管是service的impl还是mapper最终调的都是mapper的方法
  public void dSPointCut() {
    }

    @Around("dSPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Class targetClass = point.getTarget().getClass();
        Method method = signature.getMethod();
        log.info("执行数据库操作的类是：{},函数是：{}", targetClass.getName(), method.getName());
//        CurrDataSource targetDataSource = (CurrDataSource) targetClass.getAnnotation(CurrDataSource.class);
        CurrDataSource targetDataSource = AnnotationUtils.findAnnotation(targetClass, CurrDataSource.class);//获取目标类上注解
        CurrDataSource methodDataSource = method.getAnnotation(CurrDataSource.class);//获取目标函数上注解
        if (targetDataSource != null || methodDataSource != null) {
            log.info(targetDataSource + "===========" + methodDataSource);
            String value;
            if (methodDataSource != null) {
                value = methodDataSource.value();
            } else {
                value = targetDataSource.value();
            }
            DynamicContextHolder.push(value);
        } else {
            log.info("执行数据库操作的类及其函数上没有@CurrDataSource，而这个执行数据库操作的函数属于BaseMapper及其子类下的函数，故调用master");
            DynamicContextHolder.push(DBTypeName.MASTER);
        }
        try {
            return point.proceed();
        } finally {
            DynamicContextHolder.poll();
            log.info("clean datasource");
        }
    }
}

8、数据源工厂：

import com.alibaba.druid.pool.DruidDataSource;
import java.sql.SQLException;
/**
 * DruidDataSource
 */
public class DataSourceFactory {
    public static DruidDataSource buildDruidDataSource(DataSourceProperties properties) {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(properties.getDriverClassName());
        druidDataSource.setUrl(properties.getUrl());
        druidDataSource.setUsername(properties.getUsername());
        druidDataSource.setPassword(properties.getPassword());

        druidDataSource.setInitialSize(properties.getInitialSize());
        druidDataSource.setMaxActive(properties.getMaxActive());
        druidDataSource.setMinIdle(properties.getMinIdle());
        druidDataSource.setMaxWait(properties.getMaxWait());
        druidDataSource.setTimeBetweenEvictionRunsMillis(properties.getTimeBetweenEvictionRunsMillis());
        druidDataSource.setMinEvictableIdleTimeMillis(properties.getMinEvictableIdleTimeMillis());
        druidDataSource.setMaxEvictableIdleTimeMillis(properties.getMaxEvictableIdleTimeMillis());
        druidDataSource.setValidationQuery(properties.getValidationQuery());
        druidDataSource.setValidationQueryTimeout(properties.getValidationQueryTimeout());
        druidDataSource.setTestOnBorrow(properties.isTestOnBorrow());
        druidDataSource.setTestOnReturn(properties.isTestOnReturn());
        druidDataSource.setPoolPreparedStatements(properties.isPoolPreparedStatements());
        druidDataSource.setMaxOpenPreparedStatements(properties.getMaxOpenPreparedStatements());
        druidDataSource.setSharePreparedStatements(properties.isSharePreparedStatements());
        try {
            // druidDataSource.setFilters(properties.getFilters());
            druidDataSource.init();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return druidDataSource;
    }
}

9、多数据源属性类：

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
 * 多数据源属性，yml
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class DataSourceProperties {
    private String driverClassName;
    private String url;
    private String username;
    private String password;
    /**
     * Druid默认参数
     */
    private int initialSize = 2;
    private int maxActive = 10;
    private int minIdle = -1;
    private long maxWait = 60 * 1000L;
    private long timeBetweenEvictionRunsMillis = 60 * 1000L;
    private long minEvictableIdleTimeMillis = 1000L * 60L * 30L;
    private long maxEvictableIdleTimeMillis = 1000L * 60L * 60L * 7;
    private String validationQuery = "select 1";
    private int validationQueryTimeout = -1;
    private boolean testOnBorrow = false;
    private boolean testOnReturn = false;
    private boolean testWhileIdle = true;
    private boolean poolPreparedStatements = false;
    private int maxOpenPreparedStatements = -1;
    private boolean sharePreparedStatements = false;
    private String filters = "stat,wall";
}

10、数据库名字常量：

/**
 * 数据库名字常量
 */
public class DBTypeName {
    public static final String MASTER = "master";
    public static final String SLAVE = "slave";
}

11、多数据源上下文 ，用来放置数据源名字：

import java.util.ArrayDeque;
import java.util.Deque;
/**
 * 多数据源上下文
 * 用来放置数据源
 */
public class DynamicContextHolder {
    private static final ThreadLocal<Deque<String>> HOLDER = new ThreadLocal<Deque<String>>() {
        @Override
        protected Deque<String> initialValue() {
            return new ArrayDeque<String>();
        }
    };
    /**
     * 获得当前线程数据源
     * @return 数据源名称
     */
    public static String peek() {
        return HOLDER.get().peek();
    }

    /**
     * 设置当前线程数据源
     * @param dataSource 数据源名称
     */
    public static void push(String dataSource) {
        HOLDER.get().push(dataSource);
    }
    /**
     * 清空当前线程数据源
     */
    public static void poll() {
        Deque<String> deque = HOLDER.get();
        deque.poll();
        if (deque.isEmpty()) {
            HOLDER.remove();
        }
    }
}

12、多数据源属性类（把yml中多数据源信息对应成map）：

import org.springframework.boot.context.properties.ConfigurationProperties;
import java.util.LinkedHashMap;
import java.util.Map;
/**
 * 多数据源属性
 */
@ConfigurationProperties(prefix = "spring.datasource.dynamic")
public class DynamicDataSourceProperties {
    private Map<String, DataSourceProperties> datasource = new LinkedHashMap<>();
    public Map<String, DataSourceProperties> getDatasource() {
        return datasource;
    }
    public void setDatasource(Map<String, DataSourceProperties> datasource) {
        this.datasource = datasource;
    }
}

13、多数据源动态切换配置类：

import com.alibaba.druid.pool.DruidDataSource;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.type.JdbcType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;

/**
 * 配置多数据源
 */
@Slf4j
@Configuration
@EnableConfigurationProperties(DynamicDataSourceProperties.class)
public class MyDynamicDataSourceConfig {
    @Autowired
    private DynamicDataSourceProperties dynamicDataSourceProperties;

    @Bean(name = "dataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.master")
    public DataSourceProperties dataSourceProperties() {
        return new DataSourceProperties();
    }

    @Bean
    public MyRoutingDataSource dynamicDataSource(@Qualifier("dataSourceProperties") DataSourceProperties dataSourceProperties) {
        MyRoutingDataSource dynamicDataSource = new MyRoutingDataSource();
        Map<String, DataSourceProperties> dataSourcePropertiesMap = dynamicDataSourceProperties.getDatasource();
        Map<Object, Object> targetDataSources = new HashMap<>(dataSourcePropertiesMap.size());
        dataSourcePropertiesMap.forEach((k, v) -> {
            DruidDataSource druidDataSource = DataSourceFactory.buildDruidDataSource(v);
            targetDataSources.put(k, druidDataSource);
        });
        dynamicDataSource.setTargetDataSources(targetDataSources);
        //默认数据源
        DruidDataSource defaultDataSource = DataSourceFactory.buildDruidDataSource(dataSourceProperties);
        dynamicDataSource.setDefaultTargetDataSource(defaultDataSource);
        return dynamicDataSource;
    }

    @Bean("sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(@Qualifier("dataSourceProperties") DataSourceProperties dataSourceProperties) throws Exception {
        MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();
        sqlSessionFactory.setDataSource(dynamicDataSource(dataSourceProperties));
        MybatisConfiguration configuration = new MybatisConfiguration();
        configuration.setJdbcTypeForNull(JdbcType.NULL);
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setCacheEnabled(false);
        sqlSessionFactory.setConfiguration(configuration);
        return sqlSessionFactory.getObject();
    }
}

14、多数据源路由：

import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
/**
 * 多数据源
 */
@Slf4j
public class MyRoutingDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        String dataSource = DynamicContextHolder.peek();
        log.info("使用数据源：{}", dataSource);
        return dataSource;
    }
}

15、多数据源路由理解：参考下图（借用别人的图）銆怉bstractRoutingDataSource銆戝垎鏋� - zzsuje - 鍗氬鍥�

wuweixianzheng
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatis多数据源配置及动态切换——搭建多个数据源并动态切换
禅与计算机程序设计艺术
07-29 3624
随着互联网的蓬勃发展，网站的用户量和访问量越来越大，单个数据库已经无法承受如此巨大的访问量，而更好的解决方案是将数据分布到多个数据库服务器上，并通过读写分离的方式提高数据库负载能力和提升整体性能。为了实现这一目标，目前最流行的一种方式是使用读写分离的数据库架构模式。在这种架构模式下，应用层的数据请求会路由到主库或从库，由主库对数据进行写操作（INSERT、UPDATE等）后，同步给从库，保证主库中的数据的一致性。相比于单个数据库服务器，采用读写分离的架构模式最大的优点就是增加了灵活性。
Springboot + mybatis + druid 整合 (Mysql多数据源)
czc_292的博客
01-14 1872
1. 依赖注入 <!--SpringBoot--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.5.3</version> </dependency> <!--druid连接池--
正确可用版：SpringBoot+Mybatis-plus+Druid 实现配置多数据源（数据库）
Oxye
01-04 1万+
前言 此文介绍的是在SpringBoot中使用Mybatis配置多数据源（多个数据库），整合Druid 网上有很多文章，翻了翻，但是都有问题啊，有的是没使用Druid，使用了默认的Hirika，有的是配置文件不给或者给的是Hirika能用的配置，层级不对，所以我自己来记一下 代码 pom文件maven依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>druid
mybatis plus 配置多数据源(数据源进行切换)
最新发布
qq_42152032的博客
05-24 1034
AbstractRoutingDataSource 根据用户定义的规则选择当前的数据源，这样我们可以在执行查询之前，设置使用的数据源。//log.info("当前数据源 [{}]", DynamicDataSourceContextHolder.getDataSourceKey());) // MybatisSqlSessionFactoryBean中有各种MybatisPlus的配置属性(globalConfig、//sqlSession就是用来操作sql语句的。2、主启动类添加注解。
Mybatis多个数据源动态切换详解
weixin_48065337的博客
05-19 6052
动态数据源切换，支持多种数据源
SpringBoot连接MySQL并整合MyBatis-Plus
该用户名和简介纯属整活
06-18 2966
二、配置yml文件中MySQL的连接和Mybatis-Plus配置 2、创建Controller 3、创建service接口 4、创建Service实现类 5、创建Mapper 6、创建Mapper配置类 五、接口测试 1、URL携带参数测试(通过\绑定)
springboot+mybatisplus+mysql 多数据源
10-27
综上所述，"springboot+mybatisplus+mysql 多数据源"项目涵盖了Spring Boot的快速开发特性、MyBatisPlus的简便操作数据库能力，以及实现多数据源和动态数据源切换的高级技术。开发者可以通过这个示例学习如何在实际...
springboot+mybatisPlus+mysql动态数据源切换
10-17
本项目基于SpringBoot、Mybatis-Plus和MySQL，实现了动态数据源切换的功能，这使得系统能根据业务逻辑或用户权限在不同的数据库间灵活跳转，提高系统的灵活性和可扩展性。 首先，SpringBoot作为轻量级的Java框架，...
springboot+mybatisplus(mybatis)+mysql+oracle 多数据源项目
04-12
在多数据源场景下，Mybatis Plus可以方便地切换不同的数据源，实现对MySQL和Oracle的灵活操作。 项目的核心在于多数据源的配置。在Spring Boot中，我们可以通过@ConfigurationProperties注解来加载自定义的配置文件...
SpringBoot整合MyBatisPlus配置动态数据源的方法
08-26
SpringBoot 整合 MyBatisPlus 配置动态数据源的方法可以满足我们在实际开发中遇到的各种需求，例如读写分离、数据源切换等。通过使用 DynamicDataSource 插件，我们可以实现动态数据源的配置，提高应用程序的灵活性...
SpringBoot + mybatis-plus + druid 实现mySql与Orcl双数据源
01-12
总结起来，通过SpringBoot、Mybatis-Plus和Druid，我们可以方便地实现双数据源配置，使得应用能同时处理MySQL和Oracle数据库的数据。在实际开发中，要根据业务场景灵活切换数据源，确保数据操作的正确性和效率。同时...
Spring Boot整合Mybatis使用druid实现多数据源自动切换
08-24
Spring Boot整合Mybatis使用druid实现多数据源自动切换
Java培训：mybatisplus快速实现动态数据源切换
zy1992As的博客
11-21 1154
或者不同的数据源混合使用。举个简单的例子某企业要做订单网上订单系统这里面就可以涉及到多个子系统的连接，比如：产品主数据的数据源，项目管理系统的数据源（项目可以产品订单）等多个不同数据库类似的数据源，他们可能是ORACLE，SQL SERVER，MYSQL等多种混合数据源。1.本框架只做**切换数据源**这件核心的事情，并**不限制你的具体操作**，切换了数据源可以做任何CRUD。-支持**多层数据源嵌套切换**。**DS**可以注解在方法上或类上，**同时存在就近原则方法上注解优先于类上注解**。
《MyBatis-Plus 切换不同数据源 xml 中的 mysql 数据源识别与配置》
奇妙的Bug之旅
01-04 523
通过以上步骤，我们可以在 MyBatis-Plus 中轻松实现不同数据源的切换。使用来识别不同的数据源，并配置 database-id 参数，可以根据不同的数据源类型使用不同的 sql 语句，从而提高系统的灵活性和可维护性。希望本文对您理解和使用 MyBatis-Plus 切换不同数据源 xml 中识别 mysql 数据源的方法有所帮助。
SpringBoot整合多数据源，动态添加新数据源并切换（保姆级教程）
m0_48420795的博客
08-27 9690
SpringBoot整合多数据源，动态添加新数据源并切换（保姆级教程）
springboot整合多数据源的配置以及动态切换数据源，注解切换数据源
热门推荐
todoitbo的博客
05-22 9万+
springboot整合多数据源的配置以及动态切换数据源，注解切换数据源
mybatis-plus多数据源配置
yaoct的博客
12-02 6752
这里结合了springboot的多数据源配置，主要是手动创建数据源，再手动设置配置一些配置参数。
springboot dynamic多数据源demo以及常见切换、事务问题
qq_44691484的博客
02-28 5857
springboot dynamic多数据源demo以及常见切换、事务问题
Mybatis动态数据源切换
ezerror的栈力补给
08-23 4306
Mybatis动态数据源切换 1. 结构设计 首先看一下这个功能的架构设计 ![Component 1.png](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9jZG4ubmxhcmsuY29tL3l1cXVlLzAvMjAyMC9wbmcvMTE2NDY1NS8xNTk4MTMyMDQxMDc3LTJjZjQyNjI2LTk0MGItNGNjYy05NTc0LTJlZjJlY2ZhYTcxYS5wbmc?x-oss-process=image/format,png#al
Springboot+mybatisplus多数据源配置mysql和postgresql
08-15
对于Spring Boot和MyBatis Plus多数据源配置MySQL和PostgreSQL，你可以按照以下步骤进行操作： 1. 首先，在你的Spring Boot项目中添加MySQL和PostgreSQL的依赖。在`pom.xml`文件中添加以下依赖： ```xml ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值