Springboot+Mybatis+Pagehelper+Aop动态配置Oracle、Mysql数据源

用公司新搭的maven脚手架创建springboot工程，因为脚手架功能未完善，创建出的工程主要就是引了springboot基础包并创建了目录结构，所以需要自己添加框架来搭建工程，也能通过这个过程来更深入了解相关框架，提升自己。
* springboot程序入口:TianlianModelServerApplication.java

package com.tianlian.server;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.EnableAspectJAutoProxy;

import org.springframework.context.annotation.ImportResource;

import org.springframework.context.annotation.PropertySource;

//因为用springboot默认的数据源只能配置一套，而我们需要从多个数据源来查询数据，

//因此用@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})来关闭自动配置功能。

@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})

//用@PropertySource来加载properties文件

@PropertySource(value={"classpath:dev/properties/dubbo.properties","classpath:dev/properties/mysql.properties","classpath:dev/properties/oracle.properties"})

//加载xml配置文件

@ImportResource(locations={"classpath:configs/dubbo-customers.xml","classpath:configs/dubbo-server.xml"})

@ComponentScan(basePackages = "com.tianlian.server")

//开启AOP代理自动配置

@EnableAspectJAutoProxy

public class TianlianModelServerApplication {

  public static void main(String[] args) {

    SpringApplication.run(TianlianModelServerApplication.class, args);

  }

}
  • 读取mysql配置:MySqlDataSourceConfig.java(OracleDataSourceConfig.java类似)
package com.tianlian.server.configs;

import lombok.Data;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.PropertySource;

import org.springframework.stereotype.Component;

/**

 *用@Value注解来给属性赋值，分别创建oracle数据源的bean、mysql数据源的bean,

 *并用@componen把bean交给spring管理，方便后面创建不同数据源时使用。

 */

@Data

@Component

public class MySqlDataSourceConfig {

  @Value("${mysql.jdbc.driverClassName}")

  private String driverClassName;

  @Value("${mysql.jdbc.url}")

  private String url;

  @Value("${mysql.jdbc.username}")

  private String username;

  @Value("${mysql.jdbc.password}")

  private String password;

  @Value("${mysql.jdbc.initialSize}")

  private Integer initialSize;

  @Value("${mysql.jdbc.maxActive}")

  private Integer maxActive;

  @Value("${mysql.jdbc.minPoolSize}")

  private Integer minPoolSize;

  @Value("${mysql.jdbc.maxWait}")

  private Long maxWait;

  @Value("${mysql.jdbc.minIdle}")

  private Integer minIdle;

  @Value("${mysql.jdbc.timeBetweenEvictionRunsMillis}")

  private Long timeBetweenEvictionRunsMillis;

  @Value("${mysql.jdbc.minEvictableIdleTimeMillis}")

  private Long minEvictableIdleTimeMillis;

  @Value("${mysql.jdbc.validationQuery}")

  private String validationQuery;

  @Value("${mysql.jdbc.testWhileIdle}")

  private Boolean testWhileIdle;

  @Value("${mysql.jdbc.testOnBorrow}")

  private Boolean testOnBorrow;

  @Value("${mysql.jdbc.testOnReturn}")

  private Boolean testOnReturn;

  @Value("${mysql.jdbc.maxOpenPreparedStatements}")

  private Integer maxOpenPreparedStatements;

  @Value("${mysql.jdbc.removeAbandoned}")

  private Boolean removeAbandoned;

  @Value("${mysql.jdbc.removeAbandonedTimeout}")

  private Integer removeAbandonedTimeout;

  @Value("${mysql.jdbc.logAbandoned}")

  private Boolean logAbandoned;

  @Value("${mysql.jdbc.poolPreparedStatements}")

  private Boolean poolPreparedStatements;

  @Value("${mysql.jdbc.filters}")

  private String filters;

}
  • 配置mybatis：MyBatisConfigNew.java
package com.tianlian.server.configs;

import com.alibaba.druid.pool.DruidDataSource;

import com.github.pagehelper.PageHelper;

import java.util.HashMap;

import java.util.Map;

import java.util.Properties;

import javax.sql.DataSource;

import org.apache.ibatis.plugin.Interceptor;

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.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

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;

@Configuration

@MapperScan(basePackages = "com.tianlian.server.dao.mapper")

public class MyBatisConfigNew {

  @Autowired

  private MySqlDataSourceConfig mysqlJdbcMapper;

  @Autowired

  private OracleDataSourceConfig oracleJdbcMapper;

  /**

   *根据oracle和mysql的配置属性bean分别创建oracle数据源bean、mysql数据源bean

   */

  @Bean

