spring的事务管理有几种方式实现，如何实现

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了spring的事务管理有几种方式实现，如何实现相关的知识，希望对你有一定的参考价值。

Spring+Hibernate的实质：
就是把Hibernate用到的数据源Datasource，Hibernate的SessionFactory实例，事务管理器HibernateTransactionManager，都交给Spring管理。

那么再没整合之前Hibernate是如何实现事务管理的呢？
通过ServletFilter实现数据库事务的管理，这样就避免了在数据库操作中每次都要进行数据库事务处理。

一.事务的4个特性：
原子性：一个事务中所有对数据库的操作是一个不可分割的操作序列，要么全做，要么全部做。
一致性：数据不会因为事务的执行而遭到破坏。
隔离性：一个事务的执行，不受其他事务（进程）的干扰。既并发执行的个事务之间互不干扰。
持久性：一个事务一旦提交，它对数据库的改变将是永久的。

二.事务的实现方式：
实现方式共有两种：编码方式；声明式事务管理方式。

基于AOP技术实现的声明式事务管理，实质就是：在方法执行前后进行拦截，然后在目标方法开始之前创建并加入事务，执行完目标方法后根据执行情况提交或回滚事务。

声明式事务管理又有两种方式：基于XML配置文件的方式；另一个是在业务方法上进行@Transactional注解，将事务规则应用到业务逻辑中。

三.创建事务的时机：

是否需要创建事务，是由事务传播行为控制的。读数据不需要或只为其指定只读事务，而数据的插入，修改，删除就需要事务管理了。

一种常见的事务管理配置：事务拦截器TransactionInterceptor和事务自动代理BeanNameAutoProxyCreator相结合的方式

<!--定义Hibernate的事务管理器HibernateTransactionManager -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<!-- 依赖注入上面定义的sessionFactory -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>

<!--定义Spring的事务拦截器TransactionInterceptor -->
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
<!-- 依赖注入上面定义的事务管理器transactionManager -->
<property name="transactionManager" ref="transactionManager"/>
<!-- 定义需要进行事务拦截的方法及所采用的事务控制类型 -->
<property name="transactionAttributes">
<props>
<!-- 以browse、list、load、get及is开头的所有方法采用只读型事务控制类型 -->
<prop key="browse*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="list*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>
<!-- 所有方法均进行事务控制，如果当前没有事务，则新建一个事务 -->
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>

<!-- 定义BeanNameAutoProxyCreatorf进行Spring的事务处理-->
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<!-- 针对指定的bean自动生成业务代理 -->
<property name="beanNames">
<list>
<value>adminService</value>
<value>columnsService</value>
<value>newsService</value>
<value>crawlService</value>
<value>memberLevelService</value>
<value>memberService</value>
<value>categoryService</value>
<value>merService</value>
<value>cartService</value>
<value>ordersService</value>
<value>trafficService</value>
</list>
</property>
<!-- 这个属性为true时，表示被代理的是目标类本身而不是目标类的接口 -->
<property name="proxyTargetClass">
<value>true</value>
</property>
<!-- 依赖注入上面定义的事务拦截器transactionInterceptor -->
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value>
</list>
</property>
</bean>

尤其注意：如下
***********************************************************************************************************
【以上的事务拦截器和事务自动代理方式实现原理：像Struts2一样，都是凭借强大的拦截器功能对业务逻辑方法的调用进行拦截，然后又BeanNameAutoProxyCreator自动生成事务代理，最后送事务管理器，统一管理】
***********************************************************************************************************

Spring+Hibernate的实质：
就是把Hibernate用到的数据源Datasource，Hibernate的SessionFactory实例，事务管理器HibernateTransactionManager，都交给Spring管理。

那么再没整合之前Hibernate是如何实现事务管理的呢？
通过ServletFilter实现数据库事务的管理，这样就避免了在数据库操作中每次都要进行数据库事务处理。

一.事务的4个特性：
原子性：一个事务中所有对数据库的操作是一个不可分割的操作序列，要么全做，要么全部做。
一致性：数据不会因为事务的执行而遭到破坏。
隔离性：一个事务的执行，不受其他事务（进程）的干扰。既并发执行的个事务之间互不干扰。
持久性：一个事务一旦提交，它对数据库的改变将是永久的。

二.事务的实现方式：
实现方式共有两种：编码方式；声明式事务管理方式。

