Spring+MybatisPlus实现多数据源

最新推荐文章于 2024-08-07 18:30:28 发布
最新推荐文章于 2024-08-07 18:30:28 发布
阅读量125 收藏
点赞数
文章标签： java 数据库 python
原文链接：https://my.oschina.net/TonyTaotao/blog/2980518
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

DatasourceConfig 

package com.tonytaotao.dtsc.common.configuration.datasouce.normal; 

import com.alibaba.druid.pool.DruidDataSource; 
import com.tonytaotao.dtsc.common.configuration.datasouce.DBTypeEnum; 
import com.tonytaotao.dtsc.common.configuration.datasouce.DynamicDataSource; 
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Primary; 
import javax.sql.DataSource; 
import java.util.HashMap; 
import java.util.Map; 

@Configuration 
public class DatasourceConfig { 

    /*------------------------------------------------- 普通多数据源----------------------------------------------*/ 
    @Bean("multipleDataSource") 
    @Primary 
    public DataSource multipleDataSource() { 
        DynamicDataSource dynamicDataSource = new DynamicDataSource(); 
        Map< Object, Object > targetDataSources = new HashMap<>(); 
        targetDataSources.put(DBTypeEnum.ONE.getCode(), createDataSourceOne()); 
        targetDataSources.put(DBTypeEnum.TWO.getCode(), createDataSourceTwo()); 
        dynamicDataSource.setTargetDataSources(targetDataSources); 
        dynamicDataSource.setDefaultTargetDataSource(createDataSourceOne()); 
        return dynamicDataSource; 
    } 


    private DataSource createDataSourceOne() { 
        DruidDataSource druidDataSource = createDataSourceBase(); 
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/dtsc?useSSL=false&useUnicode=true&allowPublicKeyRetrieval=true&characterEncoding=UTF8&serverTimezone=GMT"); 
        druidDataSource.setUsername("root"); 
        druidDataSource.setPassword("123456"); 
        return druidDataSource; 
    } 


    private DataSource createDataSourceTwo() { 
        DruidDataSource druidDataSource = createDataSourceBase(); 
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/dtsc_1?useSSL=false&useUnicode=true&allowPublicKeyRetrieval=true&characterEncoding=UTF8&serverTimezone=GMT"); 
        druidDataSource.setUsername("root"); 
        druidDataSource.setPassword("123456"); 
        return druidDataSource; 
    } 


    private DruidDataSource createDataSourceBase() { 
        DruidDataSource druidDataSource = new DruidDataSource(); 
        druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver"); 
        druidDataSource.setInitialSize(50); 
        druidDataSource.setMaxActive(100); 
        druidDataSource.setMinIdle(5); 
        druidDataSource.setMaxWait(1000); 
        druidDataSource.setPoolPreparedStatements(false); 
        druidDataSource.setMaxPoolPreparedStatementPerConnectionSize(-1); 
        druidDataSource.setValidationQuery("SELECT 1"); 
        druidDataSource.setValidationQueryTimeout(1); 
        druidDataSource.setTestOnBorrow(false); 
        druidDataSource.setTestOnReturn(false); 
        druidDataSource.setTestWhileIdle(true); 
        druidDataSource.setTimeBetweenEvictionRunsMillis(60000); 
        druidDataSource.setMinEvictableIdleTimeMillis(30000); 
        return druidDataSource; 
    } 

}

 MybatisPlusConfig

package com.tonytaotao.dtsc.common.configuration.datasouce.normal; 

import com.baomidou.mybatisplus.annotation.DbType; 
import com.baomidou.mybatisplus.annotation.FieldStrategy; 
import com.baomidou.mybatisplus.annotation.IdType; 
import com.baomidou.mybatisplus.core.MybatisConfiguration; 
import com.baomidou.mybatisplus.core.config.GlobalConfig; 
import com.baomidou.mybatisplus.extension.injector.LogicSqlInjector; 
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor; 
import com.baomidou.mybatisplus.extension.plugins.PerformanceInterceptor; 
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean; 
import org.springframework.beans.factory.annotation.Qualifier; 
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Profile; 
import org.springframework.core.io.support.PathMatchingResourcePatternResolver; 
import javax.sql.DataSource; 
import java.io.IOException; 

@Configuration 
@MapperScan({"com.tonytaotao.dtsc.*.mapper"}) 
public class MybatisPlusConfig { 