  public DataSource mysqlDataSource() throws Exception {

    DruidDataSource datasource = new DruidDataSource();

    datasource.setUrl(mysqlJdbcMapper.getUrl());

    datasource.setUsername(mysqlJdbcMapper.getUsername());

    datasource.setPassword(mysqlJdbcMapper.getPassword());

    datasource.setDriverClassName(mysqlJdbcMapper.getDriverClassName());

    datasource.setInitialSize(mysqlJdbcMapper.getInitialSize());

    datasource.setMinIdle(mysqlJdbcMapper.getMinIdle());

    datasource.setMaxActive(mysqlJdbcMapper.getMaxActive());

    datasource.setMaxWait(mysqlJdbcMapper.getMaxWait());

    datasource.setTimeBetweenEvictionRunsMillis(mysqlJdbcMapper.getTimeBetweenEvictionRunsMillis());

    datasource.setMinEvictableIdleTimeMillis(mysqlJdbcMapper.getMinEvictableIdleTimeMillis());

    datasource.setValidationQuery(mysqlJdbcMapper.getValidationQuery());

    datasource.setTestWhileIdle(mysqlJdbcMapper.getTestWhileIdle());

    datasource.setTestOnBorrow(mysqlJdbcMapper.getTestOnBorrow());

    datasource.setTestOnReturn(mysqlJdbcMapper.getTestOnReturn());

    datasource.setPoolPreparedStatements(mysqlJdbcMapper.getPoolPreparedStatements());

    return datasource;

  }

  @Bean

  public DataSource oracleDataSource() throws Exception {

    DruidDataSource datasource = new DruidDataSource();

    datasource.setUrl(oracleJdbcMapper.getUrl());

    datasource.setUsername(oracleJdbcMapper.getUsername());

    datasource.setPassword(oracleJdbcMapper.getPassword());

    datasource.setDriverClassName(oracleJdbcMapper.getDriverClassName());

    datasource.setInitialSize(oracleJdbcMapper.getInitialSize());

    datasource.setMinIdle(oracleJdbcMapper.getMinIdle());

    datasource.setMaxActive(oracleJdbcMapper.getMaxActive());

    datasource.setMaxWait(oracleJdbcMapper.getMaxWait());

    datasource

        .setTimeBetweenEvictionRunsMillis(oracleJdbcMapper.getTimeBetweenEvictionRunsMillis());

    datasource.setMinEvictableIdleTimeMillis(oracleJdbcMapper.getMinEvictableIdleTimeMillis());

    datasource.setValidationQuery(oracleJdbcMapper.getValidationQuery());

    datasource.setTestWhileIdle(oracleJdbcMapper.getTestWhileIdle());

    datasource.setTestOnBorrow(oracleJdbcMapper.getTestOnBorrow());

    datasource.setTestOnReturn(oracleJdbcMapper.getTestOnReturn());

    datasource.setPoolPreparedStatements(oracleJdbcMapper.getPoolPreparedStatements());

    return datasource;

  }

  /**

   * 创建动态数据源，将上面创建的数据源交给动态数据源管理(即放到抽象类AbstractRoutingDataSource中的targetDataSources管理)

   */

  @Bean

  @Primary

  public DynamicDataSource dataSource(

      @Qualifier("mysqlDataSource") DataSource mysqlDataSource,

      @Qualifier("oracleDataSource") DataSource oracleDataSource) {

    Map<Object, Object> targetDataSources = new HashMap<>();

    targetDataSources.put(DatabaseType.mysqlDb, mysqlDataSource);

    targetDataSources.put(DatabaseType.oracleDb, oracleDataSource);

    DynamicDataSource dataSource = new DynamicDataSource();

    // 该方法是AbstractRoutingDataSource的方法

    dataSource.setTargetDataSources(targetDataSources);

    // 默认的datasource设置为myTestDbDataSource

    dataSource.setDefaultTargetDataSource(mysqlDataSource);

    return dataSource;

  }

  /**

   *将动态数据源交给mybatis的SqlSessionFactoryBean，并添加PageHelper分页插件。

   *因为要切换数据源，必须要把PageHelper的autoRuntimeDialect属性设置为true才能在不同类新的数据源切换时，

   *使用不同数据源的分页方式。

   */

  @Bean

