Spring 中集成 JOTM 配置 JTA 事务

最新推荐文章于 2022-08-19 14:01:30 发布

cndone

最新推荐文章于 2022-08-19 14:01:30 发布

阅读量175

点赞数

CC 4.0 BY-SA版权

分类专栏： MVC+ORM WebServer 文章标签： java 数据库

本文链接：https://blog.youkuaiyun.com/cndone/article/details/84121105

WebServer 同时被 2 个专栏收录

32 篇文章

订阅专栏

MVC+ORM

29 篇文章

订阅专栏

本文详细介绍了如何在Spring框架中集成Objectweb开源JTA实现JOTM，配置JTA事务管理以实现跨数据库的事务一致性。通过在Spring中引入JOTM相关组件和配置文件，实现对不同数据库操作的事务回滚，确保业务逻辑的正确性和数据一致性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Spring 中集成 JOTM 配置 JTA 事务：

假如业务中要用到多个数据库，我们希望在业务方法中，当对某一个数据库的数据表进行操作的事务失败并回退（rollback），另外某一个数据库的数据表的操作事务也要回退，但应用一般的事务管理达不到这样的事务管理效果，这就需要实现 JTA 事务管理了。
这里我们在SPring中集成 Object web 的一个开源JTA实现JOTM (可以在http://jotm.objectweb.org 下载完整版) 来实现JTA事务管理。

1、将必须的类包放入类路径中：
jotm.jar, xapool.jar, jotm_jrmp_stubs.jar, jta-spect1_0_1.jar, connector-1_5.jar等等。

2、编写JOTM配置文件carol.properties，将其放到类路径下：

Java代码

#JNDI调用协议
carol.protocols=jrmp
#不使用CAROL JNDI封装器
carol.start.jndi= false
#不启动命名服务器
carol.start.ns= false

3、在MYSQL中创建两个数据库 "jtatesta","jtatestb"：

Java代码

CREATE DATABASE IF NOT EXISTS jtatesta;
USE jtatesta;
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`user_id` int ( 10 ) unsigned NOT NULL auto_increment,
`user_name` varchar( 45 ) NOT NULL,
`user_password` varchar( 45 ) NOT NULL,
PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT= 5 DEFAULT CHARSET=latin1;
INSERT INTO `user` (`user_id`,`user_name`,`user_password`) VALUES
( 1 , 'tufu' , 'tufu' );
CREATE DATABASE IF NOT EXISTS jtatestb;
USE jtatestb;
DROP TABLE IF EXISTS `grade`;
CREATE TABLE `grade` (
`grade_id` int ( 10 ) unsigned NOT NULL auto_increment,
`user_id` int ( 10 ) unsigned NOT NULL,
`grade` double NOT NULL,
PRIMARY KEY (`grade_id`)
) ENGINE=InnoDB AUTO_INCREMENT= 9 DEFAULT CHARSET=latin1;
INSERT INTO `grade` (`grade_id`,`user_id`,`grade`) VALUES
( 1 , 0 , 100 );

4、域对象、数据访问类和其他事务管理的一样，如：

Java代码

//Domain对象User.java:
package com.domain;
import java.io.Serializable;
public class User implements Serializable {
private int user_id;
private String user_name;
private String user_password;
...... //省略set、get方法
}
//Domain对象Grade.java:
package com.domain;
import java.io.Serializable;
public class Grade implements Serializable{
private int grade_id;
private User user;
private double grade;
..... //省略set、get方法
}
应用Spring JDBC的DAO：(省略DAO接口)
//UserJdbcDao.java:
package com.dao.jdbc;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import com.dao.UserDao;
import com.domain.User;
public class UserJdbcDao extends JdbcDaoSupport implements UserDao{
public void addUser(User user){
String SQL = "INSERT INTO user(user_id,user_name,user_password) VALUES(?,?,?)" ;
Object[] params = new Object[]{
user.getUser_id(),user.getUser_name(),user.getUser_password()
};
this .getJdbcTemplate().update(SQL, params);
}
}
//GradeJdbcDao.java:
package com.dao.jdbc;
import com.dao.GradeDao;
import com.domain.Grade;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
public class GradeJdbcDao extends JdbcDaoSupport implements GradeDao{
public void addGrade(Grade grade){
final String SQL = "INSERT INTO grade(user_id,grade) VALUES(?,?)" ;
Object[] params = new Object[]{
grade.getUser().getUser_id(),grade.getGrade()
};
this .getJdbcTemplate().update(SQL, params);
}
}

5、应用了JTA事务管理的业务类(省略了接口)，用@Transactional注解标注，以在配置文件中可以用<tx:annotation-driven>注解驱动自动进行事务增强：

Java代码

package com.service.impl;
import com.dao.GradeDao;
import com.dao.UserDao;
import com.domain.*;
import org.springframework.transaction.annotation.Transactional;
import com.service.MyService;
@Transactional
public class MyServiceImpl implements MyService {
private UserDao userDao;
private GradeDao gradeDao;
public void setUserDao(UserDao userDao){
this .userDao = userDao;
}
public void setGradeDao(GradeDao gradeDao){
this .gradeDao = gradeDao;
}
@Transactional (readOnly= false )
public void addGrade(User user,Grade grade){
//假如希望两个添加数据的事务，其中有一个添加失败时，均回滚，
//由于两个操作是在两个不同的数据库上进行的，故要JTA事务来进行管理
//否则，将会出现添加一个，回滚一个的情形
gradeDao.addGrade(grade);
userDao.addUser(user);
}
}

6、spring为JOTM提供了一个org.springframework.transaction.jta.JotmFactoryBean 支持类，可以用其方便地创建本地JOTM实例。
具体的配置文件app_jta.xml如下：

Xml代码

<? xml version = "1.0" encoding = "UTF-8" ?>
< beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsp = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop = "http://www.springframework.org/schema/aop"
xmlns:tx = "http://www.springframework.org/schema/tx"
xsp:schemaLocation ="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.0.xsd" >
< bean id = "jotm" class = "org.springframework.transaction.jta.JotmFactoryBean" />
< bean id = "txManager" class = "org.springframework.transaction.jta.JtaTransactionManager" >
< property name = "userTransaction" ref = "jotm" />
</ bean >
<!--XAPool配置，内部包含了一XA数据源，对应了数据库jtatesta
支持JTA事务的数据源，必须封装成XAPool-- >
< bean id = "jtaTestADS" class = "org.enhydra.jdbc.pool.StandardXAPoolDataSource"
destroy-method = "shutdown" >
< property name = "dataSource" >
< bean class = "org.enhydra.jdbc.standard.StandardXADataSource"
destroy-method = "shutdown" >
< property name = "transactionManager" ref = "jotm" />
< property name = "driverName" value = "com.mysql.jdbc.Driver" />
< property name = "url" value = "jdbc:mysql://localhost/jtatesta" />
</ bean >
</ property >
< property name = "user" value = "root" />
< property name = "password" value = "885123" />
</ bean >
< bean id = "jtaTestBDS" class = "org.enhydra.jdbc.pool.StandardXAPoolDataSource"
destroy-method = "shutdown" >
< property name = "dataSource" >
< bean class = "org.enhydra.jdbc.standard.StandardXADataSource"
destroy-method = "shutdown" >
< property name = "transactionManager" ref = "jotm" />
< property name = "driverName" value = "com.mysql.jdbc.Driver" />
< property name = "url" value = "jdbc:mysql://localhost/jtatestb" />
</ bean >
</ property >
< property name = "user" value = "root" />
< property name = "password" value = "885123" />
</ bean >
< bean id = "jtaTestATemplate" class = "org.springframework.jdbc.core.JdbcTemplate" >
< property name = "dataSource" ref = "jtaTestADS" />
</ bean >
< bean id = "jtaTestBTemplate" class = "org.springframework.jdbc.core.JdbcTemplate" >
< property name = "dataSource" ref = "jtaTestBDS" />
</ bean >
< bean id = "userDao" class = "com.dao.jdbc.UserJdbcDao" >
< property name = "jdbcTemplate" ref = "jtaTestATemplate" />
</ bean >
< bean id = "gradeDao" class = "com.dao.jdbc.GradeJdbcDao" >
< property name = "jdbcTemplate" ref = "jtaTestBTemplate" />
</ bean >
< bean id = "myService" class = "com.service.impl.MyServiceImpl" >
< property name = "userDao" ref = "userDao" />
< property name = "gradeDao" ref = "gradeDao" />
</ bean >
< tx:annotation-driven transaction-manager = "txManager" proxy-target-class = "true" />
</ beans >

7、测试main方法：

Java代码

import com.service.MyService;
import com.service.impl.MyServiceImpl;
import com.domain.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestMain {
public static void main(String args[]){
ClassPathXmlApplicationContext ctx =
new ClassPathXmlApplicationContext( "beans_jta.xml" );
MyService ms = (MyServiceImpl)ctx.getBean( "myService" );
User user = new User();
//特意添加一个重复的主键，以使添加user的事务失败并回退
//如果此时应用JTA事务失败，将仍会执行添加grade的事务并提交（前提是先于添加user操作）
//如果应用JTA事务成功，就会两个添加事务同时执行或同时回退。
user.setUser_id( 1 );
user.setUser_name( "tufu" );
user.setUser_password( "tufu" );
Grade grade = new Grade();
grade.setGrade( 100 );
grade.setUser(user);
ms.addGrade(user,grade);
}
}

注：将log4j.properties中的log4j日志设置为DEBUG级别，可以看到详细的JTA事务执行情况:
.......
log4j.rootLogger=DEBUG,R,A1
.......

在特定应用服务器使用JTA
一般来说，Spring的事务抽象与应用服务器是无关的。不过，如果你如果希望事务管理器使用特定的UserTransaction 和 TransactionManager 对象（可以被自动探测），以获取更多的增强事务语义。这时，针对不同的Java EE应用服务器，Spring的事务管理器可以采取不同的配置。 3 d0 W4 y5 k3 u, h! G

 BEA WebLogic
在一个使用WebLogic 7.0、8.1或更高版本的环境中，你一般会优先选用特定于WebLogic的 WebLogicJtaTransactionManager 类来取代基础的 JtaTransactionManager 类，因为在WebLogic环境中，该类提供了对Spring事务定义的完全支持，超过了标准的JTA语义。你可以使用以下的配置达到目的：
<bean id="txManager" class="org.springframework.transaction.jta.WebLogicJtaTransactionManager"/> 7 n6 e" n' j: m9 X- Q
它的特性包括：支持事务名，支持为每个事务定义隔离级别，以及在任何环境下正确地恢复事务的能力。

 IBM WebSphere . |' v# o% K7 }( K& B
在WebSphere 5.1、5.0和4.x环境下，你可以使用Spring的 WebSphereTransactionManagerFactoryBean 类。这是一个工厂类，通过WebSphere的静态访问方法（每个版本的WebSphere中都不同）获取到JTA TransactionManager 实例。一旦通过工厂bean获取到JTA TransactionManager 实例，就可以使用该实例装配一个Spring的 JtaTransactionManager bean，它封装了JTA UserTransaction，提供增强的事务语义。你可以按以下方式进行配置： 8 |6 Y+ C: C: k6 C

①引用WebSphere的JTA事务管理器

< bean id = " wsJtaTm " class = " org.springframework.transaction.jta.WebSphereTransactionManagerFactoryBean " />

< bean id = " transactionManager " class = " org.springframework.transaction.jta.JtaTransactionManager " >

< property name = " transactionManager ref= " wsJtaTm " />

</ bean >

小结
你既可以在没有任务应用服务器支持的情况下，直接通过集成JOTM在Spring中使用JTA事务管理，也可以通过引用Java EE应用服务器的JNDI数据源，利用应用服务器提供的JTA事务功能间接实现Spring 中的JTA事务管理。为了利用一些高级Java EE应用服务器的JTA事务高级功能，你可以通过Spring所提供的特定于应用服务器的JTA事务管理器进行配置。