说明：

1.EJB的事务是方法级别的隔离，而spring的拦截事务是类级别的，所以spring管理的jta事务在同一个类的不同方法设置不同的事务传播策略是无效的。
2.使用了spring的事务，就不能显示地使用hibernate的开启事务，提交事务等，spring通过拦截器自动实现这些操作。

正文开始：

spring hibernate 集成，hibernate操作多个数据库需要 jta 事务管理器，spring提供了对容器jta事务管理器的支持，同时hibernate也提供了对容器jta事务管理器的支持，注意两者不能同时使用，只能选择其一来管理事务，如果要使用spring则可以通过配置事务代理或者拦截器的方式实现，如果要使用hibernate则可以配置session工厂使用jta事务管理器同事编码过程中要显示开启事务/提交或回滚事务，显然使用spring管理事务更加优越：1.声明式事务管理，对代码无侵入；2.拦截器使用aop的方式，可以批量对多个业务服务bean植入事务支持，下面是一个完整的使用spring管理事务的例子：

项目的pom文件：

<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">
    <parent>
        <artifactId>eden</artifactId>
        <groupId>com.conquer.eden</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>springtx</artifactId>
    <packaging>war</packaging>
    <name>springtx</name>
    <properties>
        <springVersion>2.0.1</springVersion>
    </properties>
    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.transaction</groupId>
            <artifactId>javax.transaction-api</artifactId>
            <version>1.2</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring</artifactId>
            <version>2.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate</artifactId>
            <version>3.1.3</version>
            <exclusions>
                <exclusion>
                    <groupId>javax.transaction</groupId>
                    <artifactId>jta</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    <build>
        <finalName>springtx</finalName>
    </build>
</project>

注意这里：由于web层没有使用spring管理，所以这里没有配置spring的请求转发器，所以需要手工使用spring的api来初始化spring容器，web.xml代码： 

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <servlet>
        <servlet-name>test</servlet-name>
        <servlet-class>com.test.TestServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>test</servlet-name>
        <url-pattern>/test</url-pattern>
    </servlet-mapping>
</web-app>
Servlet代码： 

package com.test;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class TestServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String data = req.getParameter("data");
        if (data == null) data = "00000";

        try {
            SpringTest.testSpring(data);
            PrintWriter writer = resp.getWriter();
            writer.println("ok, check the console output ...");
            writer.flush();
        } catch (Exception e) {
            throw new ServletException(e);
        }
    }
}

下面是spring事务测试的入口，由于没有使用spring管理web，故在这里进行spring容器的初始化： 

package com.test;

import com.test.service.Service1;
import com.test.service.Service2;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    private static Service1 service1;
    private static Service2 service2;

    static {
        /**
         * 测试使用：
         * 保证实例是在spring的管理范围内，即在spring的IOC容器中，在spring mvc 的 web 架构中，我们不需要这样显示写出来，注入是自动的
         * 这里因为我们的 测试 Servlet 没有被spring 管理，也就不能触发spring的注入机制，所以这里使用编程的方式测试。
         */
//    使用 代理bean方式 支持事务
//        ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"spring/*.xml", "spring/tx/tx_proxy.xml"});
//    使用 拦截bean方法方式（拦截器） 支持事务
        ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"spring/*.xml", "spring/tx/tx_interceptor.xml"});


        //直接引用，会导致事务不起作用，必需使用spring的事务代理类，注意：使用拦截器时使用这个，不需要改变，拦截器的实现会自动改变内存里的实现
        //拦截器是推荐使用的事务支持方式，好处：
        // 一：不需要使用新的代理bean（不用担心引用错误造成事务无效）
        // 二：可以批量配置bean的事务属性（避免事务bean的配置膨胀）
        service1 = (Service1) context.getBean("service1");
        service2 = (Service2) context.getBean("service2");

        //使用spring的事务代理类，可使用事务支持
//        service1 = (Service1) context.getBean("myTxProxy1");
//        service2 = (Service2) context.getBean("myTxProxy2");
    }

    public static void testSpring(String data) {
        service1.twoTX(data);
    }
}
好了，现在看下spring需要的配置文件：