    /** 
    * 性能分析插件 
    * @return 
    */ 
    @Bean 
    @Profile({"dev","sit"}) 
    public PerformanceInterceptor performanceInterceptor() { 
        return new PerformanceInterceptor(); 
    } 

    /** 
    * 分页插件 
    * @return 
    */ 
    @Bean 
    public PaginationInterceptor paginationInterceptor() { 
        return new PaginationInterceptor(); 
    } 

    /** 
    * 
    * @return 
    */ 
    @Bean("sqlSessionFactory") 
    public MybatisSqlSessionFactoryBean sqlSessionFactory(@Qualifier("multipleDataSource") DataSource multipleDataSource) { 
        try { 
            MybatisSqlSessionFactoryBean sqlSessionFactoryBean = mybatisSqlSessionFactoryBean(); 
            sqlSessionFactoryBean.setDataSource(multipleDataSource); 
            return sqlSessionFactoryBean; 
        } catch (IOException e) { 
            e.printStackTrace(); 
            return null; 
        } 
    } 

    private MybatisSqlSessionFactoryBean mybatisSqlSessionFactoryBean() throws IOException{ 
        MybatisSqlSessionFactoryBean mybatisSqlSessionFactoryBean = new MybatisSqlSessionFactoryBean(); 
        mybatisSqlSessionFactoryBean.setGlobalConfig(globalConfig()); 
        mybatisSqlSessionFactoryBean.setConfiguration(mybatisConfiguration()); 
        mybatisSqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:com/tonytaotao/dtsc/*/mapper/xml/*Mapper.xml")); 
        mybatisSqlSessionFactoryBean.setTypeAliasesPackage("com.tonytaotao.dtsc.*.entity"); 
        return mybatisSqlSessionFactoryBean; 
    } 

    private GlobalConfig globalConfig() { 
        GlobalConfig globalConfig = new GlobalConfig(); 
        GlobalConfig.DbConfig dbConfig = new GlobalConfig.DbConfig(); 
        dbConfig.setIdType(IdType.AUTO); 
        dbConfig.setDbType(DbType.MYSQL); 
        dbConfig.setFieldStrategy(FieldStrategy.NOT_EMPTY); 
        dbConfig.setTableUnderline(true); 
        dbConfig.setLogicDeleteValue("0"); 
        dbConfig.setLogicNotDeleteValue("1"); 
        globalConfig.setDbConfig(dbConfig); 

        LogicSqlInjector logicSqlInjector = new LogicSqlInjector(); 
        globalConfig.setSqlInjector(logicSqlInjector); 
    
        return globalConfig; 
    } 

    private MybatisConfiguration mybatisConfiguration() { 
        MybatisConfiguration mybatisConfiguration = new MybatisConfiguration(); 
        // 源码里面如果有configuration, 不会注入BaseMapper 里面的方法, 所以这里要这样写 
        mybatisConfiguration.init(globalConfig()); 
        mybatisConfiguration.setMapUnderscoreToCamelCase(true); 
        mybatisConfiguration.setCacheEnabled(false); 
    
        return mybatisConfiguration; 
    } 

}

 TransationConfig

package com.tonytaotao.dtsc.common.configuration.datasouce.normal; 

import org.springframework.beans.factory.annotation.Qualifier; 
import org.springframework.jdbc.datasource.DataSourceTransactionManager; 

import javax.sql.DataSource; 

/** 
* @author wujintao 
* 
* Configuration 类似于spring 配置文件，负责注册bean 
* ComponentScan 注解类查找规则定义 <context:component-scan/> 
* EnableAspectJAutoProxy 激活Aspect 自动代理 <aop:aspectj-autoproxy/> 
* proxy-target-class : 默认为false 表示使用JDK 动态代理。如果实现了至少一个接口，Spring 会优先选择使用JDK 动态代理，若果没有实现任何接口，则spring 会选择CGLIB 动态代理，强制使用CGLIB 动态代理，使用以下配置 
* exposeProxy : springAOP 只会拦截public 方法，不会拦截provided 和private 方法，并且不会拦截public 方法内部调用的其他方法，也就是说只会拦截代理对象的方法，即增强的是代理对象，而不是原对象, 设置就可以暴露出代理对象，拦截器会获取代理对象，并且将代理对象转换成原对象。从而对内部调用的方法进行增强 
* EnableTransactionManagement 启用注解式事务管理 <tx:annotation-driven /> 
*/ 
@Configuration 
@EnableTransactionManagement 
@EnableAspectJAutoProxy(exposeProxy = true) 
public class TransationConfig { 

    //@Bean 
    public DataSourceTransactionManager dataSourceTransactionManager(@Qualifier("multipleDataSource") DataSource multipleDataSource) { 
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(); 
        transactionManager.setDataSource(multipleDataSource); 
        return transactionManager; 
    } 
}

  DBTypeEnum 

package com.tonytaotao.dtsc.common.configuration.datasouce; 

import lombok.Getter; 

public enum DBTypeEnum { 
    ONE("ONE", "db one"), 
    TWO("TWO", "db two"); 

    DBTypeEnum(String code, String msg) { 
        this.code = code; 
        this.msg = msg; 
    } 

    @Getter 
    private String code; 
    private String msg; 
}

 DBAnnotation 

package com.tonytaotao.dtsc.common.configuration.datasouce; 

import java.lang.annotation.ElementType; 
import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 
import java.lang.annotation.Target; 

@Retention(RetentionPolicy.RUNTIME) 
@Target(ElementType.METHOD) 
public @interface DBAnnotation { 
    DBTypeEnum dbSource() default DBTypeEnum.ONE; 
}

DBAspect 

package com.tonytaotao.dtsc.common.configuration.datasouce; 

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

import java.lang.reflect.Method; 

@Component 
@Aspect 
@Order(-100) 
@Slf4j 
public class DBAspect { 

    @Pointcut("execution(* com.tonytaotao.dtsc.*.service..*.*(..))") 
    private void pointcut() { 
    } 

    @Before("pointcut()") 
    public void before(JoinPoint joinPoint) { 
        Object target = joinPoint.getTarget(); 
        String methodName = joinPoint.getSignature().getName(); 
        Class<?> clazz = target.getClass(); 

        log.info("before [ class = {}, method = {} ] execute", clazz.getName(), methodName); 

        Class<?>[] parameterTypes = ((MethodSignature)joinPoint.getSignature()).getMethod().getParameterTypes(); 

        try { 

            Method method = clazz.getMethod(methodName, parameterTypes); 

            if (method != null) { 
                if (method.getDeclaringClass().isAnnotationPresent(DBAnnotation.class) && !method.isAnnotationPresent(DBAnnotation.class)) { 
                    DBAnnotation dbAnnotation = method.getDeclaringClass().getAnnotation(DBAnnotation.class); 
                    DBContextHolder.setDbType(dbAnnotation.dbSource()); 
                    log.info("[class = {}, method = {} ] 切换类级数据源 [ {} ] 成功", clazz.getName(), methodName, dbAnnotation.dbSource()); 
                } else if ( method.isAnnotationPresent(DBAnnotation.class)) { 
                    DBAnnotation dbAnnotation = method.getAnnotation(DBAnnotation.class); 
                    DBContextHolder.setDbType(dbAnnotation.dbSource()); 
                    log.info("[class = {}, method = {} ] 切换方法级数据源 [ {} ] 成功", clazz.getName(), methodName, dbAnnotation.dbSource()); 
                } else { 
                    DBContextHolder.setDbType(DBTypeEnum.ONE); 
                    log.info("[class = {}, method = {} ] 切换默认数据源 [ {} ] 成功", clazz.getName(), methodName, DBTypeEnum.ONE); 
                } 
            } 

            } catch (Exception e) { 
            log.error(" 数据源切换异常", e); 
        } 
    } 

}

 DBContextHolder 

package com.tonytaotao.dtsc.common.configuration.datasouce; 

public class DBContextHolder { 

    private static final ThreadLocal contextHolder = new ThreadLocal<>(); 

    /** 
    * 设置数据源 
    * @param dbTypeEnum 
    */ 
    public static void setDbType(DBTypeEnum dbTypeEnum) { 
        contextHolder.set(dbTypeEnum.getCode()); 
    } 

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

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

DynamicDataSource 

package com.tonytaotao.dtsc.common.configuration.datasouce; 

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

public class DynamicDataSource extends AbstractRoutingDataSource { 

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

 

使用方式

只要在 service 实现类的方法上或者类上加上 @DBAnnotation 指定数据源，就能实现自动切换数据源

 

转载于:https://my.oschina.net/TonyTaotao/blog/2980518

weixin_34130269
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot MyBatisPlus多数据源
weixin_45020617的博客
05-24 646
参考mybait-plus官方文档：https://baomidou.com/pages/a61e1b/#%E6%96%87%E6%A1%A3-documentation 引入pom依赖： 此处注意 还需要引入你的连接数据库的依赖 <dependency> <groupId>com.baomidou</groupId> <artifactId>dynamic-datasource-spring-boot-starter</artifact
Springboot+mybatisplus+多数据源
qq_43248715的博客
10-18 636
之前一篇讲了vue2.0的框架搭建，本篇主要讲后台使用springboot+mybatisplus. 在springboot项目中引入mybatisplus，需要在pom.xml加入 <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.4.1</version
springboot+Mybatisplus实现多数据源
12-12
springboot+Mybatisplus实现多数据源,使用aop切面自动切换多数据源！！加群：687942640
MyBatisPlus--多数据源
热门推荐
qq_45917176的博客
04-21 1万+
官网地址：多数据源 | MyBatis-Plus (baomidou.com) 支持 数据源分组 ，适用于多种场景、纯粹多库、读写分离、一主多从、混合模式。 目前来模拟一个纯粹多库的一个场景，其他场景类似；场景说明： 创建两个库，分别为：mybatis_plus与mybatis_plus_1，使每个库一张表，通过一个测试用例分别获取用户数据与商品数据，如果获取到说明多库模拟成功。 1、创建数据库及表 创建数据库mybatis_plus和表user CREATE DATABASE `mybatis_plu.
Mybatis Plus配置多数据源
最新发布
yanzigejuly的博客
08-07 2482
该项目主要描述了Mybatis Plus多数据源的配置和使用，其中详细记录的配置过程，整个过程从数据库表的创建到数据初始化都有详细的记录说明。另外，如果存在同一个表在多个数据源中都存在的情况，有一些注意事项，下面看文章通过例子说明。
Spring-boot+mybatis多数据源整合（动态切换数据源）
08-12
Spring-boot+mybatis多数据源整合（动态切换数据源）,亲测可用
SpringBoot配置MybatisPlus多数据源
Lyndon的专栏
12-31 2463
SpringBoot集成Mybatis实现Hirika数据源多数据库配置 master，second
springboot+mybatisplus+mysql 多数据源
10-27
本项目"springboot+mybatisplus+mysql 多数据源"是一个演示如何在Spring Boot框架下，结合MyBatisPlus和MySQL实现多数据源切换的示例。下面将详细解释其中涉及的关键技术点。 1. **Spring Boot**: Spring Boot是...
Spring+SpringMvc+MybatisPlus+Aop（自定义注解）动态切换数据源
12-25
本项目“Spring+SpringMvc+MybatisPlus+Aop（自定义注解）动态切换数据源”正是针对这一需求提供的一种解决方案。下面将详细介绍这个项目中的关键技术点和实现原理。 首先，Spring框架是Java企业级应用开发的核心...
阿里技术员：使用springboot + druid + mybatisplus完成多数据源配置
m0_68850571的博客
03-30 5807
一. 简介 　1. 版本 springboot版本为2.0.3.RELEASE，mybatisplus版本为2.1.9， druid版本为1.1.9，swagger版本为2.7.0 2.项目地址 　　该地址有初始sql和测试方法 　3. 留个记录，方便查找 　　　　开发步骤： 　　　　1. 新建springboot项目。 　　　　2. 导入依赖 --> devtools，lombok，web，thymeleaf，mysql，aop，mybatisplus，druid，swagger。
mybatis(plus)多数据源
myli92的博客
10-12 9469
一个项目大部分都是单一数据库多一些，但是有时候会需要用多个库，所以这时候据需要使用多数据源。我这里使用springboot+mybatis(plus)+druid多数据源.目前我知道有两种方式，一种方式是需要在service实现类上添加@DS，一种方式是通过配置的方式，配置不同的SqlSessionFactory实现。
MyBatisPlus多数据源
bowei的博客
03-19 215
重点： 1.数据源配置类上增加@MapperScan 2.SqlSessionFactory中的bean用mybatisplus中提供的 3.MapperLocations中的参数用以下方式转型
MybatisPlus多数据源
晶谛-giserDev
12-16 1078
MybatisPlus多数据源
Springboot 之 Mybatis-plus 多数据源
天行健，君子以自强不息；地势坤，君子以厚德载物。
09-28 1681
简介Mybatis-puls 多数据源的使用，采用的是官方提供的dynamic-datasource-spring-boot-starter包的 @DS 注解，具体可以参考官网：https://gitee.com/baomidou/dynamic-datasource-spring-boot-starterpom.xml文件引入如下依赖主要引入dynamic-datasource-spring-b...
MyBatisPlus ---- 多数据源
是微风，是晚霞，是无可替代
02-19 1029
适用于多种场景：纯粹多库、读写分离、一主多从、混合模式等目前我们就来模拟一个纯粹多库的一个场景，其他场景类似场景说明：我们创建两个库，分别为 mybatis_plus（以前的库不动）与 mybatis_plus_1（新建），将 mybatis_plus 库的 produce 表移动到 mybatis_plus_1 库，这样每个库一张表，通过一个测试用例分别获取用户数据与商品数据，如果获取到说明多库模拟成功。
MyBatis-Plus多数据源
tongxin_tongmeng的博客
04-07 582
在线文档、项目创建、数据库连接、数据表创建、代码生成、Mapper扫描、测试接口
mybatis-plus 多数据源
luck_sheng的博客
07-06 1648
Maven依赖: POM配置 Maven <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.1.16</version> </dependency> <!-- 多数据源 --> <dependency>
Mybatisplus-多数据源
weixin_55772633的博客
09-28 194
官网链接----->适用于多种场景:纯粹多库、 读写分离、 一主多从、 混合模式等 目前我们就来模拟一个纯粹多库的一个场景，其他场景类似场景说明:我们创建两个库，分别为:mybatis_plus(以前的库不动)与mybatis_plus_1(新建)，将 mybatis_plus库的product表移动到mybatis_plus_1库，这样每个库一张表，通过一个测试用例 分别获取用户数据与商品数据，如果获取到说明多库模拟成功。
MyBatisPlus之多数据源
沉淀、分享、成长，让自己和他人都能有所收获！
10-16 5622
dynamic-datasource-spring-boot-starter 是一个基于springboot的快速集成多数据源的启动器。
Springboot+mybatisplus多数据源配置mysql和postgresql
08-15
对于Spring Boot和MyBatis Plus多数据源配置MySQL和PostgreSQL，你可以按照以下步骤进行操作： 1. 首先，在你的Spring Boot项目中添加MySQL和PostgreSQL的依赖。在`pom.xml`文件中添加以下依赖： ```xml <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>org.postgresql</groupId> <artifactId>postgresql</artifactId> </dependency> ``` 2. 接下来，配置数据源。在`application.properties`或`application.yml`文件中添加以下配置： ```yaml # MySQL 数据源配置 spring.datasource.mysql.url=jdbc:mysql://localhost:3306/mysql_db spring.datasource.mysql.username=root spring.datasource.mysql.password=123456 # PostgreSQL 数据源配置 spring.datasource.postgresql.url=jdbc:postgresql://localhost:5432/postgresql_db spring.datasource.postgresql.username=postgres spring.datasource.postgresql.password=123456 ``` 3. 然后，创建数据源配置类。创建两个数据源的配置类，分别用于MySQL和PostgreSQL。例如，创建名为`MySQLDataSourceConfig`和`PostgreSQLDataSourceConfig`的类，并分别添加`@Configuration`和`@ConfigurationProperties`注解。 ```java @Configuration @ConfigurationProperties(prefix = "spring.datasource.mysql") public class MySQLDataSourceConfig { private String url; private String username; private String password; // 省略 getter 和 setter 方法 } ``` ```java @Configuration @ConfigurationProperties(prefix = "spring.datasource.postgresql") public class PostgreSQLDataSourceConfig { private String url; private String username; private String password; // 省略 getter 和 setter 方法 } ``` 4. 接下来，配置数据源。在`DataSourceConfig`类中，创建两个数据源的`DataSource`实例，并将它们注入到`SqlSessionFactory`中。 ```java @Configuration public class DataSourceConfig { @Bean(name = "mysqlDataSource") @ConfigurationProperties(prefix = "spring.datasource.mysql") public DataSource mysqlDataSource() { return DataSourceBuilder.create().build(); } @Bean(name = "postgresqlDataSource") @ConfigurationProperties(prefix = "spring.datasource.postgresql") public DataSource postgresqlDataSource() { return DataSourceBuilder.create().build(); } @Bean(name = "sqlSessionFactory") public SqlSessionFactory sqlSessionFactory(@Qualifier("mysqlDataSource") DataSource mysqlDataSource, @Qualifier("postgresqlDataSource") DataSource postgresqlDataSource) throws Exception { SqlSessionFactoryBean sessionFactory
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值