带有Atomikos示例的Tomcat中的Spring JTA多个资源事务

在本教程中，我们将向您展示如何使用Atomikos Transaction Manager在Tomcat服务器中实现JTA多个资源事务。 Atomicos事务管理器为分布式事务提供支持。 这些是多阶段事务，通常使用多个数据库，必须以协调的方式提交。 分布式事务由XA standard描述。 XA事务管理器（例如Atomikos）如何告知数据库什么事务作为正在进行的事务的一部分，以及如何在每次事务结束时执行两阶段提交（2PC）协议。

在这里，我们将创建映射到两个不同数据库的简单实体类，并尝试使用一个分布式事务将这些类的对象持久保存到数据库中。 我们还将看到当基础事务之一回滚时会发生什么。

我们首选的开发环境是Eclipse 。 我们正在使用Eclipse Juno（4.2）版本以及Maven Integration插件版本3.1.0。 您可以从Eclipse的这里从和Maven Eclipse插件这里 。 用于Eclipse的Maven插件的安装不在本教程的讨论范围内，因此将不予讨论。 我们还使用Spring 3.2.3和JDK 7_u_21。

Tomcat 7是使用的应用程序服务器。 Hibernate版本为4.1.9，示例中使用的数据库为MySQL Database Server 5.6。

让我们开始，

1.创建一个新的Maven项目

转到文件->项目-> Maven-> Maven项目。

在向导的“选择项目名称和位置”页面中，确保未选中 “创建简单项目（跳过原型选择）”选项，单击“下一步”以继续使用默认值。

在这里，必须添加用于创建Web应用程序的Maven原型。 单击“添加原型”并添加原型。 将“ Archetype组ID”变量设置为"org.apache.maven.archetypes" ，将“ Archetype构件ID”变量设置为"maven-archetype-webapp" ，并将“ Archetype版本”设置为"1.0" 。 点击“确定”继续。

在向导的“输入工件ID”页面中，您可以定义项目的名称和主程序包。 将“ Group Id”变量设置为"com.javacodegeeks.snippets.enterprise" ，将“ Artifact Id”变量设置为"springexample" 。 前面提到的选择将主项目包组成为"com.javacodegeeks.snippets.enterprise.springexample" ，项目名称为"springexample" 。 将“ Package”变量设置为"war" ，以便创建一个war文件以部署到tomcat服务器。 点击“完成”退出向导并创建您的项目。

Maven项目结构如下所示：

它包含以下文件夹：
• / src / main / java文件夹，其中包含应用程序动态内容的源文件，
• / src / test / java文件夹包含用于单元测试的所有源文件，
• / src / main / resources文件夹包含配置文件，
• / target文件夹包含已编译和打包的可交付成果，
• / src / main / resources / webapp / WEB-INF文件夹包含Web应用程序的部署描述符，
• pom.xml是项目对象模型（POM）文件。 包含所有项目相关配置的单个文件。

2.添加Spring 3.2.3依赖项

• 在POM编辑器的“概述”页面上找到“属性”部分，并进行以下更改：
  创建一个新属性，名称为org.springframework.version ，值3.2.3RELEASE 。
• 导航到POM编辑器的“依赖关系”页面，并创建以下依赖关系（您应在该页面的“依赖关系详细信息”部分中填写“ GroupId”，“工件ID”和“版本”字段）：
  组ID： org.springframework工件ID： spring-web版本： $ {org.springframework.version}

另外，您可以在Maven的pom.xml文件中添加Spring依赖项，方法是直接在POM编辑器的“ Pom.xml”页面上对其进行编辑，如下所示：

pom.xml：

<project xmlns="http://maven.apache.org/POM/4.0.0"; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.javacodegeeks.snippets.enterprise</groupId>
	<artifactId>springexample</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
	</dependencies>

	<properties>
		<spring.version>3.2.3.RELEASE</spring.version>
	</properties>
</project>

如您所见，Maven以声明方式管理库依赖关系。 创建本地存储库（默认情况下，位于{user_home} /。m2文件夹下），所有必需的库都从公共存储库下载并放置在该库中。 此外，库内的依赖关系会自动解决和处理。