基于AOP技术实现的声明式事务管理，实质就是：在方法执行前后进行拦截，然后在目标方法开始之前创建并加入事务，执行完目标方法后根据执行情况提交或回滚事务。

声明式事务管理又有两种方式：基于XML配置文件的方式；另一个是在业务方法上进行@Transactional注解，将事务规则应用到业务逻辑中。

三.创建事务的时机：

是否需要创建事务，是由事务传播行为控制的。读数据不需要或只为其指定只读事务，而数据的插入，修改，删除就需要事务管理了。

一种常见的事务管理配置：事务拦截器TransactionInterceptor和事务自动代理BeanNameAutoProxyCreator相结合的方式

<!--定义Hibernate的事务管理器HibernateTransactionManager -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<!-- 依赖注入上面定义的sessionFactory -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>

<!--定义Spring的事务拦截器TransactionInterceptor -->
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
<!-- 依赖注入上面定义的事务管理器transactionManager -->
<property name="transactionManager" ref="transactionManager"/>
<!-- 定义需要进行事务拦截的方法及所采用的事务控制类型 -->
<property name="transactionAttributes">
<props>
<!-- 以browse、list、load、get及is开头的所有方法采用只读型事务控制类型 -->
<prop key="browse*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="list*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>
<!-- 所有方法均进行事务控制，如果当前没有事务，则新建一个事务 -->
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>

<!-- 定义BeanNameAutoProxyCreatorf进行Spring的事务处理-->
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<!-- 针对指定的bean自动生成业务代理 -->
<property name="beanNames">
<list>
<value>adminService</value>
<value>columnsService</value>
<value>newsService</value>
<value>crawlService</value>
<value>memberLevelService</value>
<value>memberService</value>
<value>categoryService</value>
<value>merService</value>
<value>cartService</value>
<value>ordersService</value>
<value>trafficService</value>
</list>
</property>
<!-- 这个属性为true时，表示被代理的是目标类本身而不是目标类的接口 -->
<property name="proxyTargetClass">
<value>true</value>
</property>
<!-- 依赖注入上面定义的事务拦截器transactionInterceptor -->
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value>
</list>
</property>
</bean>

尤其注意：如下
***********************************************************************************************************
【以上的事务拦截器和事务自动代理方式实现原理：像Struts2一样，都是凭借强大的拦截器功能对业务逻辑方法的调用进行拦截，然后又BeanNameAutoProxyCreator自动生成事务代理，最后送事务管理器，统一管理】
*********************************************************************************************************** 参考技术A

实现方式共有两种：编码方式；声明式事务管理方式。

基于AOP技术实现的声明式事务管理，实质就是：在方法执行前后进行拦截，然后在目标方法开始之前创建并加入事务，执行完目标方法后根据执行情况提交或回滚事务。

声明式事务管理又有两种方式：基于XML配置文件的方式；另一个是在业务方法上进行@Transactional注解，将事务规则应用到业务逻辑中。

事务的4个特性：

    原子性：一个事务中所有对数据库的操作是一个不可分割的操作序列，要么全做，要么全部做。

    一致性：数据不会因为事务的执行而遭到破坏。

    隔离性：一个事务的执行，不受其他事务（进程）的干扰。既并发执行的个事务之间互不干扰。

    持久性：一个事务一旦提交，它对数据库的改变将是永久的。


 参考技术B 两种方式实现
1.声明式事务2.编程式事务

bean的实例化有几种实现方式

在spring中有三中实例化bean的方式：

一、使用构造器实例化；（90%通常使用的一个方法）

二、使用静态工厂方法实例化；

三、使用实例化工厂方法实例化。

 

每种实例化所采用的配置是不一样的：

一、使用构造器实例化；

这种实例化的方式可能在我们平时的开发中用到的是最多的，因为在xml文件中配置简单并且也不需要额外的工厂类来实现。

 

Xml代码  
  1. <!--applicationContext.xml配置：-->  
  2.   
  3. <bean id="personService" class="cn.mytest.service.impl.PersonServiceBean"></bean>  

 

 id是对象的名称，class是要实例化的类，然后再通过正常的方式进调用实例化的类即可，比如：

 

