SpringBoot多数据源配置MySQL和PostgreSQL同时使用

avatar 2020年01月04日14:46:11 6 13336 views
博主分享免费Java教学视频，B站账号：Java刘哥 ，长期提供技术问题解决、项目定制：本站商品点此
在企业级项目中，系统往往会越来越庞大，场景也各有不同，对数据库的要求也不尽相同。

比如我们有一个项目原来是用 Oracle 数据库，后台需要做一些地图相关的功能，需要地理运算，这个时候有一个比较好的选择就是 PostgreSQL，因为其支持一种空间运算的扩展，即 PostGis，所以我们地图项目基本都是用 PostgreSQL的。但是我们又有一些数据是在  Oracle 库里，在没有完全拆分之前，还是需要查询 Oracle 库的。

所以在早先时候，就必须要做到多数据源配置。

本文介绍一些具体实现。

这里以 Db1 (MySQL)和 Db2 (PostgreSQL) 演示配置并测试。

完整代码地址：https://github.com/saysky/sensboot

一、Maven 依赖


分别是 MySQL 和 PostgreSQL 的依赖
  1. <!-- mysql-->
  2.   <dependency>
  3.       <groupId>mysql</groupId>
  4.       <artifactId>mysql-connector-java</artifactId>
  5.       <scope>runtime</scope>
  6.   </dependency>
  8.   <!-- postgrepsql-->
  9.   <dependency>
  10.       <groupId>org.postgresql</groupId>
  11.       <artifactId>postgresql</artifactId>
  12.       <scope>runtime</scope>
  13.   </dependency>

SpringBoot 版本是 2.0.5.RELEASE，完整代码可以访问上面 GitHub 地址


二、核心配置部分


1.application.yml
  1. server:
  2.   port: 8080
  4. # mybatis配置
  5. mybatis:
  6.   configuration:
  7.     map-underscore-to-camel-case: true
  8.     cache-enabled: true
  11. db1:
  12.   driverClassName: com.mysql.jdbc.Driver
  13.   url: jdbc:mysql://127.0.0.1:3306/sensboot?characterEncoding=utf8&useSSL=false&allowMultiQueries=true
  14.   username: root
  15.   password: 123456
  16.   initialSize: 5
  17.   minIdle: 5
  18.   maxActive: 50
  20. db2:
  21.   driverClassName: org.postgresql.Driver
  22.   url: jdbc:postgresql://127.0.0.1:5432/sensboot
  23.   username: liuyanzhao
  24.   password:
  25.   platform: postgres
  26.   initialSize: 5
  27.   minIdle: 5
  28.   maxActive: 50

不需要其他额外数据源配置，数据库连接池等其他配置我们都可以通过在自定义配置类里设置



2.配置属性类

既然我们上面自定义了配置，那么我们就需要读取它.

注意 prefix 指的是 yml 文件配置的前缀，后面的部分要和类属性名保持一致

Db1DataSourceProperties.java
  1. package com.liuyanzhao.sens.config;
  3. import lombok.Data;
  4. import org.springframework.boot.context.properties.ConfigurationProperties;
  5. import org.springframework.stereotype.Component;
  7. import java.io.Serializable;
  9. /**
  10.  * @author 言曌
  11.  * @date 2020-01-03 17:03
  12.  */
  13. @Component
  14. @Data
  15. @ConfigurationProperties(prefix = "db1")
  16. public class Db1DataSourceProperties implements Serializable {
  18.     private String driverClassName;
  20.     private String url;
  22.     private String username;
  24.     private String password;
  26.     private Integer initialSize;
  28.     private Integer minIdle;
  30.     private Integer maxActive;
  31. }



Db2DataSourceProperties.java
  1. package com.liuyanzhao.sens.config;
  3. import lombok.Data;
  4. import org.springframework.boot.context.properties.ConfigurationProperties;
  5. import org.springframework.stereotype.Component;
  7. import java.io.Serializable;
  9. /**
  10.  * @author 言曌
  11.  * @date 2020-01-03 17:03
  12.  */
  14. @Component
  15. @Data
  16. @ConfigurationProperties(prefix = "db2")
  17. public class Db2DataSourceProperties implements Serializable {
  19.     private String driverClassName;
  21.     private String url;
  23.     private String username;
  25.     private String password;
  27.     private Integer initialSize;
  29.     private Integer minIdle;
  31.     private Integer maxActive;
  33.     private String platform;
  34. }



