spring hibernate 集成：spring使用容器JTA事务管理器

最新推荐文章于 2024-05-03 17:35:14 发布
最新推荐文章于 2024-05-03 17:35:14 发布
阅读量447 收藏
点赞数
分类专栏： Java 文章标签： hibernate spring

说明：

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通过拦截器自动实现这些操作。


wang_shuyu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring 结合druid和hibernate使用jta配置分布式事务
10-31
atomikos实现多数据源支持分布式事务管理（spring、tomcat、JTA） 结合spring 和durid进行配置，
在Hibernate中使用JTA事务
天青色等烟雨 而我在等你
01-12 272
9.3.5  在Hibernate中使用JTA事务 JTA（Java Transaction API）是事务服务的J2EE解决方案。本质上，它是描述事务接口的J2EE模型的一部分，开发人员直接使用该接口或者通过J2EE容器使用该接口来确保业务逻辑能够可靠地运行。 JTA有3个接口，它们分别是UserTransaction接口、TransactionManager接口和Transacti...
第二部分spring+hibernate+jta 分布式事务Demo
momoko8443
05-08 234
0、设计分布式数据库，修改第一部分的例子。先将db1中的user1表中的记录清除，把user2表drop掉，然后create一个新的database db2来模拟分布式数据库，在db2中新建一张表user2，结构和user1一致。接下来的操作就是同时对2个数据库的2张表进行操作了。 1、DAO接口、DAOImpl实现，Service接口、ServiceImpl实现都不用去动它，为使第一次测试...
spring集成hibernate事物JTA
iteye_13831的博客
02-21 125
环境介绍：atomikos3.8，spring3,hibernate3.6.10 jdbc.properties配置：   #first first.xaDataSourceClassName=oracle.jdbc.xa.client.OracleXADataSource first.jdbc.driver=oracle.jdbc.driver.OracleDriver firs...
Spring JTA分布式事务实现
热门推荐
王浩的技术博客
08-26 1万+
1.概述 Java Transaction API，通常称为JTA，是用于管理 Java中的事务的API 。它允许我们以资源无关的方式启动，提交和回滚事务。 根据用于管理事务的底层实现，Spring中的事务策略可以分为两个主要部分： 单连接器策略（相当于本地事务管理器） - 底层技术使用单连接器。例如，JDBC使用连接级事务、Hibernate以及JDO使用会话级事务。可以应用使用AOP和拦截器...
JTA-demo：spring+hibernate+jta+mysql
03-29
NULL 博文链接：https://hezhiyu.iteye.com/blog/1284415
Spring+Jotm+Hibernate+Oracle+Junit 实现JTA分布式事务要求Demo工程
01-15
2.Spring+Jotm整合实现JTA分布式事务，应用场景如转账等，同一事务内完成db1用户加100元、db2用户减100元。 3.Spring+Junit4单元测试，优点：不会破坏数据库现场，等等。 （特别注意：Spring3.0里不在提供对jotm的...
EJB 3事务之：容器管理事务（CMT）
一米鸟巢
06-24 1054
Normal 0 7.8 磅 0 2 false false false EN-US ZH-CN X-NONE
Spring boot+Atomikos+JTA+Hibernate+mybatis+MySQL实现分布式事务+多数据源
10-08
springboot+Atomikos+jpa+mysql的JTA分布式事务实现,本案例涉及到2个数据库，预期结果，在同一个事务中，两个库的状态一致
Spring boot+Atomikos+JTA+Hibernate+MySQL实现分布式事务+多数据源（可运行）
09-12
Spring boot+Atomikos+JTA+Hibernate+MySQL实现分布式事务+多数据源，分别向两个不同的数据里面插入数据同时失败和成功，调用接口方式原理一样。
Springboot+Atomikos+Jpa+Mysql实现JTA分布式事务
08-10
myeclipse开发，导入即可用，可以参阅http://www.cnblogs.com/shamo89/p/7326718.html
spring+hibernate+JTA 分布式事务的例子
it_man的专栏
01-20 8271
对于横跨多个Hibernate SessionFacotry的分布式事务，只需简单地将 JtaTransactionManager 同多个 LocalSessionFactoryBean 的定义结合起来作为事务策略。你的每一个DAO通过bean属性得到各自的 SessionFactory 引用。如果所有的底层JDBC数据源都是支持事务的容器，那么只要业务对象使用了 JtaTransactionMa
hibernate 分布式事务的例子
guoli83945的专栏
08-26 135
对于横跨多个Hibernate SessionFacotry的分布式事务，只需简单地将 JtaTransactionManager 同多个 LocalSessionFactoryBean 的定义结合起来作为事务策略。你的每一个DAO通过bean属性得到各自的 SessionFactory 引用。如果所有的底层JDBC数据源都是支持事务的容器，那么只要业务对象使用了 JtaTransactionMa...
web安全学习笔记（6）
m0_58875569的博客
04-06 784
记一下第十节课的内容。
基于Springboot的家具网站
趙兴晨的博客
05-03 557
本文介绍了一款基于现代Web技术构建的家具网站，旨在通过互联网技术优化家具产品的展示与销售，提高用户的购物体验，同时为家具制造商和零售商提供一个高效的在线销售平台。本研究的主要目的是设计并实现一个高效、易用的家具网站，通过系统化的产品展示流程和智能化的购物功能，提升家具产品的在线销售效率和管理水平。本研究通过设计和实现家具网站，有效地解决了传统家具销售中的展示局限性和购物效率低下的问题，提高了家具产品的在线销售效率和用户的购物体验，并为相关领域的研究和实践提供了有益的参考。
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。
XING的博客
05-03 1226
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。数据库作为系统数据储存平台，实现了基于B/S结构的Web系统。界面简洁，操作简单。采用M（model）V（view）C（controller）三层体系结构，通过。
SpringData JPA - ORM 框架下，打造高效数据访问层
最新发布
CYK_byte的博客
05-03 1151
全英文名叫 Java Persistence API，就是 java 持久化 api ，是SUN公司推出的一套基于 ORM 的规范。ORM（Object Relational Mapping）表示对象关系映射. 简单来讲，通过 ORM，就可以把对象映射到关系型数据库中（为了不用 JDBC 那套方法来操作数据库）.
Spring boot 容器中怎么配置事务管理器
05-27
在 Spring Boot 应用中，配置事务管理器可以非常简单，只需要在应用配置文件中添加如下配置即可： ``` spring.datasource.url=jdbc:mysql:/...需要注意的是，如果我们需要使用 JTA 事务管理器，则需要进行额外的配置。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值