3.添加所有必需的依赖项

此处设置了设置atomosos事务管理器所需的所有依赖项。
pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.javacodegeeks.snippets.enterprise</groupId>
  <artifactId>springexample</artifactId>
  <packaging>war</packaging>
  <version>0.0.1</version>
  <name>springexample Maven Webapp</name>
  <url>http://maven.apache.org</url>
    <build>
    <finalName>springexample</finalName>
  </build>
  <dependencies>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-entitymanager</artifactId>
    <version>${hibernate.version}</version>
    <exclusions>
      <exclusion>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
      </exclusion>
      <exclusion>
        <groupId>dom4j</groupId>
        <artifactId>dom4j</artifactId>
      </exclusion>
    </exclusions>
  </dependency>

  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.0.1</version>
    <scope>provided</scope>
  </dependency>

  <dependency>
    <groupId>com.atomikos</groupId>
    <artifactId>transactions-jta</artifactId>
    <version>${atomikos.version}</version>
  </dependency>

  <dependency>
    <groupId>com.atomikos</groupId>
    <artifactId>transactions-jdbc</artifactId>
    <version>${atomikos.version}</version>
  </dependency>

  <dependency>
    <groupId>com.atomikos</groupId>
    <artifactId>transactions-hibernate3</artifactId>
    <version>${atomikos.version}</version>
    <exclusions>
      <exclusion>
        <artifactId>hibernate</artifactId>
        <groupId>org.hibernate</groupId>
      </exclusion>
    </exclusions>
  </dependency>

  <dependency>
    <groupId>dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>1.6.1</version>
  </dependency>

  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.25</version>
  </dependency>
  </dependencies>

<properties>
  <spring.version>3.2.3.RELEASE</spring.version>
  <hibernate.version>4.1.9.Final</hibernate.version>
  <atomikos.version>3.8.0</atomikos.version>
</properties>
  
</project>

4.创建实体类

EmployeeA.java和EmployeeB.java是Entity类。 他们使用javax.persistence批注映射到不同数据库中的表EMPLOYEEA和EMPLOYEEB 。 特别地， @Entity注释指定每个类是一个实体。 @Table注释指定带注释的实体的主表。 @Column批注用于为持久字段指定一个映射列，而@Id批注指定每个实体的主键字段。

EmployeeA.java

package com.javacodegeeks.snippets.enterprise.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "EMPLOYEEA")
public class EmployeeA {

	@Id
	@Column(name = "ID", nullable = false)
	private String id;

	@Column(name = "NAME", nullable = false)
	private String name;

	@Column(name = "AGE", nullable = false)
	private long age;
	
	public EmployeeA() {
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public long getAge() {
		return age;
	}

	public void setAge(long age) {
		this.age = age;
	}

}

EmployeeB.java

package com.javacodegeeks.snippets.enterprise.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "EMPLOYEEB")
public class EmployeeB {

	@Id
	@Column(name = "ID", nullable = false)
	private String id;

	@Column(name = "NAME", nullable = false)
	private String name;

	@Column(name = "AGE", nullable = false)
	private long age;
	
	public EmployeeB() {
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public long getAge() {
		return age;
	}

	public void setAge(long age) {
		this.age = age;
	}

}

5.创建DAO类

实现的数据访问对象是EmployeeADAOImpl.java和EmployeeBDAOImpl.java类。 它们使用@Service注释进行注释，表明它们是Spring Bean，因此允许Spring自动检测它们。 它们都使用javax.persistence.EntityManager与数据库进行交互。

EntityManager实例与持久性上下文关联。 持久性上下文是一组实体实例，其中对于任何持久性实体标识，都有一个唯一的实体实例。 在持久性上下文中，管理实体实例及其生命周期。 EntityManager API用于创建和删除持久实体实例，通过其主键查找实体以及查询实体。 在persistence.xml文件中配置了EntityManager ，对此进行了描述
在8.1节中。
可以由给定EntityManager实例管理的实体集由持久性单元定义。 持久性单元定义了与应用程序相关或分组的所有类的集合，并且所有类在映射到单个数据库时必须共置。

EntityManager通过@PersistenceContext注释注入到每个DAO中，在该注释中设置了每个持久性单元的名称，如persistence.xml文件中所定义。
在两个DAO中都实现了一种基本的persist方法，使用EntityManager的persist(Object entity) API方法为数据库创建一个对象。

DAO及其接口如下所示：

雇员ADAO.java

package com.javacodegeeks.snippets.enterprise.dao;

import com.javacodegeeks.snippets.enterprise.model.EmployeeA;

public interface EmployeeADAO {
	
