springboot分散式事務管理（atomikos）

阿新 • • 發佈：2018-12-30

最近公司有用到分散式事務管理，結合公司和我上網查詢的一些資料，特來梳理一下我思路。

本篇文章使用時（atomikos）來進行springboot的分散式事務管理

1.引用jta-atomikos架包

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

2,首先配置資料來源，因為是要演示分散式事務管理所以要配置多個數據源（2個）

# 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.datasource.test1.testQuery = select 1


# 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
mysql.datasource.test2.testQuery = select 1

3，配置讀取資料庫屬性檔案

DBConfig1.java

package com.itmayiedu.config;

import org.springframework.boot.context.properties.ConfigurationProperties;

@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;
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public int getMinPoolSize() {
		return minPoolSize;
	}
	public void setMinPoolSize(int minPoolSize) {
		this.minPoolSize = minPoolSize;
	}
	public int getMaxPoolSize() {
		return maxPoolSize;
	}
	public void setMaxPoolSize(int maxPoolSize) {
		this.maxPoolSize = maxPoolSize;
	}
	public int getMaxLifetime() {
		return maxLifetime;
	}
	public void setMaxLifetime(int maxLifetime) {
		this.maxLifetime = maxLifetime;
	}
	public int getBorrowConnectionTimeout() {
		return borrowConnectionTimeout;
	}
	public void setBorrowConnectionTimeout(int borrowConnectionTimeout) {
		this.borrowConnectionTimeout = borrowConnectionTimeout;
	}
	public int getLoginTimeout() {
		return loginTimeout;
	}
	public void setLoginTimeout(int loginTimeout) {
		this.loginTimeout = loginTimeout;
	}
	public int getMaintenanceInterval() {
		return maintenanceInterval;
	}
	public void setMaintenanceInterval(int maintenanceInterval) {
		this.maintenanceInterval = maintenanceInterval;
	}
	public int getMaxIdleTime() {
		return maxIdleTime;
	}
	public void setMaxIdleTime(int maxIdleTime) {
		this.maxIdleTime = maxIdleTime;
	}
	public String getTestQuery() {
		return testQuery;
	}
	public void setTestQuery(String testQuery) {
		this.testQuery = testQuery;
	}
	
}

DBConfig2.java

package com.itmayiedu.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
								
@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;
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public int getMinPoolSize() {
		return minPoolSize;
	}
	public void setMinPoolSize(int minPoolSize) {
		this.minPoolSize = minPoolSize;
	}
	public int getMaxPoolSize() {
		return maxPoolSize;
	}
	public void setMaxPoolSize(int maxPoolSize) {
		this.maxPoolSize = maxPoolSize;
	}
	public int getMaxLifetime() {
		return maxLifetime;
	}
	public void setMaxLifetime(int maxLifetime) {
		this.maxLifetime = maxLifetime;
	}
	public int getBorrowConnectionTimeout() {
		return borrowConnectionTimeout;
	}
	public void setBorrowConnectionTimeout(int borrowConnectionTimeout) {
		this.borrowConnectionTimeout = borrowConnectionTimeout;
	}
	public int getLoginTimeout() {
		return loginTimeout;
	}
	public void setLoginTimeout(int loginTimeout) {
		this.loginTimeout = loginTimeout;
	}
	public int getMaintenanceInterval() {
		return maintenanceInterval;
	}
	public void setMaintenanceInterval(int maintenanceInterval) {
		this.maintenanceInterval = maintenanceInterval;
	}
	public int getMaxIdleTime() {
		return maxIdleTime;
	}
	public void setMaxIdleTime(int maxIdleTime) {
		this.maxIdleTime = maxIdleTime;
	}
	public String getTestQuery() {
		return testQuery;
	}
	public void setTestQuery(String testQuery) {
		this.testQuery = testQuery;
	}
	
}

4,配置TestMyBatisConfig1，TestMyBatisConfig2，將兩個資料來源放入atomikos進行一個管理

TestMyBatisConfig1

package com.itmayiedu.datasource;

import java.sql.SQLException;

import javax.sql.DataSource;

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.jta.atomikos.AtomikosDataSourceBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import com.itmayiedu.config.DBConfig1;
import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;

