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. centos下直接使用命令备份mysql数据库

    mysqldump -u root -p 要备份的数据库名> /home/mysql/backup/db/back/数据库名.sql

  2. linux部署django项目流程（全）

    1.python3和python2共存配置 流程在下面网址中 https://www.cnblogs.com/vinic-xxm/p/11358894.html 2.安装依赖包 yum install ...

  3. Nginx 核心配置-根目录root指令与别名alias指令实战案例

    Nginx 核心配置-根目录root指令与别名alias指令实战案例 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.试验环境说明 1>.虚拟机环境说明 [root@nod ...

  4. jquery-ui提供的拖拽方法

    项目当中遇到了任意拖动div标签的功能,找到了jqueryui提供的draggable的插件,这个插件可以实现任意的div的移动,也可以移动到整个屏幕或者在父元素的范围内进行移动. 插件的api    ...

  5. Nginx对图片进行防盗链

    这里需要使用两台Linux主机(一台充当防盗链服务器,一台充当盗链服务器),下表是它们所使用的操作系统以及IP地址. 两台Linux主机所使用的操作系统以及IP地址 主机名称 操作系统 IP地址 防盗 ...

  6. LCD编程_显示文字

    在上篇博客中,实现了画点操作,然后在画点的基础上实现了画线.画圆的操作.实际上显示文字也是在画点的基础上实现的. 文字是由点组成的,那么这些点阵是在哪里获得的呢? 随便打开一个内核文件,搜索font, ...

  7. Spring Boot 注入外部配置到应用内部

    Spring Boot允许你外部化你的配置,这样你就可以在不同的环境中使用相同的应用程序代码,你可以使用properties文件.YAML文件.环境变量和命令行参数来外部化配置,属性值可以通过使用@V ...

  8. python相关资源

    http://blog.csdn.net/ken_wanglin/article/details/53095967 http://www.infoq.com/cn/articles/Python-wr ...

  9. 进程及Python实现

    进程杂谈 #进程就是正在执行的一个过程,是对正在运行程序的一个抽象 #进程由程序.数据集和进程控制块(最重要的,进程切换 状态如何保存,恢复和记录)组成 """ 进程调度 ...

  10. redhat quay 集成镜像构建

    redhat quay 可以类似docker hub 那样进行镜像的构建,以下是一个学习,但是在测试中发现流程是可以通的,但是 quay 在对于dockerfile 内容处理上有bug,造成build ...