  public SqlSessionFactory sqlSessionFactory(

      @Qualifier("mysqlDataSource") DataSource mysqlDataSource,

      @Qualifier("oracleDataSource") DataSource oracleDataSource) throws Exception {

    SqlSessionFactoryBean fb = new SqlSessionFactoryBean();

    fb.setDataSource(this.dataSource(mysqlDataSource, oracleDataSource));

    PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();

    //分页插件

    PageInterceptor pageHelper = new PageInterceptor(); 
    Properties properties = new Properties(); 
    properties.setProperty("reasonable", "true"); 
    properties.setProperty("supportMethodsArguments", "true"); 
    properties.setProperty("returnPageInfo", "check"); 
    properties.setProperty("params", "count=countSql"); 
    properties.setProperty("autoRuntimeDialect", "true"); 
    pageHelper.setProperties(properties); 
    //添加插件 
    fb.setPlugins(new Interceptor[]{pageHelper}); 
   //添加XML目录 
   try { 
     fb.setMapperLocations(resolver.getResources("classpath:mapper/**/*.xml")); 
     return fb.getObject(); 
   } catch (Exception e) 
   { 
     e.printStackTrace(); throw new RuntimeException(e); }
  } 
   @Bean public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) 
   { return new SqlSessionTemplate(sqlSessionFactory); } /** * 配置事务管理器 */ 
   @Bean public DataSourceTransactionManager transactionManager(DynamicDataSource dataSource) 
  throws Exception { return new DataSourceTransactionManager(dataSource); } }
  • 用ThreadLocal为每个线程保存各自选择的数据源：DataSourceContextHolder.java
package com.tianlian.server.configs;

public class DataSourceContextHolder {

  /**

   * 默认数据源

   */

  public static final DatabaseType DEFAULT_DS = DatabaseType.mysqlDb;

  //public static final DatabaseType DEFAULT_DS = DatabaseType.oracleDb;

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

  public static void setDatabaseType(DatabaseType type) {

    contextHolder.set(type);

  }

  public static DatabaseType getDatabaseType() {

    return contextHolder.get();

  }

  public static void clearDatabaseType() {

    contextHolder.remove();

  }

}
  • 继承抽象类AbstractRoutingDataSource实现抽象方法——选择切换到哪个数据源的方法：DynamicDataSource.java
package com.tianlian.server.configs;

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

public class DynamicDataSource extends AbstractRoutingDataSource {

  @Override

  protected Object determineCurrentLookupKey() {

    return DataSourceContextHolder.getDatabaseType();

  }

}
  • 定义一个注解DS，后面用它来标识用哪个数据源来查询:DS.java
package com.tianlian.server.configs;

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 DS {

  DatabaseType value() default DatabaseType.mysqlDb;

}
  • 利用spring的aop来实现根据注解来动态切换数据源的动作:DynamicDataSourceAspect.java
package com.tianlian.server.configs;

import java.lang.reflect.Method;

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.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Component;

@Aspect

@Component

public class DynamicDataSourceAspect {

  private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceAspect.class);

  //首先要定义一个切点——mapper接口下的所有查询方法

  @Pointcut(value = "execution(* com.tianlian.server.dao.mapper.*.*(..))")

  private void pointcut() {

  }

  @Around("pointcut()")

  public void around(ProceedingJoinPoint point) throws Throwable {

    DataSourceContextHolder.clearDatabaseType();

    Object target = point.getTarget();

    String method = point.getSignature().getName();

    Class<?>[] classz = target.getClass().getInterfaces();

    Class<?>[] parameterTypes = ((MethodSignature) point.getSignature())

        .getMethod().getParameterTypes();

    //设置默认数据源

    DatabaseType dataSource = DataSourceContextHolder.DEFAULT_DS;

    String methodName = "";

    try {

      Method m = classz[0].getMethod(method, parameterTypes);

      //根据方法上的DS注解的值来设置数据源

      if (m != null && m.isAnnotationPresent(DS.class)) {

        DS annotation = m

            .getAnnotation(DS.class);

        dataSource = annotation.value();

        methodName = m.getName();

      }

    } catch (Exception e) {

      logger.error("DataSource switch error:{}", e.getMessage(), e);

    } finally {

      logger.info("{} | method  {}  | datasource  {}  | begin",

          ((MethodSignature) point.getSignature()).getMethod().getDeclaringClass(), methodName,

          dataSource);

    }

    DataSourceContextHolder.setDatabaseType(dataSource);

    point.proceed();

    DataSourceContextHolder.clearDatabaseType();

    logger.info("{} | method  {}  | datasource  {}  | end",

        ((MethodSignature) point.getSignature()).getMethod().getDeclaringClass(), methodName,

        dataSource);

  }

}
  • 接下来就可以写测试用的查询接口来尝试一下数据切换功能了。

如果有写的不好的地方欢迎拍砖

源码地址：https://github.com/weijiayou/Springboot-DynamicDataSource-Demo