base.xml：引用容器提供的jndi资源，主要是数据源和JTA事务管理器

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
        "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
    <!--通过JNDI查找的对象，最终会强制转为为需要的类型，如这个会强转为 TransactionManager-->
    <bean id="twJtaTm" class="org.springframework.jndi.JndiObjectFactoryBean">
        <!--tw6-->
        <property name="jndiName" value="java:appserver/TransactionManager"/>
        <!--twe5-->
        <!--<property name="jndiName" value="java:internal/TransactionManager"/>-->
        <!--jboss-->
        <!--<property name="jndiName" value="java:/TransactionManager"/>-->
        <!--weblogic-->
        <!--<property name="jndiName" value="javax.transaction.TransactionManager"/>-->
        <!--<property name="resourceRef" value="true" />TODO-->
    </bean>
    <!--通过JNDI查找的对象，最终会强制转为为需要的类型，如这个会强转为 DataSource-->
    <bean id="myDataSource1" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName" value="DataSource1"/>
        <!--<property name="resourceRef" value="true" />TODO-->
    </bean>
    <!--通过JNDI查找的对象，最终会强制转为为需要的类型，如这个会强转为 DataSource-->
    <bean id="myDataSource2" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName" value="DataSource1"/>
        <!--<property name="resourceRef" value="true" />TODO-->
    </bean>
</beans>

business_beans.xml：业务bean的配置文件： 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
        "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
    <!--              以下是具体业务相关              -->
    <!--业务类，需要事务配置的类，特别注意，业务中不要直接使用此实例，而应该使用其事务代理：basicTxProxy -->
    <!-- NOTE：非嵌入式的，命名的，此目标业务 bean 可被直接引用，直接引用将导致 无事务，所以应该使用代理事务bean的引用或使用事务拦截器来处理-->

    <bean id="baseDAO" abstract="true">
        <property name="sessionFactory1" ref="sessionFactory1"/>
        <property name="sessionFactory2" ref="sessionFactory2"/>
    </bean>

    <!--如果使用代理，直接引用这里的bean会导致事务失效，应该引用其代理，而且事务应该加在 服务层（service）-->
    <bean id="dao1" parent="baseDAO" class="com.test.dao.impl.DAOImpl1"/>
    <bean id="dao2" parent="baseDAO" class="com.test.dao.impl.DAOImpl2"/>

    <!--事务应该加在 服务层（service）：如果使用代理，直接引用这里的bean会导致事务失效，应该引用其代理-->
    <bean id="service1" class="com.test.service.impl.Service1Impl">
        <property name="dao1" ref="dao1"/>
        <property name="dao2" ref="dao2"/>
        <!--如果使用代理，直接引用这里的bean会导致事务失效，应该引用其代理，但是，如果使用的事务拦截器，这里不需要变动，拦截器会自动改掉内存里的实现-->
        <property name="service2" ref="service2"/>

        <!--引用事务代理代理，不使用拦截器时使用这个-->
        <!--<property name="service2" ref="myTxProxy2"/>-->
    </bean>
    <bean id="service2" class="com.test.service.impl.Service2Impl">
        <property name="dao2" ref="dao2"/>
    </bean>
</beans>

hibernate.xml：hibernate session工厂的配置 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
        "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
    <!--spring 对 hibernate的支持，用于创建 hibernate的SessionFactory-->
    <bean id="sessionFactory1" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="hibernateProperties">
            <value>
                <!--这里填写hibernate特定属性，注意不要在这里写 hibernate.transaction.factory_class 和 jta.UserTransaction，因为事务需要交给spring管理
                这里写了，只会对代码调用 org.hibernate.Session#getTransaction()方法起效，对于spring配置的事务策略无效，使用spring的事务会忽略此设置
                -->
                hibernate.dialect=org.hibernate.dialect.OracleDialect
                hibernate.show_sql=true
            </value>
        </property>
        <!--配置hibernate的映射文件，这里配置的是整个 hbm 文件夹下的文件-->
        <property name="mappingDirectoryLocations">
            <list>
                <value>
                    classpath*:/hbm/
                </value>
            </list>
        </property>
        <!--JNDI 查找到的 myDataSource1 是DataSource类型的，所以可以在这里注入-->
        <property name="dataSource" ref="myDataSource1"/>
        <!--JNDI 查找到的 twJtaTm 是TransactionManager类型的，所以可以在这里注入 TODO-->
        <!--<property name="jtaTransactionManager" ref="twJtaTm"/>-->
    </bean>
    <!--spring 对 hibernate的支持，用于创建 hibernate的SessionFactory-->
    <bean id="sessionFactory2" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="hibernateProperties">
            <value>
                <!--这里填写hibernate特定属性，注意不要在这里写 hibernate.transaction.factory_class 和 jta.UserTransaction，因为事务需要交给spring管理
                这里写了，只会对代码调用 org.hibernate.Session#getTransaction()方法起效，对于spring配置的事务策略无效，使用spring的事务会忽略此设置
                -->
                hibernate.dialect=org.hibernate.dialect.OracleDialect
                hibernate.show_sql=true
            </value>
        </property>
        <!--配置hibernate的映射文件，这里配置的是指定的文件-->
        <property name="mappingResources">
            <list>
                <value>hbm/Student.hbm.xml</value>
                <value>hbm/Teacher.hbm.xml</value>
            </list>
        </property>
        <!--JNDI 查找到的 myDataSource2 是DataSource类型的，所以可以在这里注入-->
        <property name="dataSource" ref="myDataSource2"/>
        <!--JNDI 查找到的 twJtaTm 是TransactionManager类型的，所以可以在这里注入 TODO-->
        <!--<property name="jtaTransactionManager" ref="twJtaTm"/>-->
    </bean>
