跨库事务管理器
本文介绍如何编写一个跨库的事务管理器，通过best effort 1pc模式在spring DataSourceTransactionManager的基础上改造出一个能够支持多数据源事务的事务管理器。
一、多数据源配置+事务管理器配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<context:annotation-config/>
<context:component-scan base-package="com.handserome.test.dao"/>
<!--直接配置数据库连接1-->
<bean id="testDbDs1" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/test"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
<!-- 配置初始化大小、最小、最大 -->
<property name="initialSize" value="5" />
<property name="minIdle" value="10" />
<property name="maxActive" value="20" />
</bean>
<!--直接配置数据库连接2-->
<bean id="testDbDs2" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/test1"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
<!-- 配置初始化大小、最小、最大 -->
<property name="initialSize" value="5" />
<property name="minIdle" value="10" />
<property name="maxActive" value="20" />
</bean>
<bean id="shardRegister"
class="com.handserome.daat.datasource.DefaultDbShardRegister">
<property name="dbShardInfos">
<set>
<!-- 测试库1 -->
<bean class="com.handserome.daat.datasource.DbShardInfo">
<property name="id" value="db1"/>
<property name="dataSource" ref="testDbDs1"/>
<property name="description" value="测试1库数据源"/>
</bean>
<!-- 测试库1 -->
<bean class="com.handserome.daat.datasource.DbShardInfo">
<property name="id" value="db2"/>
<property name="dataSource" ref="testDbDs2"/>
<property name="description" value="测试2库数据源"/>
</bean>
</set>
</property>
</bean>
<!-- DAL客户端接口实现 -->
<bean id="sqlSession"
class="com.handserome.daat.session.DbShardSqlSession">
<property name="dbShardRegister" ref="shardRegister"/>
<property name="sqlMapConfigLocation" value="classpath*:conf/sqlMap/sqlMap_*.xml"/>
</bean>
<!-- 事务配置 -->
<bean id="transactionManager"
class="com.handserome.daat.transaction.MultiDataSourceTransactionManager">
<property name="dbShardRegister" ref="shardRegister"/>
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>
<bean id="studentDao1" class="com.handserome.test.dao.StudentDaoImpl1">
<property name="sqlSession" ref="sqlSession"/>
</bean>
</beans>
二、多数据源事务管理器
/**
* 功能描述：多数据源事务管理器<br>
* 采用Best Effort 1PC Pattern的事务策略
*
* @author handersome
*/
public class MultiDataSourceTransactionManager implements PlatformTransactionManager, InitializingBean {
private final Logger logger = LoggerFactory.getLogger(MultiDataSourceTransactionManager.class);
/**
* 各个数据源对应的事务管理器列表
*/
private List<DataSourceTransactionManager> transactionManagers;
/**
* 分库注册配置信息
*/
private DbShardRegister dbShardRegister;
public DbShardRegister getDbShardRegister() {
return dbShardRegister;
}
public void setDbShardRegister(DbShardRegister dbShardRegister) {
this.dbShardRegister = dbShardRegister;
}
/**
*
* 功能描述: 获取事务 每个数据源对应的事务管理器从数据源中拿到connection，并且关闭了connection的自动提交
*
* @param definition
* @return
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
@Override
public MultiTransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
// 所有数据源事务管理里共用一个MultiTransactionStatus，因此取第0个即可
MultiTransactionStatus mts = new MultiTransactionStatus(transactionManagers.get(0));
// 判断当前线程的事务同步器是否存在
if (!TransactionSynchronizationManager.isSynchronizationActive()) {
// 创建当前线程的事务同步器
TransactionSynchronizationManager.initSynchronization();
mts.setNewSynchronization();
}
try {
// 遍历所有数据源的事务管理器
for (DataSourceTransactionManager transactionManager : transactionManagers) {
System.out.println(transactionManager.toString());
// 将各数据源事务管理器注册到多事务状态中
mts.registerTransactionManager(definition, transactionManager);
}
} catch (RuntimeException ex) {
// key 具体数据源对应的事务管理器，value 该事务管理器的事务
Map<DataSourceTransactionManager, TransactionStatus> transactionStatuses = mts.getTransactionStatuses();
// 对各个具体的数据源事务管理器进行回滚
for (DataSourceTransactionManager transactionManager : transactionManagers) {
try {
if (transactionStatuses.get(transactionManager) != null) {
// 获取当前事务管理器对应的具体事务
transactionManager.rollback(transactionStatuses.get(transactionManager));
}
} catch (Exception ex2) {
logger.warn("Rollback exception (" + transactionManager + ") " + ex2.getMessage(), ex2);
}
}
// 发生异常清空当前线程的事务同步器
if (mts.isNewSynchronization()) {
TransactionSynchronizationManager.clear();
}
throw new CannotCreateTransactionException(ex.getMessage(), ex);
}
return mts;
}
/**
* 功能描述：提交操作<br>
*/
@Override
public void commit(TransactionStatus status) throws TransactionException {
MultiTransactionStatus multiTransactionStatus = (MultiTransactionStatus) status;
boolean commit = true;
Exception commitException = null;
PlatformTransactionManager commitExceptionTransactionManager = null;
// 反转事务管理器列表
Iterable<DataSourceTransactionManager> reverseManagerList = reverse(transactionManagers);
// 遍历所有数据源的事务管理器
for (DataSourceTransactionManager transactionManager : reverseManagerList) {
// 获取数据源对应的事务
TransactionStatus transactionStatus = multiTransactionStatus.getTransactionStatus(transactionManager);
// 如果存在某个数据源提交失败，后续不再提交
if (commit) {
try {
transactionManager.commit(transactionStatus);
} catch (Exception ex) {
commit = false;
commitException = ex;
// 发生异常的事务管理器
commitExceptionTransactionManager = transactionManager;
}
} else {
// 后面的事务回滚
try {
transactionManager.rollback(transactionStatus);
} catch (Exception ex) {
logger.warn("Rollback exception (after commit) (" + transactionManager + ") " + ex.getMessage(),
ex);
}
}
}
if (multiTransactionStatus.isNewSynchronization()) {
TransactionSynchronizationManager.clear();
}
if (commitException != null) {
// 判断是否是第一个事务管理器提交就失败
boolean firstTransactionManagerFailed = commitExceptionTransactionManager == getLastTransactionManager();
int transactionState = firstTransactionManagerFailed ? HeuristicCompletionException.STATE_ROLLED_BACK
: HeuristicCompletionException.STATE_MIXED;
throw new HeuristicCompletionException(transactionState, commitException);
}
}
/**
* 功能描述：回滚操作<br>
*/
@Override
public void rollback(TransactionStatus status) throws TransactionException {
Exception rollbackException = null;
DataSourceTransactionManager rollbackExceptionTransactionManager = null;
MultiTransactionStatus multiTransactionStatus = (MultiTransactionStatus) status;
for (DataSourceTransactionManager transactionManager : reverse(transactionManagers)) {
TransactionStatus transactionStatus = multiTransactionStatus.getTransactionStatus(transactionManager);
try {
transactionManager.rollback(transactionStatus);
} catch (Exception ex) {
if (rollbackException == null) {
rollbackException = ex;
rollbackExceptionTransactionManager = transactionManager;
} else {
logger.warn("Rollback exception (" + transactionManager + ") " + ex.getMessage(), ex);
}
}
}
if (multiTransactionStatus.isNewSynchronization()) {
TransactionSynchronizationManager.clear();
}
if (rollbackException != null) {
throw new UnexpectedRollbackException("Rollback exception, originated at ("
+ rollbackExceptionTransactionManager + ") " + rollbackException.getMessage(), rollbackException);
}
}
@Override
public void afterPropertiesSet() {
Assert.notNull(dbShardRegister, "DbShardRegister must not be null!");
transactionManagers = new ArrayList<DataSourceTransactionManager>();
// 遍历所有的数据源，给每个数据源创建一个事务管理器，并加入到事务管理器集合中
for (DbShardInfo dbShardInfo : dbShardRegister.getDbShardInfos()) {
DataSourceTransactionManager txManager = new DataSourceTransactionManager(dbShardInfo.getDataSource());
transactionManagers.add(txManager);
}
}
private <T> Iterable<T> reverse(Collection<T> collection) {
List<T> list = new ArrayList<T>(collection);
Collections.reverse(list);
return list;
}
private PlatformTransactionManager getLastTransactionManager() {
return transactionManagers.get(lastTransactionManagerIndex());
}
private int lastTransactionManagerIndex() {
return transactionManagers.size() - 1;
}
}
三、多事务状态
/**
* 功能描述：多事务状态
*
* @author handersome
*/
class MultiTransactionStatus implements TransactionStatus {
/**
* 主事务管理器
*/
private final DataSourceTransactionManager mainTransactionManager;
/**
* key 数据源对应的事务管理器， value：具体事务
*/
private final Map<DataSourceTransactionManager, TransactionStatus> transactionStatuses = new ConcurrentHashMap<DataSourceTransactionManager, TransactionStatus>();
/**
* 当前线程是否存在
*/
private boolean newSynchronization;
public MultiTransactionStatus(DataSourceTransactionManager mainTransactionManager) {
Assert.notNull(mainTransactionManager, "TransactionManager must not be null!");
this.mainTransactionManager = mainTransactionManager;
}
public void setNewSynchronization() {
this.newSynchronization = true;
}
public boolean isNewSynchronization() {
return newSynchronization;
}
public void registerTransactionManager(TransactionDefinition definition,
DataSourceTransactionManager transactionManager) {
// 获取数据源对应的事务状态
TransactionStatus transaction = transactionManager.getTransaction(definition);
transactionStatuses.put(transactionManager, transaction);
}
/**
*
* 功能描述: 获取事务管理器的当前事务
*
* @param transactionManager
* @return
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
public TransactionStatus getTransactionStatus(DataSourceTransactionManager transactionManager) {
return this.transactionStatuses.get(transactionManager);
}
@Override
public boolean isRollbackOnly() {
return getMainTransactionStatus().isRollbackOnly();
}
@Override
public boolean isCompleted() {
return getMainTransactionStatus().isCompleted();
}
@Override
public boolean isNewTransaction() {
return getMainTransactionStatus().isNewTransaction();
}
@Override
public boolean hasSavepoint() {
return getMainTransactionStatus().hasSavepoint();
}
@Override
public void setRollbackOnly() {
for (TransactionStatus ts : transactionStatuses.values()) {
ts.setRollbackOnly();
}
}
@Override
public Object createSavepoint() throws TransactionException {
SavePoints savePoints = new SavePoints();
for (TransactionStatus transactionStatus : transactionStatuses.values()) {
savePoints.save(transactionStatus);
}
return savePoints;
}
@Override
public void rollbackToSavepoint(Object savepoint) throws TransactionException {
SavePoints savePoints = (SavePoints) savepoint;
savePoints.rollback();
}
@Override
public void releaseSavepoint(Object savepoint) throws TransactionException {
((SavePoints) savepoint).release();
}
@Override
public void flush() {
for (TransactionStatus transactionStatus : transactionStatuses.values()) {
transactionStatus.flush();
}
}
private TransactionStatus getMainTransactionStatus() {
return transactionStatuses.get(mainTransactionManager);
}
public Map<DataSourceTransactionManager, TransactionStatus> getTransactionStatuses() {
return transactionStatuses;
}
/**
* 功能描述：保存点
*
* @author
*/
private static class SavePoints {
private final Map<TransactionStatus, Object> savePoints = new HashMap<TransactionStatus, Object>();
private void addSavePoint(TransactionStatus status, Object savepoint) {
Assert.notNull(status, "TransactionStatus must not be null!");
this.savePoints.put(status, savepoint);
}
private void save(TransactionStatus transactionStatus) {
Object savepoint = transactionStatus.createSavepoint();
addSavePoint(transactionStatus, savepoint);
}
private void rollback() {
for (TransactionStatus transactionStatus : savePoints.keySet()) {
transactionStatus.rollbackToSavepoint(savepointFor(transactionStatus));
}
}
private Object savepointFor(TransactionStatus transactionStatus) {
return savePoints.get(transactionStatus);
}
private void release() {
for (TransactionStatus transactionStatus : savePoints.keySet()) {
transactionStatus.releaseSavepoint(savepointFor(transactionStatus));
}
}
}
}
四、dao层实例
/**
* @author : 18073771
* @see [相关类/方法]（可选）
* @since [产品/模块版本] （可选）
*/
public class StudentDaoImpl implements StudentDao {
private SqlSession sqlSession;
@Transactional
@Override
public void insertTransactionTest() {
insert();
insert1();
}
private void insert() {
Map<String, Object> paramMap = new HashMap<String, Object>();
paramMap.put("studentId", "222");
paramMap.put("name", "bbb");
paramMap.put("dbKey", "db1");
String insert = "student.saveData";
int execute = sqlSession.execute(insert, paramMap);
System.out.println("插入条数" + execute);
}
private void insert1() {
List<Object> objectList = new ArrayList<Object>();
Student student = new Student();
student.setStudentId("7878");
student.setName("7878");
student.setCreateTime(new Timestamp(new java.util.Date().getTime()));
student.setDbKey("db2");
objectList.add(student);
Student student1 = new Student();
student1.setStudentId("78781");
student1.setName("78781");
student1.setDbKey("db2");
student1.setCreateTime(new Timestamp(new java.util.Date().getTime()));
objectList.add(student1);
String insert = "student.saveData";
int i = sqlSession.batchUpdate(insert, objectList);
System.out.println("插入条数" + i);
}
public SqlSession getSqlSession() {
return sqlSession;
}
public void setSqlSession(SqlSession sqlSession) {
this.sqlSession = sqlSession;
}
}
五、测试方法
public class JdbcTemplateTest {
public static void main(String[] args) throws InterruptedException {
// 默认，非分库
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:spes-da-shard.xml");
StudentDao studentDao = (StudentDao) context.getBean("studentDao1");
studentDao.insertTransactionTest();
multiThreadTest(context);
}
private static void multiThreadTest(ClassPathXmlApplicationContext context) throws InterruptedException {
final StudentDao studentDao = (StudentDao) context.getBean("studentDao1");
studentDao.insertTransactionTest();
for (int i = 0; i < 10000; i++) {
final Thread thread = new Thread(new Runnable() {
@Override
public void run() {
studentDao.insertTransactionTest();
}
});
thread.start();
}
}
}