前往小程序，Get更优阅读体验！
立即前往
文档建议反馈控制台
首页
学习
活动
专区
工具
TVP
最新优惠活动
文章/答案/技术大牛
发布
首页
学习
活动
专区
工具
TVP最新优惠活动
返回腾讯云官网
社区首页 >专栏 >SpringBoot整合MyBatis多数据源

SpringBoot整合MyBatis多数据源

作者头像
半月无霜
发布于 2023-03-03 14:46:19
9850
发布于 2023-03-03 14:46:19
举报
文章被收录于专栏：半月无霜半月无霜

SpringBoot整合MyBatis多数据源

一、介绍

在平常的项目中，我们有连接数据库的需求。一般都是一个项目一个数据库，但也有例外需要连接多个数据库的。

那么该如何配置，可以达到多数据源的需求呢。

本次为SpringBoot与MyBatis的整合，其实掌握了需要配置什么，也很容易进行复刻。

二、配置

1）数据库准备

首先，我们先准备三个数据库吧，这边都使用MySQL了，实际可以是不同的数据库

test数据库

代码语言：javascript
复制
create database `test` character set utf8mb4 collate utf8mb4_general_ci;

CREATE TABLE `sys_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(32) NOT NULL COMMENT '用户名',
  `password` varchar(128) NOT NULL COMMENT '密码',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4;

INSERT INTO `sys_user`(`id`, `username`, `password`) VALUES (1, 'banmoon', '1234');
INSERT INTO `sys_user`(`id`, `username`, `password`) VALUES (2, 'user', '1234');

test01数据库

代码语言：javascript
复制
create database `test01` character set utf8mb4 collate utf8mb4_general_ci;

CREATE TABLE `sys_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(32) NOT NULL COMMENT '用户名',
  `password` varchar(128) NOT NULL COMMENT '密码',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4;

INSERT INTO `sys_user`(`id`, `username`, `password`) VALUES (1, 'test01', '1234');
INSERT INTO `sys_user`(`id`, `username`, `password`) VALUES (2, 'test01User', '1234');

test02数据库

代码语言：javascript
复制
create database `test02` character set utf8mb4 collate utf8mb4_general_ci;