		  void persistEmployee(EmployeeA employee);		  
}

雇员ADAO Impl.java

package com.javacodegeeks.snippets.enterprise.dao;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.stereotype.Service;

import com.javacodegeeks.snippets.enterprise.model.EmployeeA;

@Service
public class EmployeeADAOImpl implements EmployeeADAO {

	@PersistenceContext(unitName="PersistenceUnitA")
	private EntityManager entityManager;

	public void persistEmployee(EmployeeA employee) {
		entityManager.persist(employee);
	}

}

雇员BDAO .java

package com.javacodegeeks.snippets.enterprise.dao;

import com.javacodegeeks.snippets.enterprise.model.EmployeeB;

public interface EmployeeBDAO {
	
		  void persistEmployee(EmployeeB employee) throws Exception;
		  
}

雇员BDAO Impl.java

package com.javacodegeeks.snippets.enterprise.dao;


import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.stereotype.Service;

import com.javacodegeeks.snippets.enterprise.model.EmployeeB;

@Service
public class EmployeeBDAOImpl implements EmployeeBDAO {

	@PersistenceContext(unitName="PersistenceUnitB")
	private EntityManager entityManager;

	public void persistEmployee(EmployeeB employee) throws Exception {
		entityManager.persist(employee);
//		throw new Exception();
	}
}

6.创建服务类

EmployeeADAOImpl.java和EmployeeBDAOImpl.java类被注入EmployeeServiceImpl.java类。 因此，在此处实现的persistEmployees(EmployeeA employeeA, EmployeeB employeeB)方法中，将调用DAO的方法来执行与数据库的基本交互。 EmployeeServiceImpl.java类也带有@Service注释，表明它是一个Spring Bean，因此允许Spring自动检测到它。

@Transactional批注放置在方法之前，以表示在调用该方法时创建了一个事务。 该事务是全局容器管理的事务，将在Spring配置文件中进行配置。
EmployeeService.java

package com.javacodegeeks.snippets.enterprise.service;

import com.javacodegeeks.snippets.enterprise.model.EmployeeA;
import com.javacodegeeks.snippets.enterprise.model.EmployeeB;

public interface EmployeeService {

	void persistEmployees(EmployeeA employeeA, EmployeeB employeeB) throws Exception;
	
}

EmployeeServiceImpl.java

package com.javacodegeeks.snippets.enterprise.service;

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

import com.javacodegeeks.snippets.enterprise.dao.EmployeeADAO;
import com.javacodegeeks.snippets.enterprise.dao.EmployeeBDAO;
import com.javacodegeeks.snippets.enterprise.model.EmployeeA;
import com.javacodegeeks.snippets.enterprise.model.EmployeeB;

@Service("employeeService")
public class EmployeeServiceImpl implements EmployeeService{

	@Autowired
	EmployeeADAO employeeADAO;
	
	@Autowired
	EmployeeBDAO employeeBDAO;
	