</beans>

tx_common.xml：事务公共配置，注意是一些公共bean 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
        "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
    <!--
     要使用 JTA 事务管理，需要配置 JtaTransactionManager，他需要 TransactionManager 类型的实例，twJtaTm正好是一个
     它本身是 PlatformTransactionManager 的实现，可以配合完成 spring 的多种事务配置
    -->
    <bean id="mySpringTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
        <property name="transactionManager" ref="twJtaTm"/>
    </bean>
</beans>

下面就是重头戏了，spring有至少两种方式配置事务，代理bean和拦截器，下面是这两种的不同配置文件，实际使用其中一种即可：

tx_proxy.xml：使用代理bean支持事务

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
        "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
    <!--设置为 abstract，这样可以通过继承的方式，简化子类的代码，如果没有子类就不初始化-->
    <bean id="baseTxProxyBean" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
          abstract="true">
        <!--需要的 transactionManager 是 PlatformTransactionManager 类型，所以不能直接注入 twJtaTm，需要使用 JtaTransactionManager 这个实现类，此实现类依赖 twJtaTm -->
        <property name="transactionManager" ref="mySpringTransactionManager"/>
        <property name="transactionAttributes">
            <!--Spring中Propagation类的事务属性详解：
                PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
                PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。
                PROPAGATION_MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。
                PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。
                 PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
                PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
                PROPAGATION_NESTED：支持当前事务，如果当前事务存在，则执行一个嵌套事务，如果当前没有事务，就新建一个事务。
                -->
            <props>
                <!--<prop key="*">PROPAGATION_REQUIRED</prop>-->
                <prop key="*">PROPAGATION_REQUIRED</prop>
                <!--<prop key="testTX">PROPAGATION_REQUIRED</prop>-->
                <!--<prop key="insert*">PROPAGATION_REQUIRED</prop>-->
                <!--<prop key="*">PROPAGATION_SUPPORTS,readOnly</prop>-->
            </props>
        </property>
        <!--非嵌入式的，命名的，目标业务bean可被直接引用导致无事务-->
        <!--<property name="target" ref="springTest"/>-->
        <!--嵌入式的，匿名的，避免目标业务bean被直接引用-->
        <!--<property name="target">-->
        <!--<bean class="com.test.SpringTest"/>-->
        <!--</property>-->
    </bean>
    <!-- 代理对象 -->
    <bean id="myTxProxy1" parent="baseTxProxyBean">
        <!--非嵌入式的，命名的，目标业务bean可被直接引用导致无事务，所以应该引用此：baseTxProxyBean-->
        <property name="target" ref="service1"/>
    </bean>
    <!-- 代理对象 -->
    <bean id="myTxProxy2" parent="baseTxProxyBean">
        <property name="transactionAttributes">
            <props>
                <prop key="twoTX">PROPAGATION_REQUIRES_NEW</prop>
            </props>
        </property>
        <!--非嵌入式的，命名的，目标业务bean可被直接引用导致无事务，所以应该引用此：baseTxProxyBean-->
        <property name="target" ref="service2"/>
        <!--嵌入式的，匿名的，避免目标业务bean被直接引用-->
        <!--<property name="target">-->
        <!--<bean parent="baseDAO" class="com.test.dao.impl.DAOServiceImpl"/>-->
        <!--</property>-->
    </bean>
    <!--以上的代理事务，如果业务类较多会出现配置膨胀，即每个需要事务的业务bean都需要配置一次，虽然使用了 继承 ，减少了代码量，但配置膨胀问题还没有解决
    从根本上解决就是用使用 拦截器的配置方式，看 tx_interceptor.xml 定义的的拦截器配置事务方式-->
