Spring Boot（139）
前面两章在介绍Spring Boot整合MyBatis的时候简单的看了一下Spring Boot如何去配置单一的数据源.并没有详细的单独去看数据源的配置.
本文就简要介绍下在Spring Boot中对内置内存数据库H2,多数据源等的配置.
由于本文档的代码基本都是基于MyBatis搭建，所以关于Spring-Data-JPA的内容并不能展示出来，Spring Boot中对于Repository/Dao的设计并不能完美的体现出来，不过，各个持久层框架自有它自己的好处，无所谓谁坏谁差，还是要看我们具体怎么去应用。
对内置内存数据库的支持
基于Spring Boot的自动化配置，其实我们也仅仅需要在pom.xml文件中引入我们想使用的内置内存数据库的jar依赖即可。Spring Boot会自动扫描classpath下是否有某个jar包，如果有，就加载默认配置。
基于mybatis的配置：
使用内置内存数据库需要引入`spring-jdbc`，其在`mybatis-spring-boot-starter`已经包含。
实际使用过程中，因为内置的内存数据库并不能保留表结构，所以，如果使用JPA就需要在配置文件中将ddl语句设置为`spring.jpa.hibernate.ddl-auto=create`.
如果使用mybatis,我们也可以在application.yml或者application.properties配置schema:db/xx.sql来执行数据库初始化的sql文件.
使用生产数据库
按照官方文档的说法，我们在引入`mybatis-spring-boot-starter`其实已经引入了`tomcat-jdbc`的依赖，也就使用了tomcat的数据库连接池。
当然我们也可以配置自己的数据库连接池，比如配置阿里爸爸的`Druid`来作为我们的数据库连接池工具
请看: /sunshineasbefore/veryjava.spring.boot/tree/master/jdbc
两个数据源的配置
今天多说一点就是,两个数据源分别针对不同的包下的mapper文件:
本文限于篇幅原因,不能展示所有的代码,如果想要完整的代码示例,请移步 /sunshineasbefore/veryjava.spring.boot/tree/master/datasources
支持请点赞,不喜勿喷.
每天一点点,成长多一点.
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：2975371次
积分：19155
积分：19155
排名：第412名
原创：24篇
转载：763篇
评论：839条
(5)(3)(74)(30)(126)(18)(3)(1)(3)(7)(16)(43)(1)(5)(2)(2)(1)(18)(6)(3)(27)(10)(7)(6)(2)(7)(8)(1)(6)(27)(22)(9)(29)(30)(42)(19)(34)(10)(27)(83)(17)(17)Spring Boot最大的特点是简化开发，因此使用Java Config实现去xml配置，本文将使用这种方式完成对阿里云ADS和RDS两个产品的多数据源配置。同时，会用到阿里巴巴的开源数据源Druid。
Spring Boot最大的特点是简化开发，因此使用Java Config实现去xml配置，本文将使用这种方式完成对阿里云ADS和RDS两个产品的多数据源配置。同时，会用到阿里巴巴的开源数据源Druid。
因为ADS和RDS都兼容mysql的JDBC实现，因此工程只需要依赖mysql的driver。
Spring Boot易用性的特点是通过Starter实现的，我们只需依赖mybatis的spring-boot-starter即可。
Druid是数据源。
&dependency&
&groupId&org.mybatis.spring.boot&/groupId&
&artifactId&mybatis-spring-boot-starter&/artifactId&
&version&${mybatis-spring-boot-starter.version}&/version&
&/dependency&
&dependency&
&groupId&com.alibaba&/groupId&
&artifactId&druid&/artifactId&
&version&${druid.version}&/version&
&/dependency&
&dependency&
&groupId&mysql&/groupId&
&artifactId&mysql-connector-java&/artifactId&
&version&${mysql-connector-java.version}&/version&
&/dependency&
&properties&
&mysql-connector-java.version&5.1.34&/mysql-connector-java.version&
&druid.version&1.0.18&/druid.version&
&mybatis-spring-boot-starter.version&1.1.1&/mybatis-spring-boot-starter.version&
&/properties&
数据源配置
多数据源配置要求必须有一个是『主』，我们将RDS设定为主，配置如下：
@Configuration
@MapperScan(basePackages = RdsDataSourceConfig.PACKAGE, sqlSessionFactoryRef = "rdsSqlSessionFactory")
public class RdsDataSourceConfig {
static final String PACKAGE = "com.aliyun.xxx.repository.mybatis.rds";
@Value("${xxx_mysql_url}")
private String dbU
@Value("${xxx_mysql_username}")
private String dbU
@Value("${xxx_mysql_password}")
private String dbP
@Bean(name = "rdsDataSource")
public DataSource rdsDataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl(dbUrl);
dataSource.setUsername(dbUser);
dataSource.setPassword(dbPassword);
return dataS
@Bean(name = "rdsTransactionManager")
public DataSourceTransactionManager rdsTransactionManager() {
return new DataSourceTransactionManager(rdsDataSource());
@Bean(name = "rdsSqlSessionFactory")
public SqlSessionFactory rdsSqlSessionFactory(@Qualifier("rdsDataSource") DataSource rdsDataSource) throws Exception {
final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
sessionFactory.setDataSource(rdsDataSource);
return sessionFactory.getObject();
@Value将获取Spring Boot全局配置文件的kv配置。也可以通过Environment对象的getProperty方法获得kv配置。
@MapperScan配置要扫描并容器管理的包路径，这里我们精确到rds，以便使其内的Mapper（见下文）与其他数据源隔离。
sqlSessionFactoryRef要定义key唯一的SqlSessionFactory实例，否则同名的处理是后者被忽略。
类似地，另一个数据源ADS的配置如下：
@Configuration
@MapperScan(basePackages = AdsDataSourceConfig.PACKAGE, sqlSessionFactoryRef = "adsSqlSessionFactory")
public class AdsDataSourceConfig {
static final String PACKAGE = "com.aliyun.xxx.repository.mybatis.ads";
@Value("${xxx_ads_url}")
private String dbU
@Value("${xxx_ads_username}")
private String dbU
@Value("${xxx_ads_password}")
private String dbP
@Bean(name = "adsDataSource")
public DataSource adsDataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl(dbUrl);
dataSource.setUsername(dbUser);
dataSource.setPassword(dbPassword);
return dataS
@Bean(name = "adsTransactionManager")
public DataSourceTransactionManager adsTransactionManager(@Qualifier("adsDataSource") DataSource adsDataSource) {
return new DataSourceTransactionManager(adsDataSource);
@Bean(name = "adsSqlSessionFactory")
public SqlSessionFactory adsSqlSessionFactory(@Qualifier("adsDataSource") DataSource adsDataSource) throws Exception {
final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
sessionFactory.setDataSource(adsDataSource);
return sessionFactory.getObject();
Mapper是mybatis的DAL层接口，其实现是由mybatis内部完成的，也就是说，我们只需要定义好接口即可完成CRUD。
com.aliyun.xxx.repository.mybatis.rds包内的Mapper只会用到RDS数据源。
package com.aliyun.xxx.repository.mybatis.
public interface MetaMapper {
@SelectProvider(type = MetaSelectProvider.class, method = "xxxQueryById")
@Results(value ={
@Result(id=true, property="id",column="id",javaType=Long.class,jdbcType=JdbcType.BIGINT),
@Result(property="gmtCreate",column="gmt_create",javaType=Date.class,jdbcType=JdbcType.TIMESTAMP)})
List&XxxPojo& xxxQueryById(@Param("xxxId") String xxxId);
上述Mapper定义了一个Select方法，@SelectProvider用于定义具体的SQL语句，@Results用于定义具体的表字段与POJO属性的映射。
MetaSelectProvider可以使用MyBatis的API完成SQL的拼装。
public class MetaSelectProvider {
private static final String xxxSQL = "id, ...,gmt_create";
public String xxxQueryById(Map&String, Object& parameter) {
org.apache.ibatis.jdbc.SQL sql = new org.apache.ibatis.jdbc.SQL();
sql.SELECT(xxxSQL).FROM("table_name").WHERE("biz_id=#{xxxId}");
return sql.toString();
@Repository
public class XxxDAO {
@Autowired
private MetaMapper metaM
public List&XxxPojo& xxxQueryById(String xxxId) throws DataAccessException {
return metaMapper.xxxQueryById(xxxId);
SpringBootApplication
Spring Boot的入口类定义如下：
@SpringBootApplication
@PropertySource("file:/opt/xxx/xxx.properties")
public class XxxApplication {
public static void main(String[] args) {
SpringApplication.run(XxxApplication.class, args);
使用Spring的上下文，完成单元测试：
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = XxxApplication.class)
public class TestXxxDAO {
private static final Logger logger = LogManager.getLogger(RelevanceResource.class);
@Autowired
private XxxDAO
public void testXxxById() {
String xxxId = "C00018";
List&XxxPojo& list = dao.xxxQueryById(xxxId);
Assert.assertNotNull(list);
用云栖社区APP，舒服~
【云栖快讯】支撑千亿营收，阿里如何做研发？淘宝如何做敏捷实践？如何面对开发中的“黑天鹅”事件？6月29日首届阿里研发效能嘉年华，独家直播，赶紧预约吧！&&
很好，谢谢您！
您好，有一个小问题，从库，是否能设置为以只读模式运行呢？
只是传统的spring+mybatis通过mybatis-spring-boot-starter加载jar包，并没有看到有用到spring-boot的特性。
针对互联网服务器（包括非阿里云主机）在遭受大流量的DDoS攻击后导致服务不可用的情况下，推出的付费增值服务，用户...
是一种简单易用的云计算资源管理和自动化运维服务。用户通过模板描述多个云计算资源的依赖关系、配置等，并自动完成所有...
专精于业务数据与地理信息融合的大数据可视化，通过图形界面轻松搭建专业的可视化应用， 满足您日常业务监控、调度、会...
为您提供简单高效、处理能力可弹性伸缩的计算服务，帮助您快速构建更稳定、安全的应用，提升运维效率，降低 IT 成本...
2017云栖大会·上海峰会火热报名中
Loading...Spring Boot多数据源配置与使用 - 简书
Spring Boot多数据源配置与使用
之前在介绍使用JdbcTemplate和Spring-data-jpa时，都使用了单数据源。在单数据源的情况下，Spring Boot的配置非常简单，只需要在application.properties文件中配置连接参数即可。但是往往随着业务量发展，我们通常会进行数据库拆分或是引入其他数据库，从而我们需要配置多个数据源，下面基于之前的JdbcTemplate和Spring-data-jpa例子分别介绍两种多数据源的配置方式。
多数据源配置
创建一个Spring配置类，定义两个DataSource用来读取application.properties中的不同配置。如下例子中，主数据源配置为spring.datasource.primary开头的配置，第二数据源配置为spring.datasource.secondary开头的配置。
@Configuration
public class DataSourceConfig {
@Bean(name = "primaryDataSource")
@Qualifier("primaryDataSource")
@ConfigurationProperties(prefix="spring.datasource.primary")
public DataSource primaryDataSource() {
return DataSourceBuilder.create().build();
@Bean(name = "secondaryDataSource")
@Qualifier("secondaryDataSource")
@ConfigurationProperties(prefix="spring.datasource.secondary")
public DataSource secondaryDataSource() {
return DataSourceBuilder.create().build();
对应的application.properties配置如下：
spring.datasource.primary.url=jdbc:mysql://localhost:3306/test1
spring.datasource.primary.username=root
spring.datasource.primary.password=root
spring.datasource.primary.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.secondary.url=jdbc:mysql://localhost:3306/test2
spring.datasource.secondary.username=root
spring.datasource.secondary.password=root
spring.datasource.secondary.driver-class-name=com.mysql.jdbc.Driver
JdbcTemplate支持
对JdbcTemplate的支持比较简单，只需要为其注入对应的datasource即可，如下例子，在创建JdbcTemplate的时候分别注入名为primaryDataSource和secondaryDataSource的数据源来区分不同的JdbcTemplate。
@Bean(name = "primaryJdbcTemplate")
public JdbcTemplate primaryJdbcTemplate(
@Qualifier("primaryDataSource") DataSource dataSource) {
return new JdbcTemplate(dataSource);
@Bean(name = "secondaryJdbcTemplate")
public JdbcTemplate secondaryJdbcTemplate(
@Qualifier("secondaryDataSource") DataSource dataSource) {
return new JdbcTemplate(dataSource);
接下来通过测试用例来演示如何使用这两个针对不同数据源的JdbcTemplate。
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(Application.class)
public class ApplicationTests {
@Autowired
@Qualifier("primaryJdbcTemplate")
protected JdbcTemplate jdbcTemplate1;
@Autowired
@Qualifier("secondaryJdbcTemplate")
protected JdbcTemplate jdbcTemplate2;
public void setUp() {
jdbcTemplate1.update("DELETE
jdbcTemplate2.update("DELETE
public void test() throws Exception {
// 往第一个数据源中插入两条数据
jdbcTemplate1.update("insert into user(id,name,age) values(?, ?, ?)", 1, "aaa", 20);
jdbcTemplate1.update("insert into user(id,name,age) values(?, ?, ?)", 2, "bbb", 30);
// 往第二个数据源中插入一条数据，若插入的是第一个数据源，则会主键冲突报错
jdbcTemplate2.update("insert into user(id,name,age) values(?, ?, ?)", 1, "aaa", 20);
// 查一下第一个数据源中是否有两条数据，验证插入是否成功
Assert.assertEquals("2", jdbcTemplate1.queryForObject("select count(1) from user", String.class));
// 查一下第一个数据源中是否有两条数据，验证插入是否成功
Assert.assertEquals("1", jdbcTemplate2.queryForObject("select count(1) from user", String.class));
Spring-data-jpa支持
对于数据源的配置可以沿用上例中DataSourceConfig的实现。
新增对第一数据源的JPA配置，注意两处注释的地方，用于指定数据源对应的Entity实体和Repository定义位置，用@Primary区分主数据源。
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
entityManagerFactoryRef="entityManagerFactoryPrimary",
transactionManagerRef="transactionManagerPrimary",
basePackages= { "com.didispace.domain.p" }) //设置Repository所在位置
public class PrimaryConfig {
@Autowired @Qualifier("primaryDataSource")
private DataSource primaryDataS
@Bean(name = "entityManagerPrimary")
public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
return entityManagerFactoryPrimary(builder).getObject().createEntityManager();
@Bean(name = "entityManagerFactoryPrimary")
public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary (EntityManagerFactoryBuilder builder) {
return builder
.dataSource(primaryDataSource)
.properties(getVendorProperties(primaryDataSource))
.packages("com.didispace.domain.p") //设置实体类所在位置
.persistenceUnit("primaryPersistenceUnit")
@Autowired
private JpaProperties jpaP
private Map&String, String& getVendorProperties(DataSource dataSource) {
return jpaProperties.getHibernateProperties(dataSource);
@Bean(name = "transactionManagerPrimary")
public PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder) {
return new JpaTransactionManager(entityManagerFactoryPrimary(builder).getObject());
新增对第二数据源的JPA配置，内容与第一数据源类似，具体如下：
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
entityManagerFactoryRef="entityManagerFactorySecondary",
transactionManagerRef="transactionManagerSecondary",
basePackages= { "com.didispace.domain.s" }) //设置Repository所在位置
public class SecondaryConfig {
@Autowired @Qualifier("secondaryDataSource")
private DataSource secondaryDataS
@Bean(name = "entityManagerSecondary")
public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
return entityManagerFactorySecondary(builder).getObject().createEntityManager();
@Bean(name = "entityManagerFactorySecondary")
public LocalContainerEntityManagerFactoryBean entityManagerFactorySecondary (EntityManagerFactoryBuilder builder) {
return builder
.dataSource(secondaryDataSource)
.properties(getVendorProperties(secondaryDataSource))
.packages("com.didispace.domain.s") //设置实体类所在位置
.persistenceUnit("secondaryPersistenceUnit")
@Autowired
private JpaProperties jpaP
private Map&String, String& getVendorProperties(DataSource dataSource) {
return jpaProperties.getHibernateProperties(dataSource);
@Bean(name = "transactionManagerSecondary")
PlatformTransactionManager transactionManagerSecondary(EntityManagerFactoryBuilder builder) {
return new JpaTransactionManager(entityManagerFactorySecondary(builder).getObject());
完成了以上配置之后，主数据源的实体和数据访问对象位于：com.didispace.domain.p，次数据源的实体和数据访问接口位于：com.didispace.domain.s。
分别在这两个package下创建各自的实体和数据访问接口
主数据源下，创建User实体和对应的Repository接口
public class User {
@GeneratedValue
@Column(nullable = false)
@Column(nullable = false)
public User(){}
public User(String name, Integer age) {
this.name =
this.age =
// 省略getter、setter
public interface UserRepository extends JpaRepository&User, Long& {
从数据源下，创建Message实体和对应的Repository接口
public class Message {
@GeneratedValue
@Column(nullable = false)
@Column(nullable = false)
public Message(){}
public Message(String name, String content) {
this.name =
this.content =
// 省略getter、setter
public interface MessageRepository extends JpaRepository&Message, Long& {
接下来通过测试用例来验证使用这两个针对不同数据源的配置进行数据操作。
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(Application.class)
public class ApplicationTests {
@Autowired
private UserRepository userR
@Autowired
private MessageRepository messageR
public void test() throws Exception {
userRepository.save(new User("aaa", 10));
userRepository.save(new User("bbb", 20));
userRepository.save(new User("ccc", 30));
userRepository.save(new User("ddd", 40));
userRepository.save(new User("eee", 50));
Assert.assertEquals(5, userRepository.findAll().size());
messageRepository.save(new Message("o1", "aaaaaaaaaa"));
messageRepository.save(new Message("o2", "bbbbbbbbbb"));
messageRepository.save(new Message("o3", "cccccccccc"));
Assert.assertEquals(3, messageRepository.findAll().size());
会一些前端，懂一些后端，做过一些管理，弄过一些运维，搞过一些推广，我是一枚爱折腾的团队万金油……
微信订阅号：didispace
拥有最强Spring Cloud研究者阵容的社区：
Spring技术框架一网打尽！最近在学习spring boot，发现在jar包依赖方面做很少的工作量就可以了，对于数据库操作，我用的比较多的是mybatis plus，在中央仓库已经有mybatis-plus的插件了，对于单数据源来说直接使用就是了，但我自己的项目经常会有多数据源的情况，自己去试着写数据源的代码，核心的方法参考mp说明文档中多数据源的处理，使用动态数据源，根据需求去切换数据源
新建spring-boot项目
这一步大家去参考其它教程，很简单
定义数据源相关Model
动态数据源
继承了抽像的数据源，并实现了DataSource,归根结底还是数据就是了，在这里面进行扩展，实现determiniCurrentlookupKey,也就是获取当前需要使用数据源的key值，在父类方法中有一个map,用来保存key值与数据源的对应关系，而key值是与当前线程相关的，DbcontextHolder代码见下
package mon.dataS
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataS
* Created by Administrator on
publicclassDynamicDataSourceextendsAbstractRoutingDataSource{
* 取得当前使用哪个数据源
protectedObject determineCurrentLookupKey(){
returnDbContextHolder.getDbType();
定义DbContextHolder
里面包含静态方法，用来设置或获取线程相关的数据源别名
publicclassDbContextHolder{
privatestaticfinalThreadLocal&String& contextHolder =newThreadLocal&&();
* 设置数据源
* @param dbTypeEnum
publicstaticvoid setDbType(DBTypeEnum dbTypeEnum){
contextHolder.set(dbTypeEnum.getValue());
* 取得当前数据源
publicstaticString getDbType(){
return contextHolder.get();
* 清除上下文数据
publicstaticvoid clearDbType(){
contextHolder.remove();
定义数据源枚举类
简化设置线程相关数据源名称的记忆压力；直接从所有的数据源的枚举中去选就可以了~
publicenumDBTypeEnum{
datasource1("datasource1"), datasource2("datasource2");
DBTypeEnum(String value){
this.value =
publicString getValue(){
生成 dataource 对象及 mp需要的对象
resources/application.properties的配置
在这里定义的属性名要与DruidDataSource和 SqlSessionFactory中需要的属性相同，使用ConfigurationProperties注解来减少代码
datasource1:
username: root
password: 123456
filters: mergeStat,wall,logback
initialSize: 5
maxActive: 50
minIdle: 5
maxWait: 6000
validationQuery: SELECT 'x'
testOnBorrow: true
testOnReturn: true
testWhileIdle: true
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
removeAbandoned: true
removeAbandonedTimeout: 1800
logAbandoned: true
url: jdbc:mysql://<span style="color: #2.168.168.118:3306/test?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&transformedBitIsBoolean=true&useSSL=false
mybatis-plus1:
# 数据源名称
datasource: datasource1
# mapper配置路径
mapperLocations:
classpath:/mapper/test1/*.xml
# mybatis配置路径
configLocation: classpath:/mybatis-config.xml
# entity的包
typeAliasesPackage: com.zhangshuo/test1/entity
# 全局配置
globalConfiguration:
# id生成策略 0 自增 1 用户输入
# 灵据数类型
dbType: mysql
# 字段是否为下划线格式
dbColumnUnderline: false
datasource2:
username: root
password: 123456
filters: mergeStat,wall,logback
initialSize: 5
maxActive: 50
minIdle: 5
maxWait: 6000
validationQuery: SELECT 'x'
testOnBorrow: true
testOnReturn: true
testWhileIdle: true
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
removeAbandoned: true
removeAbandonedTimeout: 1800
logAbandoned: true
url: jdbc:mysql://192.168.168.118:3306/sms?useUnicode=true&characterEncoding=utf-8
mybatis-plus2:
# 数据源名称
datasource: datasource2
# mapper配置路径
mapperLocations:
classpath:/mapper/test2/*.xml
# mybatis配置路径
configLocation:
# entity的包
typeAliasesPackage: com.zhangshuo/test2/entity
# 全局配置
globalConfiguration:
# id生成策略 0 自增 1 用户输入
# 灵据数类型
dbType: mysql
# 字段是否为下划线格式
dbColumnUnderline: false
生成相应对象
import com.alibaba.druid.pool.DruidDataS
import com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryB
import mon.dataSource.DynamicDataS
import org.mybatis.spring.annotation.MapperS
import org.springframework.beans.factory.annotation.Q
import org.springframework.boot.context.properties.ConfigurationP
import org.springframework.boot.context.properties.ConfigurationPropertiesB
import org.springframework.context.annotation.B
import org.springframework.context.annotation.C
import org.springframework.context.annotation.P
import javax.sql.DataS
import java.util.M
import java.sql.SQLE
import java.util.HashM
* Created by Administrator on
@Configuration
@MapperScan(value ={"com.zhangshuo.test1.mapper","com.zhangshuo.test2.mapper"})
publicclassDataSourceConfig{
@ConfigurationProperties(prefix ="datasource1")
@Bean(name ="datasource1")
// @Primary
* 在方法上注解configurationProperties时，将会把属性注入到返回结果的bean中
publicDruidDataSource dataSource1()throwsSQLException{
returnnewDruidDataSource();
@ConfigurationProperties(prefix ="datasource2")
@Bean(name ="datasource2")
* 在方法上注解configurationProperties时，将会把属性注入到返回结果的bean中
publicDruidDataSource dataSource2()throwsSQLException{
returnnewDruidDataSource();
@Bean(name ="datasource")
publicDynamicDataSource dynamicDataSource(@Qualifier(value ="datasource1")DataSource dataSource1,@Qualifier(value ="datasource2")DataSource dataSource2){
DynamicDataSource bean =newDynamicDataSource();
Map&Object,Object& targetDataSources =newHashMap&&();
targetDataSources.put("datasource1",dataSource1);
targetDataSources.put("datasource2", dataSource2);
bean.setTargetDataSources(targetDataSources);
bean.setDefaultTargetDataSource(dataSource1);
@Bean(name ="sessionFactory1")
@ConfigurationProperties(prefix ="mybatis-plus1")
@ConfigurationPropertiesBinding()
publicMybatisSqlSessionFactoryBean sqlSessionFactory1(@Qualifier(value ="datasource")DataSource dataSource){
MybatisSqlSessionFactoryBean bean =newMybatisSqlSessionFactoryBean();
bean.setDataSource(dataSource);
@Bean(name ="sessionFactory2")
@ConfigurationProperties(prefix ="mybatis-plus2")
@ConfigurationPropertiesBinding()
publicMybatisSqlSessionFactoryBean sqlSessionFactory2(@Qualifier(value ="datasource")DataSource dataSource){
MybatisSqlSessionFactoryBean bean =newMybatisSqlSessionFactoryBean();
bean.setDataSource(dataSource);
设置AOP用来自动切换数据源
在这里说明下我的目录结构：
com.zhangshuo.test1.controller/service/mapper
com.zhangshuo.test2.controller/service/mapper
在dao层进行切换
import mon.dataSource.DBTypeE
import mon.dataSource.DbContextH
import org.aspectj.lang.annotation.A
import org.aspectj.lang.annotation.B
import org.aspectj.lang.annotation.P
import org.slf4j.L
import org.slf4j.LoggerF
import org.
* Created by Administrator on
* 以dao层进行切换
@Component
publicclassDataSourceInterceptor{
Logger logger =LoggerFactory.getLogger(DataSourceInterceptor.class);
@Pointcut(value ="execution(public * com.zhangshuo.test1.mapper.**.*(..))")
privatevoid datasource1ServicePointcut(){};
@Pointcut(value ="execution(public * com.zhangshuo.test2.mapper.**.*(..))")
privatevoid datasource2ServicePointcut(){};
* 切换数据源1
@Before("datasource1ServicePointcut()")
publicvoid dataSource1Interceptor(){
logger.debug("切换到数据源{}..............................","datasource1");
DbContextHolder.setDbType(DBTypeEnum.datasource1);
* 切换数据源2
@Before("datasource2ServicePointcut()")
publicvoid dataSource2Interceptor(){
logger.debug("切换到数据源{}.......................","datasource2");
DbContextHolder.setDbType(DBTypeEnum.datasource2);
到这里就可以进行测试了；
顺带贴下mybatis-plus的分页插件，我是定义到了mybatis-config.xml中，也可以手动在sqlSessionfacotry中的setPlugins中()定义；
&?xml version="1.0" encoding="UTF-8"?&
&!DOCTYPE configuration
PUBLIC "-//ibatis.apache.org//DTD Config 3.0//EN"
"http://ibatis.apache.org/dtd/ibatis-3-config.dtd"&
&configuration&
&settings&
&setting name="cacheEnabled" value="false"/&
&setting name="lazyLoadingEnabled" value="false"/&
&setting name="aggressiveLazyLoading" value="true"/&
&setting name="logImpl" value="slf4j"/&
&/settings&
&plugin interceptor="com.baomidou.mybatisplus.plugins.PaginationInterceptor"&
&property name="dialectType" value="mysql" /&
&property name="optimizeType" value="aliDruid" /&
&/plugins&
&/configuration&
阅读(...) 评论()