Springboot+Mybatis+Pagehelper+Aop动态配置Oracle、Mysql数据源的更多相关文章

  1. 基于springboot通过注解AOP动态切换druid多数据源--mybatis

    控制于接口之上: 开始:demo地址  在lsr-core-base中 自定义注解: /** * @Description: 数据源切换注解 * @Package: lsr-microservice ...

  2. SpringBoot+Mybatis+PageHelper实现分页

    SpringBoot+Mybatis+PageHelper实现分页 mybatis自己没有分页功能,我们可以通过PageHelper工具来实现分页,非常简单方便 第一步:添加依赖 <depend ...

  3. springboot+mybatis+pagehelper

    springboot+mybatis+pagehelper整合 springboot   版本2.1.2.RELEASE mybatis  版本3.5 pagehelper 版本5.18 支持在map ...

  4. 【优雅写代码系统】springboot+mybatis+pagehelper+mybatisplus+druid教你如何优雅写代码

    目录 spring基本搭建 整合mybatis pom配置 mybatis配置 设置数据源 设置sqlsessionfactory 设置扫描 设置开启事务 资源放行 测试 结果 思考&& ...

  5. spring-boot + mybatis +pagehelper 使用分页

    转自:https://segmentfault.com/a/1190000015668715?utm_medium=referral&utm_source=tuicool 最近自己搭建一个sp ...

  6. springboot整合Quartz实现动态配置定时任务

    前言 在我们日常的开发中,很多时候,定时任务都不是写死的,而是写到数据库中,从而实现定时任务的动态配置,下面就通过一个简单的示例,来实现这个功能. 一.新建一个springboot工程,并添加依赖 & ...

  7. SpringBoot+Mybatis+PageHelper简化分页实现

    前言 经过一段时间的测试和修改PageHelper插件逐渐走到了让我觉得靠谱的时候,它功能的就是简化分页的实现,让分页不需要麻烦的多写很多重复的代码. 已经加入我的github模版中:https:// ...

  8. springboot+mybatis+dubbo+aop日志第二篇

    本篇主要介绍dubbo-demo-api接口层和dubbo-demo-service层,以及如何通过dubbo把服务发布出去,介绍代码前,咱们先来回顾一下整个demo工程的结构,如下图所示: 1.du ...

  9. springboot+mybatis+dubbo+aop日志第一篇

    本篇文章主要讲述项目搭建过程,不会涉及过多的基础知识,本项目是作者对前段时间学习的一个总结,主要使用到技术有:maven父子工程.springboot.mybatis.dubbo.zookeeper. ...

随机推荐

  1. Oracle 11.2.0.4打补丁

    所需补丁及高版本opatch 上传后将p6880880_112000_Linux-x86-64.zip解压覆盖$ORACLE_HOME/OPatch目录即可 [oracle@localhost OPa ...

  2. linux后台运行相关命令

    1.nohup & 让程序后台运行,nohup 命令 & 2.jobs 查看当前有多少在后台运行的命令 jobs -l选项可显示所有任务的PID,jobs的状态可以是running, ...

  3. 怎么认Destsoon标签条件

    看准一个标签认条件 如: <!--{php $tags=tag("moduleid=18&table=club_group_18&condition=status=3 ...

  4. nginx 其他配置语法

    1.nginx 缓冲区配置 2.跳转重定向 3.头信息 4.超时 location / { proxy_pass http://127.0.0.1:8080;(代理跳转url) proxy_redir ...

  5. 05-numpy-笔记-fliplr

    翻转矩阵的左右. 至少需要是2维矩阵. 例子: >>> A = np.diag([1.,2.,3.]) >>> A array([[ 1., 0., 0.], [ ...

  6. 线程三态和JVM线程状态

    1.线程三态:就绪态.运行态.阻塞态 2.JVM中的六种状态 NEW(新建状态):一个尚未启动的线程所处的状态. RUNNABLE(可运行状态):可运行线程的线程状态,可能正在运行,也可能在等待处理器 ...

  7. CentOS7.5 系统最小化安装与初始化配置

    CentOS7.5 系统最小化安装与初始化配置 1.安装标准化的系统 1.1.系统安装期间的语言 选择:中文-简体中文,安装完成也会默认支持中文输出,便于管理 1.2.时区选择 亚洲上海,CST时区( ...

  8. three.js 加载STL文件

    注意: TrackballControls.js 和 TDSLoader.js 都引用了 three.module.js,特别注意引用的路径 比如: 直接代码咯 <!DOCTYPE html&g ...

  9. 设计模式主目录 C++实现

    行为性模式 1.观察者模式 结构型模式    ----  组合的艺术 1.外观模式

  10. Ubuntu 修改apt-get源为阿里源

    原文件重命名备份 sudo mv /etc/apt/sources.list /etc/apt/source.list.bak 编辑源列表文件 sudo vim /etc/apt/sources.li ...