</beans>

tx_interceptor.xml：使用拦截器支持事务： 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
        "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
    <!--tx_proxy.xml中使用的代理事务，如果业务类较多会出现配置膨胀，即每个需要事务的业务bean都需要配置一次，虽然使用了 继承 ，减少了代码量，但配置膨胀问题还没有解决
    从根本上解决就是用使用 拦截器的配置方式，看下面的拦截器配置事务方式：利用切面编程思想，自动添加事务支持-->
    <!-- 定义事务 -->
    <bean id="txInterceptor"
          class="org.springframework.transaction.interceptor.TransactionInterceptor">
        <property name="transactionManager" ref="mySpringTransactionManager" />
        <!-- 配置事务属性 -->
        <property name="transactionAttributes">
            <!--Spring中Propagation类的事务属性详解：
                PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
                PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。
                PROPAGATION_MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。
                PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。
                 PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
                PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
                PROPAGATION_NESTED：支持当前事务，如果当前事务存在，则执行一个嵌套事务，如果当前没有事务，就新建一个事务。
                -->
            <props>
                <prop key="*">PROPAGATION_REQUIRED</prop>
            </props>
        </property>
    </bean>
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <property name="beanNames">
            <list>
                <!--matches service1 & service2 & service*-->
                <value>service*</value>
            </list>
        </property>
        <property name="interceptorNames">
            <list>
                <value>txInterceptor</value>
            </list>
        </property>
    </bean>
</beans>

由于在上面使用了hibernate，所以需要提供下hibernate的映射文件，连个 hbm 文件：

Student.hbm.xml：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.test.model">
    <class name="Student" table="STUDENT">
        <id name="id">
            <generator class="uuid"/>
        </id>
        <property name="name"/>
    </class>
</hibernate-mapping>

Teacher.hbm.xml： 

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.test.model">
    <class name="Teacher" table="TEACHER">
        <id name="id">
            <generator class="uuid"/>
        </id>
        <property name="name"/>
    </class>
</hibernate-mapping>

注意：以上spring的配置文件都放到类路径的 spring 目录下，hibernate的两个hbm放到类路径的hbm目录下。

好了，到这里就可以看看具体的java代码了，值得说明的是：spring提供的切面编程支持事务的能力，对代码零侵入，使得我们在编码过程中根本不用关心事务功能，编写好的程序最后通过一个简单的AOP事务配置就支持事务，感慨一下spring的魅力，切面编程的魅力吧！！！

dao层代码：此层直接进行数据库操作，不关心业务，不关心事务，为service层提供支持

service层代码：此层用于完成具体的业务单元，一般一个业务单元需要同时进行多项数据库操作，所以往往事务也在这一次加入

controller层代码：此层用于控制业务逻辑的导向，并完成页面（视图层）交互，本示例没有涉及到此层

dao层代码：

package com.test.dao;

public interface DAO2 {
    void tx1(String data);

    void tx2(String data);
}

package com.test.dao;

public interface DAO1 {
    void tx1(String data);

    void tx2(String data);
}


package com.test.dao.impl;

import org.hibernate.SessionFactory;

public class BaseDAO {
    protected SessionFactory sessionFactory1;
    protected SessionFactory sessionFactory2;

    public void setSessionFactory1(SessionFactory sessionFactory1) {
        this.sessionFactory1 = sessionFactory1;
    }

    public void setSessionFactory2(SessionFactory sessionFactory2) {
        this.sessionFactory2 = sessionFactory2;
    }
}


package com.test.dao.impl;

import com.test.dao.DAO1;
import com.test.model.Student;
import com.test.model.Teacher;
import org.hibernate.Query;
import org.hibernate.Session;

import java.util.Date;
import java.util.List;

public class DAOImpl1 extends BaseDAO implements DAO1 {
    public void tx1(String data) {
        System.out.println("=========第 一 次写数据========");
        Session studentSession = sessionFactory1.openSession();
        insertStudent(studentSession);
        List<Student> students = queryStudent(studentSession);
        for (Student u : students) {
            System.out.println(u);
        }
        if (data.equals("1")) throw new RuntimeException("111111111111");
    }

