微服务框架（3）----基于SpringBoot2.0版本框架-多数据源分布式事务管理(jta+atomikos)

最新推荐文章于 2024-02-27 07:15:10 发布

红烧咸鱼丶

最新推荐文章于 2024-02-27 07:15:10 发布

阅读量518

点赞数

分类专栏：蚂蚁课堂的视频笔记

本文链接：https://blog.csdn.net/u014437791/article/details/101038083

版权

蚂蚁课堂的视频笔记专栏收录该内容

49 篇文章 6 订阅

订阅专栏

SpringBoot整合MyBatis

可以不在mapper层加上@Mapper，直接加@MapperScan(basePackages={})扫包，若有多个包，用逗号隔开
推荐使用@MapperScan的方式
代码演示：
（1）pom文件

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.0.RELEASE</version>
	</parent>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>
		<!-- 测试 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.1.1</version>
		</dependency>
		<!-- mysql 依赖 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>
		<!-- springboot-web组件 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
	</dependencies>

（2）application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

（3）Mapper代码：

public interface UserMapper {
	@Select("SELECT * FROM USERS WHERE NAME = #{name}")
	User findByName(@Param("name") String name);
	@Insert("INSERT INTO USERS(NAME, AGE) VALUES(#{name}, #{age})")
	int insert(@Param("name") String name, @Param("age") Integer age);
}

（4）启动类，这里我们直接用的是@MapperScan而没有在每一个接口上用@Mapper

@MapperScan("com.itmayiedu.mapper")
@SpringBootApplication
public class MybatisApp {

	public static void main(String[] args) {
		SpringApplication.run(MybatisApp.class, args);
	}

}

SpringBoot的事务管理，整合@transactional

单数据源的情况下，SpringBoot默认集成事务，只要在方法上或者类的上面加上@Transactional即可，默认就是开启的
事务分为声明事务和编程事务
声明事务是根据编程事务来的（编程事务就是指的是手动commit等）
事务的原理就是使用AOP的环绕通知进行拦截
使用Spring事务的注意事项就是不要进行try-catch，需要将异常抛出给外层，让异常的AOP可以捕获到，进行rollback
推荐使用注解版本的事务，即@transactional

SpringBoot多数据源

在一个项目中有不同库的JDBC连接，理论上可以有无限个连接，具体的实际情况依赖于内存的大小
垂直拆分和水平拆分：

垂直拆分属于分库，水平拆分属于分表

多数据源应该如何去划分？

根据包来进行划分，就是说包名不同，数据源不同，分包（根据业务来的）
使用注解的方式划分多数据源
一般情况下根据分包用的比较多：
（1）com.xiyou.test01----datasource01
（2）com.xiyou.test02----datasource02
有点类似于多个不同的jar包，多个不同的业务需求，存放在同一个项目中
不推荐使用注解的方式实现多数据源，太麻烦

使用分包的方式实现拆分数据源

不同的数据源建立不同的包
application.properties中也要自己去实现数据库的连接，不能使用默认的数据库连接的key
@Configuration表示是一个配置信息，将其注册到Spring中
如果我们要加载mapping文件的时候需要加上

bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/test1/*.xml"));

不同数据源的xml文件（mapping文件）写在不同的数据源配置方法中

在这里插入图片描述

（重要）SpringBoot的2.0版本，即使我们不写@Primary也不会报错。在SpringBoot1.5等版本的时候，如果不指定主数据源（默认数据源）的时候就会报错
java代码实现：
（1）代码架构:

这里以不同的包进行区分，不同的包名下链接不同的数据源
（2）application.properties

server.port=8081

###datasource1 数据源1
spring.datasource.test1.driver-class-name = com.mysql.jdbc.Driver
spring.datasource.test1.jdbc-url = jdbc:mysql://localhost:3307/test?useUnicode=true&characterEncoding=utf-8
spring.datasource.test1.username = root
spring.datasource.test1.password = root

###datasource2 数据源2
spring.datasource.test2.driver-class-name = com.mysql.jdbc.Driver
spring.datasource.test2.jdbc-url = jdbc:mysql://localhost:3307/test_rc?useUnicode=true&characterEncoding=utf-8
spring.datasource.test2.username = root
spring.datasource.test2.password = root

（3）config配置（重要）

DataSourceConfig1:链接一个数据库

package com.xiyou.datasource.config;

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.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

@Configuration
// 表示mapper1包由test1SqlSessionFactory数据源注入
@MapperScan(basePackages = "com.xiyou.datasource.mapper.mapper1", sqlSessionFactoryRef = "test1SqlSessionFactory")
public class DataSourceConfig1 {

    /**
     * 规定bean的名字，设置注入的数据来源
     * @return
     */
    @Bean(name = "test1DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.test1")
    public DataSource testDataSource1(){
        return DataSourceBuilder.create().build();
    }

    /**
     * 创建sqlSessionFactory，将自定义的数据源进行注入
     * @param dataSource
     * @return
     */
    @Bean("test1SqlSessionFactory")
    @Primary
    public SqlSessionFactory test1SqlSessionFactory(@Qualifier("test1DataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        // 如果使用的是xml的形式写sql的话，需要加上下面的配置
        // bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mapper1/test1/*.xml"));
        return bean.getObject();
    }

    /**
     * 注入事务的管理
     * @param dataSource
     * @return
     */
    @Bean(name = "test1TransactionManager")
    public DataSourceTransactionManager transactionManager(@Qualifier("test1DataSource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     * SqlSession模板生成
     * @return
     */
    @Bean(name = "test1SqlSessionTemplate")
    @Primary
    public SqlSessionTemplate test1SqlSessionTemplate(@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception{
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

DataSourceConfig2:链接另一个数据库

package com.xiyou.datasource.config;

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
// 表示mapper2包由test2SqlSessionFactory数据源注入
@MapperScan(basePackages = "com.xiyou.datasource.mapper.mapper2", sqlSessionFactoryRef = "test2SqlSessionFactory")
public class DataSourceConfig2 {

    /**
     * 规定bean的名字，设置注入的数据来源
     * @return
     */
    @Bean(name = "test2DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.test2")
    public DataSource testDataSource2(){
        return DataSourceBuilder.create().build();
    }

    /**
     * 创建sqlSessionFactory，将自定义的数据源进行注入
     * @param dataSource
     * @return
     */
    @Bean("test2SqlSessionFactory")
    public SqlSessionFactory test2SqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        // 如果使用的是xml的形式写sql的话，需要加上下面的配置
        // bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/test2/*.xml"));
        return bean.getObject();
    }

    /**
     * 注入事务的管理
     * @param dataSource
     * @return
     */
    @Bean(name = "test2TransactionManager")
    public DataSourceTransactionManager transactionManager(@Qualifier("test2DataSource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     * SqlSession模板生成
     * @return
     */
    @Bean(name = "test2SqlSessionTemplate")
    public SqlSessionTemplate test2SqlSessionTemplate(@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception{
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

UserMapper1

package com.xiyou.datasource.mapper.mapper1;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;

/**
 * 数据源1 对数据库进行操作
 */
public interface User1Mapper {

    @Insert("insert into t_user(userName, age) values(#{name}, #{age})")
    public int addUser(@Param("name") String name, @Param("age") Integer age);
}

UserMapper2

package com.xiyou.datasource.mapper.mapper2;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;

/**
 * 数据源2 对数据库进行操作
 */
public interface User2Mapper {

    @Insert("insert into user2(NAME, pwd) values(#{name}, #{pwd})")
    public int addUser(@Param("name") String name, @Param("pwd") String pwd);
}

UserService1

package com.xiyou.datasource.service;

import org.springframework.transaction.annotation.Transactional;

/**
 * 用户的接口类
 */
@Transactional(transactionManager = "test1TransactionManager")
public interface UserService1 {
    /**
     * 新增用户(数据源1操作)
     * @param name
     * @param age
     */
    public int addUser(String name, Integer age);

}

UserService2

package com.xiyou.datasource.service;

import org.springframework.transaction.annotation.Transactional;

/**
 * 用户的接口类
 */
@Transactional(transactionManager = "test2TransactionManager")
public interface UserService2 {
    /**
     * 新增用户（数据源2操作）
     * @param name
     * @param pwd
     * @return
     */
    public int addUser(String name, String pwd);
}

UserService1Impl

package com.xiyou.datasource.service.impl;

import com.xiyou.datasource.mapper.mapper1.User1Mapper;
import com.xiyou.datasource.service.UserService1;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


/**
 * 数据源1的实现
 */
@Service
public class UserService1Impl implements UserService1 {

    @Autowired
    private User1Mapper user1Mapper;

    @Override
    public int addUser(String name, Integer age) {
        int i = user1Mapper.addUser(name, age);
        int a = 1/0;
        return i;
    }
}

UserService2Impl

package com.xiyou.datasource.service.impl;

import com.xiyou.datasource.mapper.mapper2.User2Mapper;
import com.xiyou.datasource.service.UserService2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 数据源2的实现
 */
@Service
public class UserService2Impl implements UserService2 {

    @Autowired
    private User2Mapper user2Mapper;

    @Override
    public int addUser(String name, String pwd) {
        int i = user2Mapper.addUser(name, pwd);
        return i;
    }
}

启动类

package com.xiyou.datasource;


import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
// 扫描指定包
@MapperScan(basePackages = {"com.xiyou.datasource.mapper"})
public class MyDatasourceApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyDatasourceApplication.class, args);
    }

}

多数据源事务管理机制（代码上面已经实现）

不同的数据库（不同的数据源），如果不使用全局事务管理器（分布式事务），就应该使用多个事务
多数据源的情况下使用事务必须指明使用的是哪一个数据源的事务，否则会因为不知道使用哪一个事务报错。
在多数据的情况下，使用@Transactional注解的时候，应该指明事务的管理者（就是指明使用哪一个数据库事务）

@Transactional(transactionManager = "test2TransactionManager")

多数据源分布式事务

同一个事务下有多个数据源的连接，事务要控制多个数据源的提交与回滚

如上述代码所示的话，因为一个方法中有数据源1和数据源2，但是事务只能管理数据源2，因此数据源1可以成功入库，数据源2则会回滚。
传统的分布式事务解决方案jta+atomikos：将多个数据源事务，注册到同一个全局事务中（几乎不用，了解下行了，性能非常不好，一般就用在多数据源项目，微服务项目中一定不去使用）

使用jta+atomikos解决多数据源下的分布式事务

新增pom依赖

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

配置文件

# Mysql 1
mysql.datasource.test1.url = jdbc:mysql://localhost:3306/test01?useUnicode=true&characterEncoding=utf-8
mysql.datasource.test1.username = root
mysql.datasource.test1.password = root

mysql.datasource.test1.minPoolSize = 3
mysql.datasource.test1.maxPoolSize = 25
mysql.datasource.test1.maxLifetime = 20000
mysql.datasource.test1.borrowConnectionTimeout = 30
mysql.datasource.test1.loginTimeout = 30
mysql.datasource.test1.maintenanceInterval = 60
mysql.datasource.test1.maxIdleTime = 60



# Mysql 2
mysql.datasource.test2.url =jdbc:mysql://localhost:3306/test02?useUnicode=true&characterEncoding=utf-8
mysql.datasource.test2.username =root
mysql.datasource.test2.password =root

mysql.datasource.test2.minPoolSize = 3
mysql.datasource.test2.maxPoolSize = 25
mysql.datasource.test2.maxLifetime = 20000
mysql.datasource.test2.borrowConnectionTimeout = 30
mysql.datasource.test2.loginTimeout = 30
mysql.datasource.test2.maintenanceInterval = 60
mysql.datasource.test2.maxIdleTime = 60

实体类（DBConfig1）

@Data
@ConfigurationProperties(prefix = "mysql.datasource.test1")
public class DBConfig1 {

	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;
}

实体类（DBConfig2）

@Data
@ConfigurationProperties(prefix = "mysql.datasource.test2")
public class DBConfig2 {

	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;
}

MybatisConfig1

@Configuration
// basePackages 最好分开配置 如果放在同一个文件夹可能会报错
@MapperScan(basePackages = "com.itmayiedu.test01", sqlSessionTemplateRef = "testSqlSessionTemplate")
public class MyBatisConfig1 {

	// 配置数据源
	@Primary
	@Bean(name = "testDataSource")
	public DataSource testDataSource(DBConfig1 testConfig) throws SQLException {
		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
		mysqlXaDataSource.setUrl(testConfig.getUrl());
		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
		mysqlXaDataSource.setPassword(testConfig.getPassword());
		mysqlXaDataSource.setUser(testConfig.getUsername());
		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);

		AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
		xaDataSource.setXaDataSource(mysqlXaDataSource);
		xaDataSource.setUniqueResourceName("testDataSource");

		xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
		xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
		xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
		xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
		xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
		xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
		xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
		xaDataSource.setTestQuery(testConfig.getTestQuery());
		return xaDataSource;
	}

	@Primary
	@Bean(name = "testSqlSessionFactory")
	public SqlSessionFactory testSqlSessionFactory(@Qualifier("testDataSource") DataSource dataSource)
			throws Exception {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(dataSource);
		return bean.getObject();
	}

	@Primary
	@Bean(name = "testSqlSessionTemplate")
	public SqlSessionTemplate testSqlSessionTemplate(
			@Qualifier("testSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
		return new SqlSessionTemplate(sqlSessionFactory);
	}
}

MybatisConfig2


@Configuration
@MapperScan(basePackages = "com.itmayiedu.test02", sqlSessionTemplateRef = "test2SqlSessionTemplate")
public class MyBatisConfig2 {

	// 配置数据源
	@Bean(name = "test2DataSource")
	public DataSource testDataSource(DBConfig2 testConfig) throws SQLException {
		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
		mysqlXaDataSource.setUrl(testConfig.getUrl());
		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
		mysqlXaDataSource.setPassword(testConfig.getPassword());
		mysqlXaDataSource.setUser(testConfig.getUsername());
		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);

		AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
		xaDataSource.setXaDataSource(mysqlXaDataSource);
		xaDataSource.setUniqueResourceName("test2DataSource");

		xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
		xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
		xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
		xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
		xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
		xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
		xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
		xaDataSource.setTestQuery(testConfig.getTestQuery());
		return xaDataSource;
	}

	@Bean(name = "test2SqlSessionFactory")
	public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource)
			throws Exception {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(dataSource);
		return bean.getObject();
	}

	@Bean(name = "test2SqlSessionTemplate")
	public SqlSessionTemplate testSqlSessionTemplate(
			@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
		return new SqlSessionTemplate(sqlSessionFactory);
	}
}

启动的时候需要给启动类加上

@EnableConfigurationProperties(value = {DBConfig1.class. DBConfig2.class})

红烧咸鱼丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
微服务框架（3）----基于SpringBoot2.0版本框架-多数据源分布式事务管理(jta+atomikos)

SpringBoot整合MyBatis可以不在mapper层加上@Mapper，直接加@MapperScan(basePackages={})扫包，若有多个包，用逗号隔开推荐使用@MapperScan的方式SpringBoot的事务管理，整合@transactional单数据源的情况下，SpringBoot默认集成事务，只要在方法上或者类的上面加上@Transactional即可，默...
复制链接

扫一扫

专栏目录