@Configuration
@MapperScan(basePackages = "com.itmayiedu.test01", sqlSessionTemplateRef = "testSqlSessionTemplate")
public class TestMyBatisConfig1 {

	// 配置資料來源
	@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);
	}
}

TestMyBatisConfig2

package com.itmayiedu.datasource;

import java.sql.SQLException;

import javax.sql.DataSource;

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.jta.atomikos.AtomikosDataSourceBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.itmayiedu.config.DBConfig1;
import com.itmayiedu.config.DBConfig2;
import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;

@Configuration
//basePackages 最好分開配置 如果放在同一個資料夾可能會報錯
@MapperScan(basePackages = "com.itmayiedu.test02", sqlSessionTemplateRef = "testSqlSessionTemplate2")
public class TestMyBatisConfig2 {

	// 配置資料來源
	@Bean(name = "testDataSource2")
	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("testDataSource2");

		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 = "testSqlSessionFactory2")
	public SqlSessionFactory testSqlSessionFactory(@Qualifier("testDataSource2") DataSource dataSource)
			throws Exception {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(dataSource);
		return bean.getObject();
	}

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

外加附上service層程式碼

package com.itmayiedu.test01.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.itmayiedu.entity.UserEntity;
import com.itmayiedu.test01.mapping.UserMapper1;
import com.itmayiedu.test02.mapping.UserMapper2;

@Service
public class UserService1 {
	@Autowired
	private UserMapper1 userMapper1;
	
	@Autowired
	private UserMapper2 userMapper2;
	
	@Transactional
	 public int addUser1 (UserEntity userEntity){
		 userMapper2.addUser(userEntity.getName(), userEntity.getAge());
		 userMapper1.addUser(userEntity.getName(), userEntity.getAge());
		 return 1;
	 }
}

其他的地方不需改動，到此已經結束。希望可以幫助到各位同學，寫得有錯誤的地方，希望各位同學可以指證出來。謝謝！

springboot分散式事務管理（atomikos）

最近公司有用到分散式事務管理，結合公司和我上網查詢的一些資料，特來梳理一下我思路。本篇文章使用時（atomikos）來進行springboot的分散式事務管理 1.引用jta-atomikos架包 <dependency> <groupId>

Spring 聲明式事務管理（11）

fault cep 維護 eat ati 信息圖書管理 rem tro 案例分析　　本案例是圖書管理系統精簡部分，在數據庫中有3張表。分別保存圖書庫存、圖書信息和用戶信息。下面是建表SQL語句 1 DROP TABLE IF EXISTS store; 2 DR

springCloud分散式事務實戰（七）改造合服務BlockMicroService支援分散式事務

在BlockMicroService 工程中加入（1）加入jar  <dependency> <groupId>com.codingapi</groupId>

springCloud分散式事務實戰（六）編寫第二個微服務

（1）建立工程（2）新增 jar pom.xml新增:springboot 父， mysql連線，(mybatis， spring-mybatis springboot ,阿里連線池) ,服務中心客戶端。 <project xmlns="http://maven.apache.org/POM/4.

微服務分散式事務實戰（四）分散式事務處理器的下載，編譯和執行

分散式事務處理器的下載，編譯和執行（1）下載分散式事務處理器工程原始碼 https://github.com/codingapi/tx-lcn/ （2）匯入eclipse （3）修改配置檔案填寫分散式事務伺服器地址，redis地址，註冊中心地址 ################

微服務分散式事務實戰（一）專案需求描述和實現步驟

本文通過一個具體例項如何實施springCloud 分散式事務，不對分散式事務理論做探索。由於內容較多，分多個小節來說明案例需求：建立2個基於springCloud的微服務，分別訪問不同的資料庫；然後建立一個整合服務，呼叫微服務實現資料的儲存到2個不同的資料庫，要求採用分散式事務，要麼都

微服務分散式事務實戰（五）準備資料庫和建立第一個微服務

1)資料庫準備在資料庫中mysql 分別建立2個數據庫forum1和forum2 forum1 下建立表block forum2下建立表Theme sql程式碼如下： 1 資料庫1Forum1: CREATE DATABASE IF NOT EXISTS forum1; USE forum

微服務分散式事務實戰（三）SpringCloud註冊中心編寫和測試