	@Transactional(rollbackFor=Exception.class)
	public void persistEmployees(EmployeeA employeeA, EmployeeB employeeB) throws Exception {
		System.out.println("Persist A");
		employeeADAO.persistEmployee(employeeA);
		System.out.println("Persist A OK - persist B");
		employeeBDAO.persistEmployee(employeeB);
		System.out.println("Persist B okk");
	}

}

7.创建一个servlet以运行该应用程序

AppServlet.java类是一个简单的servlet，它实现org.springframework.web.HttpRequestHandler并覆盖其handleRequest(HttpServletRequest req, HttpServletResponse resp) API方法。 EmployeeService通过@Autowire注释注入到此处。 在handleRequest(HttpServletRequest req, HttpServletResponse resp) API方法中使用它来持久存储新的EmployeeA和新的EmployeeB对象。 如果该方法成功返回，则该方法还返回成功消息，如果该方法引发异常，则返回回滚消息。

AppServlet.java

package com.javacodegeeks.snippets.enterprise.servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.HttpRequestHandler;

import com.javacodegeeks.snippets.enterprise.model.EmployeeA;
import com.javacodegeeks.snippets.enterprise.model.EmployeeB;
import com.javacodegeeks.snippets.enterprise.service.EmployeeService;

@Component("appServlet")
public class AppServlet implements HttpRequestHandler {

	@Autowired
	private EmployeeService employeeService;

	public void handleRequest(HttpServletRequest req, HttpServletResponse resp)
			throws ServletException, IOException {
		EmployeeA em1 = new EmployeeA();
		em1.setId("123");
		em1.setName("John");
		em1.setAge(35);
		EmployeeB em2 = new EmployeeB();
		em2.setId("123");
		em2.setName("Mary");
		em2.setAge(31);

		try {
			employeeService.persistEmployees(em1, em2);
			 resp.setContentType("text/html");
		        PrintWriter out = resp.getWriter();
		        out.println("<html>");
		        out.println("<head>");
		        out.println("<title>Hello World!</title>");
		        out.println("</head>");
		        out.println("<body>");
		        out.println("<h1>Java Code Geeks </h1>");
		        out.println("<h2>Both employees are inserted!</h2>");
		        out.println("</body>");
		        out.println("</html>");
		} catch (Exception e) {
			 resp.setContentType("text/html");
		        PrintWriter out = resp.getWriter();
		        out.println("<html>");
		        out.println("<head>");
		        out.println("<title>Hello World!</title>");
		        out.println("</head>");
		        out.println("<body>");
		        out.println("<h1>Java Code Geeks </h1>");
		        out.println("<h2>Transaction Rollback!</h2>");
		        out.println("</body>");
		        out.println("</html>");
			e.printStackTrace();
		}
	}
}

8.配置应用程序

8.1配置持久性单元

如上所述，在persistence.xml文件中配置了entityManager和与每个数据库关联的持久性单元。 在这里，我们定义了两个持久性单元。 在每个persistence-unit元素中，我们定义与持久性单元关联的实体类。 hibernate.transaction.manager_lookup_class属性设置为com.atomikos.icatch.jta.hibernate3.TransactionManagerLookup 。 hibernate.transaction.factory_class属性设置为org.hibernate.transaction.CMTTransactionFactory 。
persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
  xmlns="http://java.sun.com/xml/ns/persistence" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
  http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

 <persistence-unit name="PersistenceUnitA" transaction-type="JTA">
  <class>com.javacodegeeks.snippets.enterprise.model.EmployeeA</class>
  <properties>
   <property name="hibernate.transaction.manager_lookup_class"
   value="com.atomikos.icatch.jta.hibernate3.TransactionManagerLookup" />
   <property name="hibernate.transaction.factory_class"
   value="org.hibernate.transaction.CMTTransactionFactory" />
  </properties>
 </persistence-unit>
  