Java代码  
  1. public void instanceSpring(){  
  2.                 //加载spring配置文件  
  3.         ApplicationContext ac = new ClassPathXmlApplicationContext(  
  4.                 new String[]{  
  5.                         "/conf/applicationContext.xml"  
  6.                 });  
  7.         //调用getBean方法取得被实例化的对象。  
  8.         PersonServiceBean psb = (PersonServiceBean) ac.getBean("personService");  
  9.           
  10.         psb.save();  
  11. }  

 

采用这种实例化方式要注意的是：要实例化的类中如果有构造器的话，一定要有一个无参的构造器。

 

二、使用静态工厂方法实例化；

根据这个中实例化方法的名称就可以知道要想通过这种方式进行实例化就要具备两个条件：（一）、要有工厂类及其工厂方法；（二）、工厂方法是静态的。OK，知道这两点就好办了，首先创建工程类及其静态方法：

 

Java代码  
  1. package cn.mytest.service.impl;  
  2.   
  3. /** 
  4. *创建工厂类 
  5. * 
  6. */  
  7. public class PersonServiceFactory {  
  8.     //创建静态方法  
  9.     public static PersonServiceBean createPersonServiceBean(){  
  10.          //返回实例化的类的对象  
  11.         return new PersonServiceBean();  
  12.     }  
  13. }  

 然后再去配置spring配置文件，配置的方法和上面有点不同，这里也是关键所在

 

Xml代码  
  1. <!--applicationContext.xml配置：-->  
  2.   
  3. <bean id="personService1" class="cn.mytest.service.impl.PersonServiceFactory" factory-method="createPersonServiceBean"></bean>  

 id是实例化的对象的名称，class是工厂类，也就实现实例化类的静态方法所属的类，factory-method是实现实例化类的静态方法。

然后按照正常的调用方法去调用即可：

 

Java代码  
  1. public void instanceSpring(){  
  2.                 //加载spring配置文件  
  3.         ApplicationContext ac = new ClassPathXmlApplicationContext(  
  4.                 new String[]{  
  5.                         "/conf/applicationContext.xml"  
  6.                 });  
  7.         //调用getBean方法取得被实例化的对象。  
  8.         PersonServiceBean psb = (PersonServiceBean) ac.getBean("personService1");  
  9.           
  10.         psb.save();  
  11. }  

 

三、使用实例化工厂方法实例化。

这个方法和上面的方法不同之处在与使用该实例化方式工厂方法不需要是静态的，但是在spring的配置文件中需要配置更多的内容，，首先创建工厂类及工厂方法：

 

Java代码  
  1. package cn.mytest.service.impl;  
  2.   
  3. /** 
  4. *创建工厂类 
  5. * 
  6. */  
  7. public class PersonServiceFactory {  
  8.     //创建静态方法  
  9.     public PersonServiceBean createPersonServiceBean1(){  
  10.          //返回实例化的类的对象  
  11.         return new PersonServiceBean();  
  12.     }  
  13. }  

 

  然后再去配置spring配置文件，配置的方法和上面有点不同，这里也是关键所在

 

Xml代码  
  1. <!--applicationContext.xml配置：-->  
  2.   
  3. <bean id="personServiceFactory" class="cn.mytest.service.impl.PersonServiceFactory"></bean>  
  4.   
  5. <bean id="personService2" factory-bean="personServiceFactory" factory-method="createPersonServiceBean1"></bean>  

 这里需要配置两个bean，第一个bean使用的构造器方法实例化工厂类，第二个bean中的id是实例化对象的名称，factory-bean对应的被实例化的工厂类的对象名称，也就是第一个bean的id，factory-method是非静态工厂方法。

 

 

然后按照正常的调用方法去调用即可：

 

Java代码  
  1. public void instanceSpring(){  
  2.                 //加载spring配置文件  
  3.         ApplicationContext ac = new ClassPathXmlApplicationContext(  
  4.                 new String[]{  
  5.                         "/conf/applicationContext.xml"  
  6.                 });  
  7.         //调用getBean方法取得被实例化的对象。  
  8.         PersonServiceBean psb = (PersonServiceBean) ac.getBean("personService2");  
  9.           
  10.         psb.save();  
  11. } 

以上是关于spring的事务管理有几种方式实现，如何实现的主要内容，如果未能解决你的问题，请参考以下文章

Spring的事务管理有几种方式？Spring常用的实物隔离级别是哪几种？

SQL Server启动事务有几种方式？

spring 事务实现方式都有哪些?

Spring有几种配置方式 ？

spring的注入方式有几种

spring管理java类有几种方式