    public void tx2(String data) {
        System.out.println("=========第 二 次写数据========");
        Session teacherSession = sessionFactory2.openSession();
        insertStudent(teacherSession);
        List<Student> students2 = queryStudent(teacherSession);
        for (Student u : students2) {
            System.out.println(u);
        }
        if (data.equals("2")) throw new RuntimeException("222222222222");
    }

    public void insertStudent(Session session) {
        Student s = new Student();
        s.setName("SpringTest1:" + new Date().toString());
        session.save(s);
    }

    public List<Student> queryStudent(Session session) {
        Query query = session.createQuery("from Student");
        return query.list();
    }

    public void insertTeacher(Session session) {
        Teacher s = new Teacher();
        s.setName(new Date().toString());
        session.save(s);
    }

    public List<Student> queryTeacher(Session session) {
        Query query = session.createQuery("from Teacher");
        return query.list();
    }
}

package com.test.dao.impl;

import com.test.dao.DAO2;
import com.test.model.Student;
import org.hibernate.Query;
import org.hibernate.Session;

import java.util.Date;
import java.util.List;

public class DAOImpl2 extends BaseDAO implements DAO2 {
    public void tx1(String data) {
        System.out.println("=========第 一 次写数据========");
        Session studentSession = sessionFactory1.openSession();
        insertStudent(studentSession);
        List<Student> students = queryStudent(studentSession);
        for (Student u : students) {
            System.out.println(u);
        }
        if (data.equals("3")) throw new RuntimeException("111111111111");
    }

    public void tx2(String data) {
        System.out.println("=========第 二 次写数据========");
        Session teacherSession = sessionFactory2.openSession();
        insertStudent(teacherSession);
        List<Student> students2 = queryStudent(teacherSession);
        for (Student u : students2) {
            System.out.println(u);
        }
        if (data.equals("4")) throw new RuntimeException("222222222222");
    }

    private void insertStudent(Session session) {
        Student s = new Student();
        s.setName("SpringTest2:" + new Date().toString());
        session.save(s);
    }

    private List<Student> queryStudent(Session session) {
        Query query = session.createQuery("from Student");
        return query.list();
    }
}
service层代码： 
package com.test.service;

public interface Service1 {
    void twoTX(String data);
}


package com.test.service;

public interface Service2 {
    void twoTX(String data);
}


package com.test.service.impl;

import com.test.dao.DAO1;
import com.test.dao.DAO2;
import com.test.service.Service1;
import com.test.service.Service2;

public class Service1Impl implements Service1 {
    private DAO1 dao1;
    private DAO2 dao2;

    private Service2 service2;

    public void setDao1(DAO1 dao1) {
        this.dao1 = dao1;
    }

    public void setDao2(DAO2 dao2) {
        this.dao2 = dao2;
    }

    public void setService2(Service2 service2) {
        this.service2 = service2;
    }

    public void twoTX(String data) {
        dao1.tx1(data);
        dao1.tx2(data);
        service2.twoTX(data);
    }
}


package com.test.service.impl;

import com.test.dao.DAO1;
import com.test.dao.DAO2;
import com.test.service.Service2;

public class Service2Impl implements Service2 {
    private DAO1 dao1;
    private DAO2 dao2;

    public void setDao1(DAO1 dao1) {
        this.dao1 = dao1;
    }

    public void setDao2(DAO2 dao1) {
        this.dao2 = dao1;
    }

    public void twoTX(String data) {
        dao2.tx1(data);
        dao2.tx2(data);
    }
}

model类： 

package com.test.model;

public class Student {
    private String id;
    private String name;

    public String getName() {
        return name;
    }

    public String getId() {
        return id;
    }

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

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

    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}
package com.test.model;

public class Teacher {
    private String id;
    private String name;

    public String getName() {
        return name;
    }

    public String getId() {
        return id;
    }

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

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

    @Override
    public String toString() {
        return "Teacher{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}


最后说明：

1.EJB的事务是方法级别的隔离，而spring的拦截事务是类级别的，所以spring管理的jta事务在同一个类的不同方法设置不同的事务传播策略是无效的。
2.使用了spring的事务，就不能显示地使用hibernate的开启事务，提交事务等，spring通过拦截器自动实现这些操作。


Logo
向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

avatar 云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

avatar 云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

avatar 云原生