 <persistence-unit name="PersistenceUnitB" transaction-type="JTA">
  <class>com.javacodegeeks.snippets.enterprise.model.EmployeeB</class>
  <properties>
   <property name="hibernate.transaction.manager_lookup_class"
   value="com.atomikos.icatch.jta.hibernate3.TransactionManagerLookup" />
   <property name="hibernate.transaction.factory_class"
   value="org.hibernate.transaction.CMTTransactionFactory" />
  </properties>
 </persistence-unit>
  
</persistence>

8.2配置Spring容器

applicationContext.xml文件是Spring的配置文件。

<context:component-scan/>元素用于设置包含容器必须扫描以检测Spring Bean的所有类的包。
还使用<tx:annotation-driven/>元素，以便Spring具有@Transactional感知，并可以检测@Transactional注释以配置具有事务行为的适当bean。
<jta-transaction-manager/>元素用于检测基础服务器并选择可用于平台的事务管理器。

在dataSourceA和dataSourceB bean中，我们定义了数据源。 com.atomikos.jdbc.AtomikosDataSourceBean是此处设置的类。 它使用支持Atomikos JTA的连接池。 它具有两个要配置的属性。 com.mysql.jdbc.jdbc2.optional.MysqlXADataSource类设置为xaDataSourceClass属性，而在xaProperties我们可以设置属性（名称，值对）以配置XADataSource 。

在entityManagerFactoryA和entityManagerFactoryB bean中，我们设置了org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean类。 它是一个FactoryBean ，可根据JPA的标准容器引导合同创建JPA EntityManagerFactory 。 我们可以在其persistenceXmlLocation属性中设置persistence.xml位置。 我们可以在persistenceUnitName属性中设置用于创建此EntityManagerFactory的持久性单元的名称。 datasource属性是对适当的dataSource bean的引用。 jpaVendorAdapter属性设置为org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter ，它是Hibernate EntityManager的实现。

最后，使用org.springframework.transaction.jta.JtaTransactionManager定义transactionManager bean。 它具有两个要配置的属性。 transactionManager和atomikosTransactionManager 。 它们分别引用了com.atomikos.icatch.jta.UserTransactionManager类和com.atomikos.icatch.jta.J2eeUserTransaction类的两个bean。
applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.2.xsd">

	<context:component-scan base-package="com.javacodegeeks.snippets.enterprise.*" />
	<tx:annotation-driven />
	<tx:jta-transaction-manager />
	
	<bean id="dataSourceA" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init" destroy-method="close">
	<property name="uniqueResourceName"><value>DataSourceA</value></property>
	<property name="xaDataSourceClassName"><value>com.mysql.jdbc.jdbc2.optional.MysqlXADataSource</value></property>
	<property name="xaProperties">
	    <props>
		<prop key="databaseName">companyA</prop>
		<prop key="serverName">localhost</prop>
		<prop key="port">3306</prop>
		<prop key="user">root</prop>
		<prop key="password">root</prop>
		<prop key="url">jdbc:mysql://localhost:3306/companyA</prop>
	    </props>
	</property>
	<property name="minPoolSize"><value>1</value></property>
</bean>
	
<bean id="dataSourceB" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init" destroy-method="close">
	<property name="uniqueResourceName"><value>DataSourceB</value></property>
	<property name="xaDataSourceClassName"><value>com.mysql.jdbc.jdbc2.optional.MysqlXADataSource</value></property>
	<property name="xaProperties">
	    <props>
		<prop key="databaseName">companyB</prop>
		<prop key="serverName">localhost</prop>
		<prop key="port">3306</prop>
		<prop key="user">root</prop>
		<prop key="password">root</prop>
		<prop key="url">jdbc:mysql://localhost:3306/companyB</prop>
	    </props>
	</property>
	<property name="minPoolSize"><value>1</value></property>
</bean>

<bean id="entityManagerFactoryA" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
	<property name="persistenceXmlLocation">
            <value>classpath*:persistence.xml</value>
    </property>
		<property name="persistenceUnitName" value="PersistenceUnitA" />
		<property name="dataSource" ref="dataSourceA" />
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<property name="showSql" value="true" />
				<property name="databasePlatform" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
			</bean>
		</property>
	</bean>
	<bean id="entityManagerFactoryB" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
	<property name="persistenceXmlLocation">
            <value>classpath*:persistence.xml</value>
    </property>
		<property name="persistenceUnitName" value="PersistenceUnitB" />
		<property name="dataSource" ref="dataSourceB" />
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<property name="showSql" value="true" />
				<property name="databasePlatform" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
			</bean>
		</property>
	</bean>

	<bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager" init-method="init" destroy-method="close">
		<property name="forceShutdown" value="false" />
	</bean>

