mybatis-plus整合多数据源案例

最新推荐文章于 2024-08-07 18:30:28 发布

夏木炎

最新推荐文章于 2024-08-07 18:30:28 发布

阅读量396

点赞数

文章标签： mybatis java mysql

本文链接：https://blog.csdn.net/xm393392625/article/details/130038433

版权

该配置展示了如何在SpringBoot应用中配置多个数据源（如feeControlDataSource和calculateDataSource），使用HikariDataSource作为连接池，并集成mybatis-plus进行数据库操作。同时，文章还详细说明了如何自定义mybatis-plus配置，包括日志、驼峰命名转换等，并通过AOP实现数据源的动态切换。

摘要由CSDN通过智能技术生成

一、配置多数据源和mybatis-plus

server:
  port: 20030
spring:
  application:
    name: calculate
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    type: com.zaxxer.hikari.HikariDataSource
    # hikari 连接池
    hikari:
      feecontrol:
        jdbc-url: jdbc:mysql://192.168.1.100:8066/yb_platform_feecontrol?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&autoReconnect=true
        username: feecontrol
        password: kingseok888
      calculate:
        jdbc-url: jdbc:mysql://192.168.1.100:3306/yb_platform_calculate?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&autoReconnect=true
        username: root
        password: root

### mybatis-plus config
mybatis-plus:
  # MyBaits 别名包扫描路径，通过该属性可以给包中的类注册别名
  type-aliases-package: com.ks.feecontrol.pojo.model.*
  # 该配置请和 typeAliasesPackage 一起使用，如果配置了该属性，则仅仅会扫描路径下以该类作为父类的域对象 。
  type-aliases-super-type: java.lang.Object
  configuration:
    # 这个配置会将执行的sql打印出来，在开发或测试的时候可以用
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    # 驼峰下划线转换
    map-underscore-to-camel-case: true
    # 配置的缓存的全局开关
    cache-enabled: true
    # 延时加载的开关
    lazy-loading-enabled: true
    # 开启的话，延时加载一个属性时会加载该对象全部属性，否则按需加载属性
    multiple-result-sets-enabled: true
    use-generated-keys: true
    default-statement-timeout: 60
    default-fetch-size: 100

二、配置自定义mp

package com.ks.config;

import com.baomidou.mybatisplus.autoconfigure.ConfigurationCustomizer;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.extension.MybatisMapWrapperFactory;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PerformanceInterceptor;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import com.ks.config.db.DBTypeEnum;
import com.ks.config.db.DynamicDataSource;
import com.zaxxer.hikari.HikariDataSource;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.spring.annotation.MapperScan;
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 org.springframework.context.annotation.Profile;
import org.springframework.transaction.annotation.EnableTransactionManagement;

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

/**
 * @author Mr.Zheng
 * @program: ks-platform
 * @description: Mp 配置类
 * @date 2020-05-26 14:28
 */
@Configuration
@MapperScan("com.ks.mapper.*")
@EnableTransactionManagement
public class MybatisPlusConfig {
    /**
     * 性能分析拦截器，不建议生产使用 用来观察 SQL 执行情况及执行时长, 默认dev,staging 环境开启
     * @return PerformanceInterceptor;
     */
    @Bean
    @Profile({"dev", "staging"})
    public PerformanceInterceptor performanceInterceptor(){

        //启用性能分析插件, SQL是否格式化 默认false,此处开启
        return new PerformanceInterceptor().setFormat(true);
    }

    @Bean(name = "feeControlDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.hikari.feecontrol")
    public DataSource feeControlDataSource() {
        return new HikariDataSource();
    }

    @Bean(name = "calculateDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.hikari.calculate")
    public DataSource calculateDataSource() {
        return new HikariDataSource();
    }

    @Bean
    @Primary
    public DataSource multipleDataSource (@Qualifier("feeControlDataSource") DataSource db1,
                                          @Qualifier("calculateDataSource") DataSource db2 ) {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        Map< Object, Object > targetDataSources = new HashMap<>(4);
        targetDataSources.put(DBTypeEnum.feeControlDataSource.getValue(), db1 );
        targetDataSources.put(DBTypeEnum.calculateDataSource.getValue(), db2);
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.setDefaultTargetDataSource(db1);
        return dynamicDataSource;
    }

    @Bean("sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();
        sqlSessionFactory.setDataSource(multipleDataSource(feeControlDataSource(), calculateDataSource()));
        MybatisConfiguration configuration = new MybatisConfiguration();
        configuration.setJdbcTypeForNull(JdbcType.NULL);
        configuration.setMapUnderscoreToCamelCase(false);
        configuration.setCacheEnabled(false);
        sqlSessionFactory.setConfiguration(configuration);
        //添加分页功能
        sqlSessionFactory.setPlugins(new Interceptor[]{
                paginationInterceptor()
        });
        return sqlSessionFactory.getObject();
    }

    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }

    @Bean
    public ConfigurationCustomizer mybatisConfigurationCustomizer() {
        return configuration -> configuration.setObjectWrapperFactory(new MybatisMapWrapperFactory());
    }

}

三、配置动态切换数据源

package com.ks.config.db;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * @author Mr.Zheng
 * @Program: hospital_parent
 * @Description: AOP实现的数据源切换
 * @date 2020-05-25 21:40
 */
@Component
@Order(value = -100)
@Slf4j
@Aspect
public class DataSourceSwitchAspect {
    @Pointcut("execution(* com.*.mapper.feecontrol..*.*(..))")
    private void feeControlAspect() {
    }

    @Pointcut("execution(* com.*.mapper.calculate..*.*(..))")
    private void calculateAspect() {
    }

    @Before("feeControlAspect()")
    public void feeControl() {
        log.info("Switch to feeControl data source...");
        DbContextHolder.setDbType(DBTypeEnum.feeControlDataSource);
    }

    @Before("calculateAspect()")
    public void calculate() {
        log.info("Switch to calculate data source...");
        DbContextHolder.setDbType(DBTypeEnum.calculateDataSource);
    }
}

package com.ks.config.db;

/**
 * @author Mr.Zheng
 * @Program: hospital_parent
 * @Description: 设置、获取数据源
 * @date 2020-05-25 21:29
 */
public class DbContextHolder {
    private static final ThreadLocal CONTEXT_HOLDER = new ThreadLocal<>();
    /**
     * 设置数据源
     * @param dbTypeEnum
     */
    public static void setDbType(DBTypeEnum dbTypeEnum) {
        CONTEXT_HOLDER.set(dbTypeEnum.getValue());
    }

    /**
     * 取得当前数据源
     * @return String
     */
    public static String getDbType() {
        return (String) CONTEXT_HOLDER.get();
    }

    /**
     * 清除上下文数据
     */
    public static void clearDbType() {
        CONTEXT_HOLDER.remove();
    }
}

package com.ks.config.db;

/**
 * @author Mr.Zheng
 * @program: ks-platform
 * @description:
 * @date 2020-06-20 11:02
 */
public enum DBTypeEnum {
    /**
     * 多数据源枚举
     */
    feeControlDataSource("feeControlDataSource"),
    calculateDataSource("calculateDataSource");
    private String value;

    DBTypeEnum(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

package com.ks.config.db;

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

/**
 * @author Mr.Zheng
 * @Program: hospital_parent
 * @Description: 动态数据源决策
 * @date 2020-05-25 21:28
 */
public class DynamicDataSource  extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return  DbContextHolder.getDbType();
    }
}