3.数据源配置

Db1DataSourceConfig.java
  1. package com.liuyanzhao.sens.config;
  3. import com.alibaba.druid.pool.DruidDataSource;
  4. import org.apache.ibatis.session.SqlSessionFactory;
  5. import org.mybatis.spring.SqlSessionFactoryBean;
  6. import org.mybatis.spring.SqlSessionTemplate;
  7. import org.mybatis.spring.annotation.MapperScan;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.beans.factory.annotation.Qualifier;
  10. import org.springframework.boot.context.properties.ConfigurationProperties;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.Configuration;
  13. import org.springframework.core.io.Resource;
  14. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
  15. import org.springframework.core.io.support.ResourcePatternResolver;
  16. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  18. import javax.sql.DataSource;
  20. /**
  21.  * @author 言曌
  22.  * @date 2020-01-03 17:03
  23.  */
  25. @Configuration
  26. @MapperScan(basePackages = "com.liuyanzhao.sens.mapper.db1", sqlSessionFactoryRef = "db1SqlSessionFactory")
  27. public class Db1DataSourceConfig {
  29.     @Autowired
  30.     private Db1DataSourceProperties db1DataSourceProperties;
  32.     @Bean(name = "db1DataSource")
  33.     public DataSource dataSource() {
  34.         DruidDataSource dataSource = new DruidDataSource();
  35.         dataSource.setDriverClassName(db1DataSourceProperties.getDriverClassName());
  36.         dataSource.setUrl(db1DataSourceProperties.getUrl());
  37.         dataSource.setUsername(db1DataSourceProperties.getUsername());
  38.         dataSource.setPassword(db1DataSourceProperties.getPassword());
  39.         dataSource.setInitialSize(db1DataSourceProperties.getInitialSize());
  40.         dataSource.setMinIdle(db1DataSourceProperties.getMinIdle());
  41.         dataSource.setMaxActive(db1DataSourceProperties.getMaxActive());
  42.         return dataSource;
  43.     }
  45.     @Bean(name = "db1SqlSessionFactory")
  46.     public SqlSessionFactory sqlSessionFactory(@Qualifier("db1DataSource") DataSource dataSource,
  47.                                                @Qualifier("camelCaseConfiguration") org.apache.ibatis.session.Configuration configuration) throws Exception {
  48.         SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
  49.         sqlSessionFactoryBean.setDataSource(dataSource);
  50.         sqlSessionFactoryBean.setConfiguration(configuration);
  51.         ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
  52.         Resource[] resources = resourcePatternResolver.getResources("classpath*:mapper/db1/*Mapper.xml");
  53.         sqlSessionFactoryBean.setMapperLocations(resources);
  54.         return sqlSessionFactoryBean.getObject();
  55.     }
  57.     @Bean(name = "db1SqlSessionTemplate")
  58.     public SqlSessionTemplate sqlSessionTemplate(@Qualifier("db1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
  59.         return new SqlSessionTemplate(sqlSessionFactory);
  60.     }
  62.     @Bean(name = "db1TransactionManager")
  63.     public DataSourceTransactionManager dataSourceTransactionManager(@Qualifier("db1DataSource") DataSource dataSource) {
  64.         return new DataSourceTransactionManager(dataSource);
  65.     }
  68.     @Bean(name = "camelCaseConfiguration")
  69.     @ConfigurationProperties(prefix = "mybatis.configuration")
  70.     public org.apache.ibatis.session.Configuration configuration() {
  71.         return new org.apache.ibatis.session.Configuration();
  72.     }
  73. }



Db2DataSourceConfig.java
  1. package com.liuyanzhao.sens.config;
  3. import com.alibaba.druid.pool.DruidDataSource;
  4. import org.apache.ibatis.session.SqlSessionFactory;
  5. import org.mybatis.spring.SqlSessionFactoryBean;
  6. import org.mybatis.spring.SqlSessionTemplate;
  7. import org.mybatis.spring.annotation.MapperScan;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.beans.factory.annotation.Qualifier;
  10. import org.springframework.context.annotation.Bean;
  11. import org.springframework.context.annotation.Configuration;
  12. import org.springframework.context.annotation.Primary;
  13. import org.springframework.core.io.Resource;
  14. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
  15. import org.springframework.core.io.support.ResourcePatternResolver;
  16. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  18. import javax.sql.DataSource;
  20. /**
  21.  * @author 言曌
  22.  * @date 2020-01-03 17:03
  23.  */
  25. @Configuration
  26. @MapperScan(basePackages = "com.liuyanzhao.sens.mapper.db2", sqlSessionFactoryRef = "db2SqlSessionFactory")
  27. public class Db2DataSourceConfig {
  29.     @Autowired
  30.     private Db2DataSourceProperties db2DataSourceProperties;
  32.     @Primary
  33.     @Bean(name = "db2DataSource")
  34.     public DataSource dataSource() {
  35.         DruidDataSource dataSource = new DruidDataSource();
  36.         dataSource.setDriverClassName(db2DataSourceProperties.getDriverClassName());
  37.         dataSource.setUrl(db2DataSourceProperties.getUrl());
  38.         dataSource.setUsername(db2DataSourceProperties.getUsername());
  39.         dataSource.setPassword(db2DataSourceProperties.getPassword());
  40.         dataSource.setInitialSize(db2DataSourceProperties.getInitialSize());
  41.         dataSource.setMinIdle(db2DataSourceProperties.getMinIdle());
  42.         dataSource.setMaxActive(db2DataSourceProperties.getMaxActive());
  43.         return dataSource;
  44.     }
  46.     @Bean(name = "db2SqlSessionFactory")
  47.     public SqlSessionFactory sqlSessionFactory(@Qualifier("db2DataSource") DataSource dataSource,
  48.                                                @Qualifier("camelCaseConfiguration") org.apache.ibatis.session.Configuration configuration) throws Exception {
  49.         SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
  50.         sqlSessionFactoryBean.setDataSource(dataSource);
  51.         sqlSessionFactoryBean.setConfiguration(configuration);
  52.         ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
  53.         Resource[] resources = resourcePatternResolver.getResources("classpath*:mapper/db2/*Mapper.xml");
  54.         sqlSessionFactoryBean.setMapperLocations(resources);
  55.         return sqlSessionFactoryBean.getObject();
  56.     }
  58.     @Bean(name = "db2SqlSessionTemplate")
  59.     public SqlSessionTemplate sqlSessionTemplate(@Qualifier("db2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
  60.         return new SqlSessionTemplate(sqlSessionFactory);
  61.     }
  63.     @Bean(name = "db2TransactionManager")
  64.     public DataSourceTransactionManager dataSourceTransactionManager(@Qualifier("db2DataSource") DataSource dataSource) {
  65.         return new DataSourceTransactionManager(dataSource);
  66.     }
  70. }

这两个配置文件是相似的，只是指定不同的  mapper 扫描位置和 xml 文件位置。同时，我们自定义了 sqlSessionTemplate 和 transactionManager  的 bean 名称。需要用的时候指定对应的即可，下面会介绍事务的时候说明。


三、分别创建 mapper，准备测试


我们这里还是用 sensboot 那个项目测试。

在 mapper 包下创建 db1 和 db2，用于存放不同数据源的 mapper 类。

在 resources/mapper 下也创建对应的 db1 和 db2，用于存放不同数据源的 mapper xml 文件。

本地主要以 Db1UserMapper 和 Db2UserMapper 测试。

数据库两表结构也是一样的，对应实体类都是 User。

完整代码大家可以自己去 GitHub 上克隆。



这里贴一下 Db1UserMapper.xml 代码

其和 Db2UserMapper.xml 代码除了包名和类名不同都一样
  1. package com.liuyanzhao.sens.mapper.db1;
  3. import com.liuyanzhao.sens.entity.User;
  5. /**
  6.  * Db1 数据源的 mapper 测试
  7.  * @author 言曌
  8.  * @date 2020-01-03 17:39
  9.  */
  10. public interface Db1UserMapper {
  12.     /**
  13.      * 根据ID获得用户
  14.      * @param id
  15.      * @return
  16.      */
  17.     User findById(Long id);
  19.     /**
  20.      * 添加
  21.      * @param user
  22.      * @return
  23.      */
  24.     Integer insert(User user);
  25. }



然后贴一下对应的 xml，两个 xml 除了 namespace 写的不一样，几乎一致。
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.liuyanzhao.sens.mapper.db2.Db2UserMapper">
  4.     <resultMap id="BaseResultMap" type="com.liuyanzhao.sens.entity.User">
  5.         <id column="id" property="id"/>
  6.         <result column="username" property="username"/>
  7.         <result column="nickname" property="nickname"/>
  8.         <result column="password" property="password"/>
  9.         <result column="email" property="email"/>
  10.         <result column="avatar" property="avatar"/>
  11.         <result column="status" property="status"/>
  12.         <result column="created_time" property="createdTime"/>
  13.         <result column="created_by" property="createdBy"/>
  14.         <result column="updated_time" property="updatedTime"/>
  15.         <result column="updated_by" property="updatedBy"/>
  16.     </resultMap>
  18.     <sql id="all_columns">
  19.         id, username, nickname, password, email, avatar, status,
  20.         created_time, created_by, updated_time, updated_by
  21.     </sql>
  23.     <insert id="insert">
  24.         INSERT INTO t_user
  25.         (
  26.         username, nickname, password, email,
  27.         avatar, status, created_time, created_by,
  28.         updated_time, updated_by
  29.         )
  30.         VALUES
  31.         (
  32.         #{username}, #{nickname}, #{password}, #{email},
  33.         #{avatar},  #{status},  #{createdTime},  #{createdBy},
  34.         #{updatedTime},  #{updatedBy}
  35.         )
  36.     </insert>
  38.     <select id="findById" resultMap="BaseResultMap">
  39.         SELECT
  40.         <include refid="all_columns"/>
  41.         FROM
  42.         t_user
  43.         WHERE id = #{id}
  44.     </select>
  47. </mapper>



创建表的 sql 这里就不贴了吧

四、测试数据源连接和查询


我们往两个数据库分别插入一条 id 为1的数据，内容不同

然后通过单元测试调用 db1UserMapper.findById(1) 和 db2UserMapper.findById(1)

分别都能返回对应结果，说明配置成功

db1 的测试类 如下
  1. package com.liuyanzhao.sens.mapper.db1;
  3. import com.liuyanzhao.sens.entity.User;
  4. import org.junit.Test;
  5. import org.junit.runner.RunWith;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.boot.test.context.SpringBootTest;
  8. import org.springframework.test.context.junit4.SpringRunner;
  11. /**
  12.  * @author 言曌
  13.  * @date 2020-01-03 17:48
  14.  */
  16. @SpringBootTest
  17. @RunWith(SpringRunner.class)
  18. public class Db1UserMapperTest {
  20.     @Autowired
  21.     private Db1UserMapper db1UserMapper;
  23.     @Test
  24.     public void findById() {
  26.         User user = db1UserMapper.findById(1L);
  27.         System.out.println(user);
  28.     }
  29. }


五、测试事务


我们通过一个给测试类加上事务的注解，并制定 manager。

具体代码是往数据库插入一条数据，然后强制抛出一个异常，看是否回滚
  1. package com.liuyanzhao.sens.mapper.db1;
  3. import com.liuyanzhao.sens.entity.User;
  4. import org.junit.Test;
  5. import org.junit.runner.RunWith;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.boot.test.context.SpringBootTest;
  8. import org.springframework.test.context.junit4.SpringRunner;
  9. import org.springframework.transaction.annotation.Transactional;
  11. import java.util.Date;
  14. /**
  15.  * @author 言曌
  16.  * @date 2020-01-03 17:48
  17.  */
  19. @SpringBootTest
  20. @RunWith(SpringRunner.class)
  21. public class Db1UserMapperTest {
  23.     @Autowired
  24.     private Db1UserMapper db1UserMapper;
  26.     /**
  27.      * 测试事务
  28.      * 如果没有插入 saysky123，说明事务有效
  29.      */
  30.     @Test
  31.     @Transactional(rollbackFor = Exception.class, transactionManager = "db1TransactionManager")
  32.     public void insert() {
  33.         User user = new User("saysky123", "saysky123", "987654", "forest", "", 1, new Date(), "system", new Date(), "system");
  34.         db1UserMapper.insert(user);
  36.         System.out.println(1 / 0);
  37.     }
  38. }

经过测试发现，db1 的能正常回滚，控制台并打印回滚信息



然后测试 db2，也是一样的，不会插入数据

注意：transactionManager = "db1TransactionManager" 不能写错，如果这里写反了

如 db2UserMapper.insert() 的事务 manager 指定为 db1TransactionManager，事务将无法回滚



历史上的今天
一月
04日
  • 微信
  • 交流学习，资料分享
  • weinxin
  • 个人淘宝
  • 店铺名：言曌博客咨询部

  • (部分商品未及时上架淘宝)
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：0   待审核评论数：0