SpringBoot2.x+MybatisPlus+HikariCP多数据源动态配置

最新推荐文章于 2023-09-27 15:43:08 发布
最新推荐文章于 2023-09-27 15:43:08 发布
阅读量1k 收藏 2
点赞数
分类专栏： java springboot 文章标签： mybatis java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wm9028/article/details/126291229
版权

SpringBoot2.x+MybatisPlus+HikariCP多数据源动态配置

环境
SpringBoot 2.7.0
MybatisPlus 3.5.2
项目源码地址

一、准备工作

准备三个数据库 testdb testdb1 testdb2

类似主服务器 、从服务器、从服务器

创建一个user表

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
                        `id` int NOT NULL AUTO_INCREMENT,
                        `name` varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL,
                        `create_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
                        PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

-- ----------------------------
-- Records of user
-- ----------------------------
BEGIN;
INSERT INTO `user` (`id`, `name`, `create_time`) VALUES (1, '小明', '2022-08-11 14:54:51');
COMMIT;

SET FOREIGN_KEY_CHECKS = 1;

然后每个数据库插入不同的数据，方便区分是否成功。

# testdb
INSERT INTO `user` (`id`, `name`, `create_time`) VALUES (1, '小明', '2022-08-11 14:54:51');
# testdb1
INSERT INTO `user` (`id`, `name`, `create_time`) VALUES (1, '小明1', '2022-08-11 14:54:51');
# testdb2
INSERT INTO `user` (`id`, `name`, `create_time`) VALUES (1, '小明2', '2022-08-11 14:54:51');

Springboot项目开始

新建一个Springboot项目，可以使用start.spring.io或者idea创建项目。

项目目录如下：
在这里插入图片描述
pom.xml 文件

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>
数据源路由器

AbstractRoutingDatasource 需要知道要路由到哪个实际 DataSource 的信息。该信息通常称为上下文。在示例中，我们将使用 DBTypeEnum 的概念作为我们的上下文，并具有以下实现：
DBTypeEnum.java

public enum DBTypeEnum {
    MAIN, CLIENT_A, CLIENT_B;
}

新建一个 DBContextHolder.java

package com.wumeng.dynamicmultidatabase.config;

/**
 * @author wumeng 2022/8/11 3:02 下午
 */
public class DBContextHolder {
    private static final ThreadLocal<DBTypeEnum> contextHolder = new ThreadLocal<>();

    public static void setCurrentDb(DBTypeEnum dbType) {
        contextHolder.set(dbType);
    }

    public static DBTypeEnum getCurrentDb() {
        return contextHolder.get();
    }

    public static void clear() {
        contextHolder.remove();
    }
}

MultiRoutingDataSource.java

package com.wumeng.dynamicmultidatabase.config;

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

/**
 * @author wumeng 2022/8/11 3:03 下午
 */
public class MultiRoutingDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DBContextHolder.getCurrentDb();
    }
}

配置文件 PersistenceConfiguration.java

package com.wumeng.dynamicmultidatabase.config;

import com.zaxxer.hikari.HikariDataSource;
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 javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 * @author wumeng 2022/8/11 3:13 下午
 */

@Configuration
//@Component
public class PersistenceConfiguration {

//    @Primary
    @Bean(name = "mainDataSource")
    @ConfigurationProperties("app.datasource.main")
    public DataSource mainDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Bean(name = "clientADataSource")
    @ConfigurationProperties("app.datasource.clienta")
    public DataSource clientADataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Bean(name = "clientBDataSource")
    @ConfigurationProperties("app.datasource.clientb")
    public DataSource clientBDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Primary
    @Bean(name = "multiRoutingDataSource")
    public DataSource multiRoutingDataSource() {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DBTypeEnum.MAIN, mainDataSource());
        targetDataSources.put(DBTypeEnum.CLIENT_A, clientADataSource());
        targetDataSources.put(DBTypeEnum.CLIENT_B, clientBDataSource());
        MultiRoutingDataSource multiRoutingDataSource = new MultiRoutingDataSource();
        multiRoutingDataSource.setDefaultTargetDataSource(mainDataSource());
        multiRoutingDataSource.setTargetDataSources(targetDataSources);
        return multiRoutingDataSource;
    }

}
application.properties
server.port=8081

# mapper
mybatis.mapper-locations=classpath:mapper/*Mapper.xml
# 数据库下划线自动转驼峰标示关闭
mybatis-plus.configuration.map-underscore-to-camel-case=true
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

logging.level.com.wumeng.service.modules.report.dao=error


app.datasource.main.driver-class-name=com.mysql.cj.jdbc.Driver
app.datasource.main.jdbc-url=jdbc:mysql://localhost:3306/testdb?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
app.datasource.main.username=root
app.datasource.main.password=12345678


app.datasource.clienta.driver-class-name=com.mysql.cj.jdbc.Driver
app.datasource.clienta.jdbc-url=jdbc:mysql://localhost:3306/testdb1?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
app.datasource.clienta.username=root
app.datasource.clienta.password=12345678


app.datasource.clientb.driver-class-name=com.mysql.cj.jdbc.Driver
app.datasource.clientb.jdbc-url=jdbc:mysql://localhost:3306/testdb1?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
app.datasource.clientb.username=root
app.datasource.clientb.password=12345678

Mybatis 实体类代码

/modules/user/dao/user.java

package com.wumeng.dynamicmultidatabase.modules.user.dao;

import lombok.Data;

import java.sql.Timestamp;

/**
 * @author wumeng 2022/6/8 4:49 下午
 */
@Data
public class User {
    private Integer id;
    private String name;
    private Timestamp create_time;
}

UserMapper.java

package com.wumeng.dynamicmultidatabase.modules.user.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.wumeng.dynamicmultidatabase.modules.user.dao.User;
import org.apache.ibatis.annotations.*;
import org.springframework.stereotype.Component;

import java.sql.Timestamp;
import java.util.Map;


/**
 * @author wumeng 2022/6/8 5:18 下午
 */
@Component
public interface UserMapper extends BaseMapper<User> {
    @Insert("insert into User(id,name,create_time) values(#{id},#{name},#{create_time})")
    int add(User User);

    @Update("update User set name=#{name},create_time=#{create_time} where id=#{id}")
    int update(User User);

    //@Delete("delete from User where sno=#{sno}")
    void deleteById(int id);

    @Select("select * from User where id=#{id}")
    @Results(id = "User",value= {
            @Result(property = "id", column = "id", javaType = int.class),
            @Result(property = "name", column = "name", javaType = String.class),
            @Result(property = "create_time", column = "create_time", javaType = Timestamp.class)
    })
    User queryUserById(int id);

    User queryUserByState(String state);

    Map<String,Object> getDynamicUser(String tableName,String columns);

}

UserService.java

package com.wumeng.dynamicmultidatabase.modules.user.service;

import com.wumeng.dynamicmultidatabase.modules.user.dao.User;

/**
 * @author wumeng 2022/6/8 5:23 下午
 */
public interface UserService {
    int add(User user);
    int update(User user);
    void deleteById(int id);
    User queryUserById(int id);
}

UserServiceImpl.java

package com.wumeng.dynamicmultidatabase.modules.user.service.impl;

import com.wumeng.dynamicmultidatabase.modules.user.dao.User;
import com.wumeng.dynamicmultidatabase.modules.user.mapper.UserMapper;
import com.wumeng.dynamicmultidatabase.modules.user.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;


@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public int add(User user) {
        return userMapper.add(user);
    }

    @Override
    public int update(User user) {
        return userMapper.update(user);
    }

    @Override
    public void deleteById(int id) {
        userMapper.deleteById(id);
    }

    @Override
    public User queryUserById(int id) {
        return userMapper.queryUserById(id);
    }
}

UserMapper.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.wumeng.dynamicmultidatabase.modules.user.mapper.UserMapper">

    <select id="deleteById" parameterType="java.lang.String">
        delete from student where id = #{id}
    </select>

    <select id="queryUserByState" resultType="java.util.List">
        SELECT * FROM User
        <where>
            <if test="state != null">
                and state = #{state}
            </if>
        </where>
    </select>

    <select id="getDynamicUser" resultType="java.util.Map" parameterType="java.lang.String" statementType="STATEMENT">
        select
            ${columns}
        from ${tableName}
    </select>


</mapper>

UserController.java接口

package com.wumeng.dynamicmultidatabase.modules.user.controller;

import com.wumeng.dynamicmultidatabase.config.DBContextHolder;
import com.wumeng.dynamicmultidatabase.config.DBTypeEnum;
import com.wumeng.dynamicmultidatabase.modules.user.dao.User;
import com.wumeng.dynamicmultidatabase.modules.user.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.sql.Timestamp;


/**
 * @author wumeng 2022/6/8 4:35 下午
 */
@RestController
@RequestMapping("/user")
public class UserController {

    private Logger logger = LoggerFactory.getLogger(this.getClass());


    @Autowired
    private UserService userService;

    // query_user?id=1 -> main DB
    // query_user?id=1&client=client-a -> Client A DB
    // query_user?id=1&client=client-b -> Client B DB
    @RequestMapping(value = "/query_user", method = RequestMethod.GET)
    public User queryUserById(int id, String client) {

        switch (client) {
            case "client-a":
                DBContextHolder.setCurrentDb(DBTypeEnum.CLIENT_A);
                break;
            case "client-b":
                DBContextHolder.setCurrentDb(DBTypeEnum.CLIENT_B);
                break;
        }
        logger.info("查询id = " + id + " client = " + client);
        return this.userService.queryUserById(id);
    }

    @RequestMapping(value = "/deleteUser", method = RequestMethod.GET)
    public String deleteUserById(int id, String client) {
        switch (client) {
            case "client-a":
                DBContextHolder.setCurrentDb(DBTypeEnum.CLIENT_A);
                break;
            case "client-b":
                DBContextHolder.setCurrentDb(DBTypeEnum.CLIENT_B);
                break;
        }
        this.userService.deleteById(id);
        logger.info("删除id" + id);
        return "删除成功";
    }

    @GetMapping("/addUser/{id}")
    public String addUser(@PathVariable(value = "id") Integer id, @RequestParam(value = "name") String name, @RequestParam(value = "client") String client) {

        switch (client) {
            case "client-a":
                DBContextHolder.setCurrentDb(DBTypeEnum.CLIENT_A);
                break;
            case "client-b":
                DBContextHolder.setCurrentDb(DBTypeEnum.CLIENT_B);
                break;
        }
        User user = new User();
        user.setName(name);
        user.setCreate_time(new Timestamp(System.currentTimeMillis()));
        int addCode = this.userService.add(user);
        logger.info("id " + id + "add code " + addCode);
        return "添加成功";
    }


}

运行项目，调用接口，就可以查看变化了。

http://localhost:8081/user/query_user?id=1&client=

{"id":1,"name":"小明","create_time":"2022-08-11T14:54:51.000+00:00"}

http://localhost:8081/user/query_user?id=1&client=client-a

{"id":1,"name":"小明1","create_time":"2022-08-11T14:54:51.000+00:00"}

http://localhost:8081/user/query_user?id=1&client=client-b

{"id":1,"name":"小明2","create_time":"2022-08-11T14:54:51.000+00:00"}
WMSmile
关注
专栏目录
Springboot + HikariCp + MybatisPlus多数据源配置 （1）
weixin_44215595的博客
09-29 5979
概述 以前一直用的druid，最近想换hikari了，因为druid的监控多数情况我用不到，hikari的速度更能让我满意 项目架构 项目依赖 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <proj...
Springboot + HikariCp + MybatisPlus多数据源配置 注解切换数据源 （2）
weixin_44215595的博客
09-29 3505
多数据源实现请参考上文 Springboot + HikariCp + MybatisPlus多数据源配置 （1） 由于手动切换在我看来并不优雅，但他最主要的是能够让我少写点代码。所以出现了Aop 首先引入aop依赖 <dependency> <groupId>org.springframework.boot</groupId> ...
springboot + mybatis(通用mapper) + HikariCP（比durid更快）多数据源
04-02
springboot + mybatis(通用mapper) + HikariCP（比durid更快）多数据源，从此单表的xml文件和crud就不需要自己写了
springboot+MybatisPlus+HikariCP多数据源动态配置（实战篇）
Hello-huang
03-10 5298
最近做的系统有很多个数据源，所以我研究了一下Mybatis多数据源的配置，Springboot 2.x.x.RELEASE 版本之后连接池只要你不配置默认就是HikariCP，被称为最快速的连接池。由于这个项目不需要使用到Druid的监控，所以我使用HikariCP数据库连接池，需要用到aop动态切换，话不多说，上代码了。 pom.xml大概要使用的包，仅供参考，我也需要自动生成代码所以也会有MybatisPlus的包 yml文件的配置： 创建类MybatisPlusConfig，配置注入数据源
springboot mybatis-plus 多数据源配置(HikariCP)
qiaobing1226的博客
07-22 1666
springboot mybatis-plus 多数据源配置
springboot+Mybatis(MybatisPlus)+HikariCP多数据源动态配置(三个数据源)
dfBeautifulLive的博客
09-04 3388
我们新做的系统可能是很多个数据源，所以我闲来无事研究一下Mybatis多数据源的配置，然后连接池只要你不配置默认就是HikariCP，被称为最快速的连接池。所以我们使用HikariCP数据库连接池，需要用到aop动态切换，话不多说，上代码了。 1.pom.xml大概要使用的包，仅供参考，我也需要自动生成代码所以也会有MybatisPlus的包 <!-- ####...
springboot+mybatisplus+mysql 多数据源
最新发布
10-27
综上所述，"springboot+mybatisplus+mysql 多数据源"项目涵盖了Spring Boot的快速开发特性、MyBatisPlus的简便操作数据库能力，以及实现多数据源和动态数据源切换的高级技术。开发者可以通过这个示例学习如何在实际...
详解springboot+mybatis多数据源最简解决方案
08-30
然而，这两种方法都有其缺陷，例如JPA需要使用复杂的配置文件，而Spring框架自带的多数据源解决方案又需要使用AOP动态切换数据源，感觉都有点小复杂。 因此，我们需要一个简单的多数据源解决方案来解决这个问题。本...
springBoot2 多数据源配置Hikari + MybatisPlus
weixin_43344648的博客
04-25 2179
环境：springBoot2.4.5 IDEA 数据库：Mysql8.0.21 主要任务：多数据源配置Hikari + MybatisPlus 项目结构 注意要点 两个数据源的mapperScan目录一定要分开，否则就会出现数据源1中的表去数据源2数据库中查询的情况 原因：在mapperScan的过程中会把扫描到的类归属于正在配置的某一个数据源，而不会智那区分 application.yml配置 spring: datasource: user: jdbc-url: jdbc:my
Hikari数据源配置及说明.md
12-09
Hikari连接池是Spring Boot 2.0+默认也是官方推荐的连接池，其卓越的性能，更适合高并发下的业务场景。
Spring Boot 2.7.5 HikariCP 连接池多数据源配置
热门推荐
换条路吧，编程没意思的~
12-22 1万+
Springboot 2.7.5多数据源配置
数据源HikariCP（多数据库的配置项）
weixin_34126215的博客
11-20 907
oracle.jdbc.type=oracle oracle.jdbc.driver=oracle.jdbc.OracleDriver oracle.jdbc.url=jdbc:oracle:thin:@[ip]:[port]:[dbdomain] oracle.jdbc.username=[username] oracle.jdbc.password=[password] pi.isUsed...
SpringBoot整合(五)HikariCP、Druid数据库连接池—多数据源配置
qq_44665283的博客
02-27 1万+
SpringBoot整合(五)HikariCP、Druid数据库连接池—多数据源配置
springboot+mybatis-plus+hikari多数据源配置
weixin_45658376的博客
10-26 3551
.ymal文件针对mysql举例 # database spring: application: name: dipper-web flyway: enabled: false datasource: portal: driver-class-name: com.mysql.jdbc.Driver type: com.zaxxer.hikari.HikariDataSource jdbc-url: jdbc:mysql:########
32位数据源中没有mysql_Spring Boot+MyBatis 动态数据源切换、多数据源，读写分离
weixin_39970823的博客
11-26 173
作 者：呜呜呜啦啦啦来 源：blog.csdn.net/u013360850广而告之：由于此订阅号换了个皮肤，系统自动取消了读者的公众号置顶。导致用户接受文章不及时。可以打开订阅号，选择置顶(标星)公众号，重磅干货，第一时间送达！本项目使用 Spring Boot 和 MyBatis 实现多数据源，动态数据源的切换；有多种不同的实现方式，在学习的过程中发现没有文章将这些方式和常见的问题集中处理，所...
SpringBoot集成MyBatis Plus，使用HikariCP连接池
Crazy_young_man的博客
04-26 6267
我这里用到了lombok中的几个注解 1. 准备一个基础的Spring Boot项目 创建一个简单的SpringBoot项目你应该是没有问题的吧？如果不会请移步https://www.yuanmen.top/pages/view.html?id=33 2. pom.xml添加依赖 <!-- Lombok --> <dependency> <groupId>...
SpringBoot+Hirika 实现动态数据源
Shy的博客
02-12 830
1、实现原理 AbstractRoutingDataSource中，determineTargetDataSource 方法通过数据源的标识获取当前数据源；determineCurrentLookupKey方法则是获取数据源标识，实现动态切换数据源，需要实现determineCurrentLookupKey方法，动态提供数据源标识即可。这边使用AOP识别方法上的注解进行数据源切换。没用注解使用默认...
springboot2配置hikari多数据源(postgres版)
小万是个程序员
09-27 1124
#springboot2配置hikari多数据源(postgres版)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WMSmile

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值