	<bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.J2eeUserTransaction">
		<property name="transactionTimeout" value="300" />
	</bean>

	<bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager"
		depends-on="atomikosTransactionManager,atomikosUserTransaction">
		<property name="transactionManager" ref="atomikosTransactionManager" />
		<property name="userTransaction" ref="atomikosUserTransaction" />
		<property name="allowCustomIsolationLevels" value="true" />
	</bean>

</beans>

8.3配置Web应用程序部署描述符

web.xml文件是定义服务器需要了解的有关应用程序的所有内容的文件。 此处设置了Servlet和其他组件，如过滤器或侦听器，初始化参数，容器管理的安全性约束，资源，欢迎页面等。

servlet元素声明AppServlet ，并声明实现它的org.springframework.web.context.support.HttpRequestHandlerServlet类。 servlet-mapping元素指定在浏览器中调用servlet的/appServlet URL模式。 在context-param元素中，我们设置了contextConfigLocation参数，其中定义了applicationContext.xml文件位置。 在listener元素中，将Bootstrap侦听器设置为启动Spring的applicationContext.xml 。 在两个数据源中都设置了resource-ref元素，以定义对资源的引用查找名称。 这允许servlet代码通过在部署时映射到实际位置的“虚拟”名称来查找资源。

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	id="WebApp_ID" version="3.0">

	<display-name>javacodegeeks</display-name>

	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			/WEB-INF/applicationContext.xml
		</param-value>
	</context-param>

	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<servlet>
		<display-name>AppServlet</display-name>
		<servlet-name>appServlet</servlet-name>
		<servlet-class>org.springframework.web.context.support.HttpRequestHandlerServlet</servlet-class>
	</servlet>

	<servlet-mapping>
		<servlet-name>appServlet</servlet-name>
		<url-pattern>/appServlet</url-pattern>
	</servlet-mapping>

	<resource-ref>
		<description>MySQL DS</description>
		<res-ref-name>jdbc/DataSourceA</res-ref-name>
		<res-type>javax.sql.DataSource</res-type>
		<res-auth>Container</res-auth>
	</resource-ref>

	<resource-ref>
		<description>MySQL DS</description>
		<res-ref-name>jdbc/DataSourceB</res-ref-name>
		<res-type>javax.sql.DataSource</res-type>
		<res-auth>Container</res-auth>
	</resource-ref>

</web-app>

9.在Tomcat中运行应用程序

为了在tomcat中运行应用程序，我们首先必须构建项目。 产生的war被放置在tomcat的webapps文件夹中。 然后，我们启动服务器。 撞上之后

localhost:8080/springexample/appServlet

在浏览器中，我们可以检查在MySQL，这两个数据库， companyA和companyB表EmployeeA和EmployeeB有一个记录。 浏览器中返回的消息是以下消息：

10.回滚情况

现在，让我们看看如果两个事务之一失败了会发生什么。 我们将更改EmployeeBDAOImpl.java类的persistEmployee(EmployeeB employee)方法，以引发Exception 。

雇员BDAO Impl.java

package com.javacodegeeks.snippets.enterprise.dao;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.stereotype.Service;

import com.javacodegeeks.snippets.enterprise.model.EmployeeB;

@Service
public class EmployeeBDAOImpl implements EmployeeBDAO {

	@PersistenceContext(unitName="PersistenceUnitB")
	private EntityManager entityManager;

	public void persistEmployee(EmployeeB employee) throws Exception {
//		entityManager.persist(employee);
		throw new Exception();
	}
}

我们再次构建该项目，并将新的war文件放入tomcat的webapps文件中。 再次启动tomcat之后，结果如下：

这是由于事务之一引发异常而导致分布式事务也会回滚。

这是使用Atomikos事务管理器在Tomcat服务器中进行JTA多个资源事务的示例。
下载本教程的Eclipse项目： SpringJTAatomicosTomcatExample.zip

翻译自: https://www.javacodegeeks.com/2013/07/spring-jta-multiple-resource-transactions-in-tomcat-with-atomikos-example.html