SpringCloud註冊中心編寫和測試（1）建立註冊中心工程（2）新增jar包 pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLS

SpringCloud分散式事務實戰（七）在微服務1中建立整合函式，呼叫微服務2

（1）新增jar pom.xml <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-s

springCloud分散式事務實戰（十）分散式事務綜合大測試（全，共10篇）

啟動註冊中心，啟動redis ,啟動事務管理器啟動mysql 啟動微服務1 ，啟動微服務2（1）正常事務測試：不丟擲異常，兩邊都插入 1 設計沒有故障整合服務@TxTransaction(isStart=true) //關鍵 4 @Overridebr/>@Transactionalpublic

springCloud分散式事務實戰（九）改造ThemeMicroService 支援分散式事務

（1）新增jar  <dependency> <groupId>com.codingapi</groupId> <artifa

MySQL——事務管理（重點）、檢視、使用者管理

在我們剛開始學習資料庫的時候就認識到了SQL的分類總共有三種DDL、DML、DCL，前面的學習已經用到了DDL、DML，今天的事務管理將用到DCL，資料控制語言，主要負責許可權管理和事務。一、事務的概念事

python分散式事務方案（二）基於訊息最終一致性

python分散式事務方案（二）基於訊息最終一致性上一章採用的是tcc方案，但是在進行批量操作時，比如說幾百臺主機一起分配策略時，會執行很長時間，這時體驗比較差。由於zabbix隱藏域後臺，而這個慢主要是集中在呼叫zabbix介面，這裡我們就基於訊息最終一致性來進行優化訊息一致性方案是通過

python分散式事務方案（一）tcc

python分散式事務方案（一）tcc 隨著單體應用的拆分以及服務化的流行，現在分散式事務已經比較常見，分散式事務理論ACID、CAP、BASE等我就不說了，現在就直接說一下一種常見的解決方案-tcc TCC 其實就是採用的補償機制，其核心思想是：針對每個操作，都要註冊一個與其對應的確認和補償（

SpringBoot全域性日誌管理（AOP）

1、在pom.xml中引入aop的jar包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</

8.spring：事務管理（上）:Spring的資料庫程式設計、程式設計式事務管理

Spring的資料庫程式設計 Spring框架提供了JDBC模板模式------>JdbcTemplate 簡化了開發，在開發中並不經常是使用實際開發更多使用的是Hibernate和MyBatis 1).Spring JDBCp配置如果使用Spring JDBC操作資料庫，要有

9.spring：事務管理（下）:宣告式事務管理

宣告式事務管理 sprin的宣告式事務是管理AOP技術實現的事務管理，其本質是是對方法前後進行攔截，然後在目標方法開始之前建立或者加入一個事務，在執行完成目標方法之後根據執行情況提交或者回滾事務。宣告式事務管理優點：不需要通過程式設計的方式管理事務，因而不需要在業務邏輯程

LCN基於Spring cloud2.0實現分散式事物管理（一）LCN的修改和部署

首先，對專案進行編譯，裝好maven環境，jdk環境。命令如下，注意這裡需要jdk1.8以上 mvn install -Dmaven.test.skip=true 打包之後，將編譯好的jar包上傳到自己的私服。獲取最新的tx-manager的jar

Netty遊戲伺服器實戰開發(8):利用redis或者zookeeper實現3pc分散式事務鎖（二）。支撐騰訊系列某手遊百萬級流量公測

導讀：在上篇文章中介紹了分散式事務專案的基本原理和工程元件，我們瞭解到了分散式事務的理論知識。處於實戰的經驗，我們將理論知識使用到實際專案中。所以我們將藉助idea中maven工程來實戰我們的專案。回到正文：在上篇文章中我們已經把需要的準備工作做好了。現在

Spring框架的事務管理之程式設計式的事務管理（瞭解）

1. 說明：Spring為了簡化事務管理的程式碼:提供了模板類 TransactionTemplate，所以手動程式設計的方式來管理事務，只需要使用該模板類即可！ 2. 手動程式設計方式的具體步驟如下： 1. 步驟一:配置一個事務管理器，Spring使用PlatformT

springboot分散式事務管理（atomikos）

相關推薦