CREATE TABLE `sys_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(32) NOT NULL COMMENT '用户名',
  `password` varchar(128) NOT NULL COMMENT '密码',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4;

INSERT INTO `sys_user`(`id`, `username`, `password`) VALUES (1, 'test02', '1234');
INSERT INTO `sys_user`(`id`, `username`, `password`) VALUES (2, 'test02User', '1234');

2）配置

首先，maven依赖包不能忘记

代码语言：javascript
复制
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.2</version>
</dependency>

然后，我们需要在配置文件上配置上三个数据库的配置信息。

代码语言：javascript
复制
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?serverTimezone=Asia/Shanghai&allowMultiQueries=true
    username: root
    password: 1234

dynamic-datasource:
  test01:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test01?serverTimezone=Asia/Shanghai&allowMultiQueries=true
    username: root
    password: 1234
  test02:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test02?serverTimezone=Asia/Shanghai&allowMultiQueries=true
    username: root
    password: 1234

怎么配置不重要，清爽就好，重点在于读取。

我们需要读取上面配置文件的信息，配置生成SqlSessionTemplate、SqlSessionFactory、PlatformTransactionManager，如此来达到多数据源的功能

test数据库连接的相关配置

代码语言：javascript
复制
package com.banmoon.test.config.datasource;

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.boot.autoconfigure.jdbc.DataSourceProperties;
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 org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = {"com.banmoon.test.persistent.master.mapper"},
        sqlSessionFactoryRef = "masterSqlSessionFactory")
public class MasterDatasourceConfig {

    /**
     * 寻找配置文件中的数据源配置信息
     * @return
     */
    @Primary
    @Bean("masterDatasourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSourceProperties dataSourceProperties(){
        return new DataSourceProperties();
    }

    /**
     * 构建数据源
     * @param properties
     * @return
     */
    @Primary
    @Bean("masterDatasource")
    public DataSource dataSource(@Qualifier("masterDatasourceProperties") DataSourceProperties properties){
        DataSource build = DataSourceBuilder.create()
                .driverClassName(properties.getDriverClassName())
                .url(properties.getUrl())
                .username(properties.getUsername())
                .password(properties.getPassword())
                .build();
        return build;
    }

    /**
     * 构建事务管理器
     * @param dataSource
     * @return
     */
    @Primary
    @Bean(name = "masterTransactionManager")
    public PlatformTransactionManager dataSourceTransactionManager(@Qualifier("masterDatasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     * 构建sqlSession工厂
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "masterSqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(@Qualifier("masterDatasource") DataSource dataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);
        sessionFactoryBean.setTypeHandlersPackage("com.banmoon.test.persistent.master.entity");
        sessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/master/*.xml"));
        return sessionFactoryBean.getObject();
    }

    /**
     * 构建sqlSession
     * @param sqlSessionFactory
     * @return
     */
    @Primary
    @Bean(name = "masterSqlSessionTemplate")
    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("masterSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

test01数据库连接的相关配置

代码语言：javascript
复制
package com.banmoon.test.config.datasource;

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.boot.autoconfigure.jdbc.DataSourceProperties;
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 org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = {"com.banmoon.test.persistent.test01.mapper"},
        sqlSessionFactoryRef = "test01SqlSessionFactory")
public class Test01DatasourceConfig {

    @Bean("test01DatasourceProperties")
    @ConfigurationProperties(prefix = "dynamic-datasource.test01")
    public DataSourceProperties dataSourceProperties(){
        return new DataSourceProperties();
    }

    @Primary
    @Bean("test01Datasource")
    public DataSource dataSource(@Qualifier("test01DatasourceProperties") DataSourceProperties properties){
        DataSource build = DataSourceBuilder.create()
                .driverClassName(properties.getDriverClassName())
                .url(properties.getUrl())
                .username(properties.getUsername())
                .password(properties.getPassword())
                .build();
        return build;
    }

    @Primary
    @Bean(name = "test01TransactionManager")
    public PlatformTransactionManager dataSourceTransactionManager(@Qualifier("test01Datasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "test01SqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(@Qualifier("test01Datasource") DataSource dataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);
        sessionFactoryBean.setTypeHandlersPackage("com.banmoon.test.persistent.test01.entity");
        sessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/test01/*.xml"));
        return sessionFactoryBean.getObject();
    }

    @Primary
    @Bean(name = "test01SqlSessionTemplate")
    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("test01SqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

test02数据库连接的相关配置

代码语言：javascript
复制
package com.banmoon.test.config.datasource;

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.boot.autoconfigure.jdbc.DataSourceProperties;
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 org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = {"com.banmoon.test.persistent.test02.mapper"},
        sqlSessionFactoryRef = "test02SqlSessionFactory")
public class Test02DatasourceConfig {

    @Bean("test02DatasourceProperties")
    @ConfigurationProperties(prefix = "dynamic-datasource.test02")
    public DataSourceProperties dataSourceProperties(){
        return new DataSourceProperties();
    }

    @Primary
    @Bean("test02Datasource")
    public DataSource dataSource(@Qualifier("test02DatasourceProperties") DataSourceProperties properties){
        DataSource build = DataSourceBuilder.create()
                .driverClassName(properties.getDriverClassName())
                .url(properties.getUrl())
                .username(properties.getUsername())
                .password(properties.getPassword())
                .build();
        return build;
    }

    @Primary
    @Bean(name = "test02TransactionManager")
    public PlatformTransactionManager dataSourceTransactionManager(@Qualifier("test02Datasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "test02SqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(@Qualifier("test02Datasource") DataSource dataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);
        sessionFactoryBean.setTypeHandlersPackage("com.banmoon.test.persistent.test02.entity");
        sessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/test02/*.xml"));
        return sessionFactoryBean.getObject();
    }

    @Primary
    @Bean(name = "test02SqlSessionTemplate")
    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("test02SqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

还有一个需要注意，我们需要排除掉MybatisAutoConfiguration类，避免它自动进行配置

代码语言：javascript
复制
package com.banmoon.test;

import org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(exclude = MybatisAutoConfiguration.class)
public class TestApplication {

    public static void main(String[] args) {
        SpringApplication.run(TestApplication.class, args);
    }

}

配置完成，那么该如何去写Entity和Mapper呢？

请注意，在我们构建sqlSessionFactory的时候，就已经指定了它Entity的包路径和Mapper的包路径。

所以我只需要在指定的包路径在创建Entity和Mapper就可以了。

3）编写实体和Mapper

如下进行编写User.java、UserMapper.java、UserMapper.xml

代码语言：javascript
复制
package com.banmoon.test.persistent.master.entity;

import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    private Integer id;

    /**
     * 用户名
     */
    private String username;

    /**
     * 密码
     */
    private String password;

}
代码语言：javascript
复制
package com.banmoon.test.persistent.master.mapper;

import com.banmoon.test.persistent.master.entity.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface UserMapper {

    List<User> selectList();

}
代码语言：javascript
复制
<?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.banmoon.test.persistent.master.mapper.UserMapper">

    <!-- 通用查询映射结果 -->
    <resultMap id="BaseResultMap" type="com.banmoon.test.persistent.master.entity.User">
        <id column="id" property="id" />
        <result column="username" property="username" />
        <result column="password" property="password" />
    </resultMap>
    
    <select id="selectList" resultType="com.banmoon.test.persistent.master.entity.User">
        select * from sys_user
    </select>

</mapper>

由于演示的三个数据库，里面建的表结构都是一样的，这里就不再贴代码了，贴一个包路径结构

image-20220606214416229
image-20220606214416229
image-20220606214444285
image-20220606214444285

4）测试

以前我还很喜欢写Controller去进行测试，现在直接单元测试，直接进行调试了，简单快捷

代码语言：javascript
复制
package com.banmoon.test;

import com.banmoon.test.persistent.master.entity.User;
import com.banmoon.test.persistent.master.mapper.UserMapper;
import com.banmoon.test.persistent.test01.entity.Test01User;
import com.banmoon.test.persistent.test01.mapper.Test01UserMapper;
import com.banmoon.test.persistent.test02.entity.Test02User;
import com.banmoon.test.persistent.test02.mapper.Test02UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class ServiceTest {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private Test01UserMapper test01UserMapper;

    @Autowired
    private Test02UserMapper test02UserMapper;

    @Test
    void insertTest() {
        List<User> list = userMapper.selectList();
        list.forEach(System.out::println);

        System.out.println("============");
        List<Test01User> test01UserList = test01UserMapper.selectList();
        test01UserList.forEach(System.out::println);

        System.out.println("============");
        List<Test02User> test02UserList = test02UserMapper.selectList();
        test02UserList.forEach(System.out::println);
    }

}
image-20220606220338657
image-20220606220338657

三、MyBatis-Plus多数据源

1）自己配置

首先就是先写入maven依赖，这一点去官网可以查看到

代码语言：javascript
复制
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.1</version>
</dependency>

至于多数据源的配置，其实和上面差不多的，主要需要将SqlSessionFactory改成MyBatis-plus中的实现就可以了，如下

代码语言：javascript
复制
package com.banmoon.test.config.datasource;

import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
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 org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = {"com.banmoon.test.persistent.master.mapper"},
        sqlSessionFactoryRef = "masterSqlSessionFactory")
public class MasterDatasourceConfig {

    /**
     * 寻找配置文件中的数据源配置信息
     * @return
     */
    @Primary
    @Bean("masterDatasourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSourceProperties dataSourceProperties(){
        return new DataSourceProperties();
    }

    /**
     * 构建数据源
     * @param properties
     * @return
     */
    @Primary
    @Bean("masterDatasource")
    public DataSource dataSource(@Qualifier("masterDatasourceProperties") DataSourceProperties properties){
        DataSource build = DataSourceBuilder.create()
                .driverClassName(properties.getDriverClassName())
                .url(properties.getUrl())
                .username(properties.getUsername())
                .password(properties.getPassword())
                .build();
        return build;
    }

    /**
     * 构建事务管理器
     * @param dataSource
     * @return
     */
    @Primary
    @Bean(name = "masterTransactionManager")
    public PlatformTransactionManager dataSourceTransactionManager(@Qualifier("masterDatasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     * 构建sqlSession工厂
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "masterSqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(@Qualifier("masterDatasource") DataSource dataSource) throws Exception {
        // 修改为mp的SqlSessionFactoryBean
        final MybatisSqlSessionFactoryBean sessionFactoryBean = new MybatisSqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);
        sessionFactoryBean.setTypeHandlersPackage("com.banmoon.test.persistent.master.entity");
        sessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/master/*.xml"));
        return sessionFactoryBean.getObject();
    }

    /**
     * 构建sqlSession
     * @param sqlSessionFactory
     * @return
     */
    @Primary
    @Bean(name = "masterSqlSessionTemplate")
    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("masterSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

注意一下，由于只需要引入MyBatis-plus，所以启动类上的排除的类，已经可以不需要了

代码语言：javascript
复制
package com.banmoon.test;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class TestApplication {

    public static void main(String[] args) {
        SpringApplication.run(TestApplication.class, args);
    }

}

其他都差不多，是由代码生成器生成的Entity和Mapper，这里就不贴了，直接翻官网文档吧，里面很详细

上代码测试一下吧，其实和之前差不多，只是使用到的是MyBatis-plus中的方法

代码语言：javascript
复制
package com.banmoon.test;

import com.banmoon.test.persistent.master.entity.User;
import com.banmoon.test.persistent.master.mapper.UserMapper;
import com.banmoon.test.persistent.test01.entity.Test01User;
import com.banmoon.test.persistent.test01.mapper.Test01UserMapper;
import com.banmoon.test.persistent.test02.entity.Test02User;
import com.banmoon.test.persistent.test02.mapper.Test02UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class ServiceTest {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private Test01UserMapper test01UserMapper;

    @Autowired
    private Test02UserMapper test02UserMapper;

    @Test
    void insertTest() {
        List<User> list = userMapper.selectList(null);
        list.forEach(System.out::println);

        System.out.println("============");
        List<Test01User> test01UserList = test01UserMapper.selectList(null);
        test01UserList.forEach(System.out::println);

        System.out.println("============");
        List<Test02User> test02UserList = test02UserMapper.selectList(null);
        test02UserList.forEach(System.out::println);
    }

}
image-20220607095738103
image-20220607095738103

2）官方插件

在MyBatis-Plus中，有一个多数据源启动器，它可以做到以下这些功能

  • 支持 数据源分组 ，适用于多种场景 纯粹多库 读写分离 一主多从 混合模式。
  • 支持数据库敏感配置信息 加密 ENC()。
  • 支持每个数据库独立初始化表结构schema和数据库database。
  • 支持无数据源启动，支持懒加载数据源（需要的时候再创建连接）。
  • 支持 自定义注解 ，需继承DS(3.2.0+)。
  • 提供并简化对Druid，HikariCp，BeeCp,Dbcp2的快速集成。
  • 提供对Mybatis-Plus，Quartz，ShardingJdbc，P6sy，Jndi等组件的集成方案。
  • 提供 自定义数据源来源 方案（如全从数据库加载）。
  • 提供项目启动后 动态增加移除数据源 方案。
  • 提供Mybatis环境下的 纯读写分离 方案。
  • 提供使用 spel动态参数 解析数据源方案。内置spel，session，header，支持自定义。
  • 支持 多层数据源嵌套切换 。（ServiceA >>> ServiceB >>> ServiceC）。
  • 提供 **基于seata的分布式事务方案。
  • 提供 本地多数据源事务方案。

具体还是看官网文档吧，已经写的十分详细了，建议使用！！！

四、最后

虽然最近暂时没有此类的需求，但提前先记录测试一波，免得到时候手忙脚乱。

哦对，现在的确很少使用原生的MyBatis了，最近都是在使用MyBatis-plus。

这是一个好框架，十分好用，建议学习，直接使用。

我是半月，祝你幸福！！！

本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2022-06-06，如有侵权请联系 cloudcommunity@tencent.com 删除
数据库
sql
腾讯云测试服务
mybatis
maven

本文分享自 作者个人站点/博客 前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

数据库
sql
腾讯云测试服务
mybatis
maven
评论
登录后参与评论
0 条评论
热度
最新
登录 后参与评论
推荐阅读
LV.
文章
0
获赞
0
目录
  • SpringBoot整合MyBatis多数据源
    • 一、介绍
      • 二、配置
        • 1）数据库准备
        • 2）配置
        • 3）编写实体和Mapper
        • 4）测试
      • 三、MyBatis-Plus多数据源
        • 1）自己配置
        • 2）官方插件
      • 四、最后
      相关产品与服务
      数据库
      云数据库为企业提供了完善的关系型数据库、非关系型数据库、分析型数据库和数据库生态工具。您可以通过产品选择和组合搭建，轻松实现高可靠、高可用性、高性能等数据库需求。云数据库服务也可大幅减少您的运维工作量，更专注于业务发展，让企业一站式享受数据上云及分布式架构的技术红利！
      产品介绍
      领券

      腾讯云开发者

      扫码关注腾讯云开发者

      扫码关注腾讯云开发者

      领取腾讯云代金券

      热门产品

      热门推荐

      更多推荐

      Copyright © 2013 - 2024 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

      深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

      腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

      问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

      Copyright © 2013 - 2024 Tencent Cloud.

      All Rights Reserved. 腾讯云 版权所有

      登录 后参与评论