Springboot整合多数据源以及多数据源中的事务处理

Posted 2022-11-23 经理，天台风好大

文章目录

• • • 前言
    • 创建数据库
    • 项目结构
    • 引入依赖
    • yml配置
    • 数据源配置类
    • • 注意
    • Mapper层
    • Controller层
    • 多数据源事务处理
    • • 注意：
      • • 设置日志文件目录

---

前言

本文主要介绍的是springboot整合多数据源以及多数据源事务处理。

多数据源就是在同一个项目中连接多个数据库，使用多个数据库可能是由于业务量扩大进行数据库拆分，也可能是根据项目实际情况需要连接多个数据库。比如我之前有个项目，需要访问一个已有的数据库进行查询操作，但不能修改，还需要新建数据库表进行其他的业务处理，这时就需要使用多数据源。

创建数据库

1. 创建member数据库，添加一张user表，字段为id主键自增，name，age；

-- 创建member数据库，添加一张user表，字段为id主键自增，name，age；
CREATE database if not exists member;
use member;

CREATE table user(
	id int primary key auto_increment,
	name varchar(100),
	age int
);

2. 创建order数据库，添加一张order表，字段为id主键自增，number；

-- 创建order数据库，添加一张order表，字段为id主键自增，number；
create database `order`;

use `order`;

create table `order` (
	id int primary key auto_increment,
	number int
);

项目结构

先来看一下工程结构，这里的demo使用会员数据库和订单数据库，建立member和order相关包和类。

引入依赖

在pom文件中引入依赖，这里持久层框架使用的是mybatis，数据库引擎是mysql。不过oracle也适用。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.6.6</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- MySQL 连接驱动依赖 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    	<version>5.1.39</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.2</version>
    </dependency>
</dependencies>

yml配置

在application.yml中进行数据源配置

server:
  port: 8080

spring:
  datasource:
    member:
      jdbc-url: jdbc:mysql://localhost:3306/member?useUnicode=true&characterEncoding=utf-8
      username: root
      password: root
      driver-class-name: com.mysql.jdbc.Driver
    order:
      jdbc-url: jdbc:mysql://localhost:3306/order?useUnicode=true&characterEncoding=utf-8
      username: root
      password: root
      driver-class-name: com.mysql.jdbc.Driver

这里数据源的url的key是’jdbc-url’,在多数据源的情况下，使用’url’作为key会报错，这是它本身的一个bug。

数据源配置类

在config目录中创建member文件夹，在member文件夹中创建MemberDatasourceConfig进行数据源配置。

package com.lx.config.member;

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.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

@Configuration
@MapperScan(value = "com.lx.mapper.member",sqlSessionTemplateRef = "memberSqlSessionTemplate")
public class MemberDatasourceConfig 

    /**
     * 创建DataSource
     * @return
     */
    @Bean("memberDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.member")
    public DataSource memberDataSource()
        return DataSourceBuilder.create().build();
    

    /**
     * 创建sqlSessionFactory
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "memberSqlSessionFactory")
    public SqlSessionFactory memberSqlSessionFactory(@Qualifier("memberDataSource")DataSource dataSource ) throws Exception
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean.getObject();
    

    /**
     * 创建事务管理器
     * @param dataSource
     * @return
     */
    @Bean(name = "memberTransactionManager")
    public DataSourceTransactionManager memberTransactionManager(@Qualifier("memberDataSource") DataSource dataSource)
            return new DataSourceTransactionManager(dataSource);
    

    /**
     * 创建sqlSession模板
     * @param sqlSessionFactory
     * @return
     */
    @Bean(name = "memberSqlSessionTemplate")
    public SqlSessionTemplate memberSqlSessionTemplate(@Qualifier("memberSqlSessionFactory") SqlSessionFactory sqlSessionFactory)
        return new SqlSessionTemplate(sqlSessionFactory);
    

在config目录中创建order文件夹，在order文件夹中创建OrderDatasourceConfig进行数据源配置。

package com.lx.config.order;

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.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

@Configuration
@MapperScan(value = "com.lx.mapper.order",sqlSessionTemplateRef = "orderSqlSessionTemplate")
public class OrderDatasourceConfig 
    /**
     * 创建DataSource
     * @return
     */
    @Bean("orderDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.order")
    public DataSource orderDataSource()
        return DataSourceBuilder.create().build();
    

    /**
     * 创建sqlSessionFactory
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "orderSqlSessionFactory")
    public SqlSessionFactory orderSqlSessionFactory(@Qualifier("orderDataSource") DataSource dataSource) throws Exception 
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean.getObject();
    

    /**
     * 创建事务管理器
     * @param dataSource
     * @return
     */
    @Bean(name = "orderTransactionManager")
    public DataSourceTransactionManager orderTransactionManager(@Qualifier("orderDataSource") DataSource dataSource) 
        return new DataSourceTransactionManager(dataSource);
    

    /**
     * 创建sqlSession模板
     * @param sqlSessionFactory
     * @return
     */
    @Bean(name = "orderSqlSessionTemplate")
    public SqlSessionTemplate orderSqlSessionTemplate(@Qualifier("orderSqlSessionFactory") SqlSessionFactory sqlSessionFactory) 
        return new SqlSessionTemplate(sqlSessionFactory);
    

注意

• SpringBoot2.0以前需要在方法上加Primary注解，来判断默认的数据库连接。
• Configuration注解定义当前类为配置类，相当于xml, 配合Bean注解将方法注入到spring容器中。
• MapperScan注解定义了持久层的扫包范围，并且指定这个包配置的是哪个数据源。
• ConfigurationProperties注解是springboot的注解，它指定了使用application.yml文件中哪个数据源的配置。

Mapper层

在mapper目录下创建member文件夹，在member文件夹中创建接口MemberMapper.java,添加一条插入语句。

package com.lx.mapper.member;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

@Repository
public interface MemberMapper 

    /**
     * 添加会员
     * @param name 姓名
     * @param age 年龄
     * @return
     */
    @Insert("insert into user values (null,#name,#age);")
    public int addUser(@Param("name") String name, @Param("age") Integer age);

在mapper目录下创建order文件夹，在order文件夹中创建接口OrderMapper.java,添加一条插入语句。

package com.lx.mapper.order;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

@Repository
public interface OrderMapper 

    /**
     * 添加订单
     * @param number 数量
     * @return
     */
    @Insert("insert into `order` values (null,#number);")
    public int addUser(@Param("number") Integer number);

这里的order表名因为是数据库关键字，需要使用``符号，（英文输入法下键盘上tab键上面那个按）键进行引用，否则会报错。

Controller层

在controller层中新建MultiDatasourceController.java

package com.lx.controller;

import com.lx.mapper.member.MemberMapper;
import com.lx.mapper.order.OrderMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MultiDatasourceController 

    @Autowired
    private MemberMapper memberMapper;
    @Autowired
    private OrderMapper orderMapper;

    /**
     * 调用member数据库
     * @param name
     * @param age
     * @return
     */
    @Transactional(rollbackFor = Exception.class,transactionManager = "memberTransactionManager")
    @RequestMapping("/addUser")
    public String addUser(String name, Integer age)
        return memberMapper.addUser(name,age) > 0 ? "success" : "fail";
    

    /**
     * 调用order数据库
     * @param number
     * @return
     */
    @Transactional(rollbackFor = Exception.class,transactionManager = "orderTransactionManager")
    @RequestMapping("/addOrder")
    public String addOrder(Integer number)
        return memberMapper.addUser(number) > 0 ? "success" : "fail";
    

• 方法上添加Transactional注解，进行事务管理，指定事务管理器，就是我们之前在config中配置的。
• 这样的话比如addOrder中，如果输入的参数number为0，就会失败回滚。
• 在浏览器中分别访问这两个接口，就可以看到两个数据库中的分别插入数据了。

order数据库


member数据库

多数据源事务处理

但是上面这种事务处理还是单数据源的处理方式，如果两个数据源在同一个事务中时，就无法完全回滚了。

    @Transactional(rollbackFor = Exception.class,transactionManager = "orderTransactionManager")
    @RequestMapping("/addOrderAndMember")
    public String addOrderAndMember(String name, Integer age,Integer number) 
        int i = memberMapper.addUser(name, age);
        int j = orderMapper.addOrder(number);
        int x = 10 / number;
        return j >0?"success":"fail";
    

比如这一段代码，因为指定的事务管理器是orderTransactionManager，所以 即使number为0的时候，memberMapper.addUser(name, age);这一段数据库操作是不会回滚的。

• 这里需要使用jta-atomikos进行事务管理。

pom中引入jta-atomikos依赖：

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-jta-atomikos</artifactId>
</dependency>

修改application.yml文件，添加一些配置，注意，这里的数据库地址的key是’url’ ,不然会报空指针。

server:
  port: 8080

spring:
  datasource:
    member:
      url: jdbc:mysql://47.108.211.99:3306/member?useUnicode=true&characterEncoding=utf-8
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
      borrowConnectionTimeout: 30
      loginTimeout: 30
      maintenanceInterval: 60
      maxIdleTime: 60
      maxLifetime: 20000
      maxPoolSize: 25
      minPoolSize: 3
      uniqueResourceName: memberDataSource
    order:
      url: jdbc:mysql://localhost:3306/order?useUnicode=true&characterEncoding=utf-8
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
      borrowConnectionTimeout: 30
      loginTimeout: 30
      maintenanceInterval: 60
      maxIdleTime: 60
      maxLifetime: 20000
      maxPoolSize: 25
      minPoolSize: 3
      uniqueResourceName: orderDataSource

在config/member中添加MemberConfig配置类，属性与yml中的数据源配置是一致的

package com.lx.config.member;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Data
@Component
@ConfigurationProperties(prefix = "spring.datasource.member")
public class MemberConfig 
    private String url;
    private String username;
    private String password;
    private int minPoolSize;
    private int maxPoolSize;
    private int maxLifetime;
    private int borrowConnectionTimeout;
    private int loginTimeout;
    private int maintenanceInterval;
    private int maxIdleTime;
    private String testQuery;
    private String uniqueResourceName;

在config/order中添加OrderConfig配置类，属性与yml中的数据源配置是一致的

@Data
@Component
@ConfigurationProperties(prefix = "spring.datasource.order")
public class OrderConfig 
    private String url;
    private String username;
    private String password;
    private int minPoolSize;
    private int maxPoolSize;
    private int maxLifetime;
    private int borrowConnectionTimeout;
    private int loginTimeout;
    private int maintenanceInterval;
    private int maxIdleTime;
    private String testQuery;
    private String uniqueResourceName;

• Data注解提供get/set方法。
• ConfigurationProperties注解负责解析对应属性在yml文件的前缀。

如果出现这个错误,就添加下面的依赖,并添加@Componen注解

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>
以上是关于Springboot整合多数据源以及多数据源中的事务处理的主要内容，如果未能解决你的问题，请参考以下文章
 
 springboot整合mybatis的多数据源解决办法
 SpringBoot整合Spring Data JPA多数据源
 springboot整合多数据源配置
 Springboot-整合多数据源配置 & AbstractRoutingDataSource详解，分析多数据源切换原理
 SpringBoot2 整合JTA组件，多数据源事务管理
 springboot：整合多数据源