spring注解事务

@Transactional spring 配置事务 注意事项

 

 

近日来，发现有很多童鞋询问：“Mybatis整合Spring3，事务注解为何不起作用？ ”，“已经声明了事务，但是无法回滚。。。”“Mybatis如果配置事务，Spring配置没起作用啊！”等等，实际上，无论怎么问或者怎么贴出代码，实际上没有人能够帮你解决这个问题的，首先Spring事务处理方式目前有五种，你用的到底是哪一种呢？回答问题的大神们不清楚，因此他们的回答和招在你那里不会起作用，因此，无论是哪一种事务处理方式首先你要弄明白你用的是哪一种，如果是杂交方式，建议选择事务处理的第四种方式：使用tx标签配置的拦截器，这个简单而且容易上手，如果用这种方式还有问题，那请往下看，有很大可能性是由于这些原因造成的，我们在罗列代码的时候一定要知其然还要知其所以然，这样你不仅能够快速的解决自己的问题，还能够把该问题解决办法与他人共享！

 

 

1. 在需要事务管理的地方加@Transactional 注解。@Transactional 注解可以被应用于接口定义和接口方法、类定义和类的 public 方法上 。

2. @Transactional 注解只能应用到 public 可见度的方法上 。 如果你在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解，它也不会报错， 但是这个被注解的方法将不会展示已配置的事务设置。

3. 注意仅仅 @Transactional 注解的出现不足于开启事务行为，它仅仅 是一种元数据。必须在配置文件中使用配置元素，才真正开启了事务行为。

4. 通过 元素的 "proxy-target-class" 属性值来控制是基于接口的还是基于类的代理被创 建。 如果 "proxy-target-class" 属值被设置为 "true"，那么基于类的代理将起作用（这时需要CGLIB库cglib.jar在CLASSPATH中）。如果 "proxy-target-class" 属值被设置为 "false" 或者这个属性被省略，那么标准的JDK基于接口的代理将起作用。

<!-- JTA事务（非分布式事务）， 事务配置的时候 ，不能指定dataSource属性（分布式事务，是有全局事务来管理数据库链接的）--> <!-- 标准的JDK基于接口的代理将起作用 --><!-- aop切面 -->    <aop:aspectj-autoproxy proxy-target-class="false" /><!-- 基于类的代理将起作用 ,同时 cglib.jar必须在CLASSPATH中 --><!-- aop切面 -->    <aop:aspectj-autoproxy proxy-target-class="true" />

 注 解@Transactional cglib与java动态代理最大区别是代理目标对象不用实现接口, 那么注解要是写到接口方法上，要是使用cglib代理，这是注解事物就失效了，为了保持兼容注解最好都写到实现类方法上。

5. Spring团队建议在具体的类（或类的方法）上使用 @Transactional 注解，而不要使用在类所要实现的任何接口上 。在接口上使用 @Transactional 注解，只能当你设置了基于接口的代理时它才生效。因为注解是 不能继承 的，这就意味着如果正在使用基于类的代理时，那么事务的设置将不能被基于类的代理所识别，而且对象也将不会被事务代理所包装。

6. @Transactional 的事务开启 ，或者是基于接口的 或者是基于类的代理被创建。所以在同一个类中一个方法调用另一个方法有事务的方法，事务是不会起作用的 。

public interface PersonageTempService {//删除指定id的Personagepublic void del(Integer Personageid) ;//删除指定id的Personage,flagpublic void del(Integer Personageid,boolean flag) ;}public class PersonageTempServiceBean implements PersonageTempService {private JdbcTemplate jdbcTemplate;public void del(Integer Personageid){try{this.del(Personageid,true)System.out.println("del success");}catch(Exception e){System.out.println("del failed");}}@Transactional//此时，事务根本就没有开启, 即数据库会默认提交该操作，即记录别删除掉public void del(Integer Personageid,boolean flag){if(flag == ture){jdbcTemplate.update("del from Personage where id=?", new Object[]{Personageid}, new int[]{java.sql.Types.INTEGER});throw new RuntimeException("运行期例外");}}}public class PersonageTempServiceBeanTest{PersonageTempService ps = new PersonageTempServiceBean ();ps.del(5);}}

 7. Spring使用声明式事务处理，默认情况下， 如果被注解的数据库操作方法中发生了unchecked异常，所有的数据库操作将rollback ；如果发生的异常是checked异常，默认情况下数 据库操作还是会提 交的。

public interface PersonageService {//删除指定id的Personagepublic void del(Integer Personageid) ;//获取Personagepublic Personage getPersonage(Integer Personageid);}//PersonageServiceBean 实现了PersonageService 接口，则基于接口的还是基于类的代理 都可以实现事务@Transactional public class PersonageServiceBean implements PersonageService {private JdbcTemplate jdbcTemplate;//发生了unchecked异常,事务回滚, @Transactionalpublic void del(Integer Personageid){jdbcTemplate.update("del from Personage where id=?", new Object[]{Personageid},new int[]{java.sql.Types.INTEGER});throw new RuntimeException("运行期例外");}}

 

public interface PersonageService {//删除指定id的Personagepublic void delete(Integer Personageid) throws Exception;//获取Personagepublic Personage getPersonage(Integer Personageid);}@Transactionalpublic class PersonageServiceBean implements PersonageService {//发生了checked异常,事务不回滚,即数据库记录仍能被删除，//checked的例外，需要我们在外部用try/catch语法对调用该方法的地方进行包含 @Transactionalpublic void delete(Integer Personageid) throws Exception{jdbcTemplate.update("delete from Personage where id=?", new Object[]{Personageid},new int[]{java.sql.Types.INTEGER});throw new Exception("运行期例外");}}

 但是，对于checked这种例外，默认情况下它是不会进行事务回滚的，但是 如果我们需要它进行事务回滚，这时候可以在delete方法上通过@Transaction这个注解来修改它的行为。

@Transactionalpublic class PersonServiceBean implements PersonService {@Transactional(rollbackFor=Exception.class)//rollbackFor这属性指定了，既使你出现了checked这种例外，那么它也会对事务进行回滚public void delete(Integer personid) throws Exception{jdbcTemplate.update("delete from person where id=?", new Object[]{personid},new int[]{java.sql.Types.INTEGER});throw new Exception("运行期例外");}}

 

在PersonServiceBean这个业务bean里面，有一些事务是不需要事务管理的，好比说获取数据的getPersons方法，getPerson方法。因为@Transactional 放在了类的上面。

此时，可 以采用propagation这个事务属性 @Transactional(propagation=Propagation.NOT_SUPPORTED)，propagation这个属性指定了 事务传播行为，我们可以指定它不支持事务，当我们这么写了之后，Spring容器在getPersons方法执行前就不会开启事务 .

@Transactionalpublic class PersonServiceBean implements PersonService {@Transactional(propagation=Propagation.NOT_SUPPORTED)//则此方法 就不会开启事务了public Person getPerson(Integer personid){}}

 =================================================================================

spring @Transaction 事务控制
1. 第一种用法
--spring.xml 配置文件中
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/> 
</bean> 



<tx:annotation-driven transaction-manager="txManager"/>
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>

--java service 代码中
@Service("userService")
@Transactional(readOnly = true)
public class UserServiceImpl implements IUserService {

@Transactional(readOnly = false, propagation = Propagation.REQUIRES_NEW)
public void insertUserAndRole(User user, Role role) {
。。。。
｝

｝
2.第二种用法

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean> 

<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="get*" read-only="true"/>
<tx:method name="find*" read-only="true"/>
<tx:method name="*"/>
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="allServiceOperation" expression="execution(* com.frank.test.service.I*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="allServiceOperation"/>
</aop:config>



注意：

匹配格式： com.frank.test.service.I*（接口名）.*(..)

=========================================================================

 @Transactional只能被应用到public方法上, 对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能.

Spring使用声明式事务处理，默认情况下，如果被注解的数据库操作方法中发生了unchecked异常，所有的数据库操作将rollback；如果发生的异常是checked异常，默认情况下数据库操作还是会提交的。
这种默认的行为是可以改变的。

使用@Transactional注解的noRollbackFor和rollbackFor属性

如：@Transactional(rollbackFor=Exception.class)可以使checked异常发生时，数据库操作也rollback、@Transactional(noRollbackFor=RuntimeException.class)可以使unchecked异常发生时也提交数据库操作。

也可以使用noRollbackForClassName、rollbackForClassName属性来指定一个异常类名的String数组来改变默认的行为。

 
读取数据库中的数据时是不需要事务管理的，这种情况下可以使用事务的传播行为来告诉Spring不需要开启事务，
如：@Transactional(propagation = Propagation.NOT_SUPPORTED)。

事务的传播行为有：

1.           REQUIRED：表示业务方法需要在一个事务中处理，如果业务方法执行时已经在一个事务中，则加入该事务，否则重新开启一个事务。这也是默认的事务传播行为；

2.           NOT_SUPPORTED：声明业务方法不需要事务，如果业务方法执行时已经在一个事务中，则事务被挂起，等方法执行完毕后，事务恢复进行；

3.           REQUIRES_NEW：表明业务方法需要在一个单独的事务中进行，如果业务方法进行时已经在一个事务中，则这个事务被挂起，并重新开启一个事务来执行这个业务方法，业务方法执行完毕后，原来的事务恢复进行；

4.           MANDATORY：该属性指定业务方法只能在一个已经存在的事务中进行，业务方法不能发起自己的事务；如果业务方法没有在一个既有的事务中进行，容器将抛出异常；

5.           SUPPORTS：该属性指定，如果业务方法在一个既有的事务中进行，则加入该事务；否则，业务方法将在一个没有事务的环境下进行；

6.           NEVER：指定业务方法不可以在事务中进行，如果业务方法执行时已经在一个事务中，容器将抛出异常；

7.           NESTED：该属性指定，如果业务方法在一个既有的事务中执行，则该业务方法将在一个嵌套的事务中进行；否则，按照REQUEIRED来对待。它使用一个单独的事务，这个事务可以有多个rollback点，内部事务的rollback对外部事务没有影响，但外部事务的rollback会导致内部事务的rollback。这个行为只对DataSourceTransactionManager有效。

 

事务的隔离级别

  使用@Transactional的Isolation属性可以指定事务的隔离级别。但事务的隔离级别是由底层的数据库实现的，并不是由Spring来实现。

1.       READ_UNCOMMITTED：会出现脏读、不可重复读和幻读问题；

2.       READ_COMMITTED：会出现不可重复读和幻读问题；

3.       REPEATABLE_READ：会出现幻读问题；

4.       SERIALIZABLE：串行化，不会出现上面的问题。

  一般的数据库默认提供的是READ_COMMITTED隔离级别，如sqlserver2000；Mysql默认提供的是REPEATABLE_READ。

@Transactional  的所有可选属性如下:
属性     类型     默认值     说明
propagation                               Propagation枚举     REQUIRED     事务传播属性 
isolation                                     isolation枚举             DEFAULT     事务隔离级别
readOnly                                    boolean                      false     是否只读
timeout                                       int                               -1     超时(秒)
rollbackFor                                Class[]  {}                  需要回滚的异常类
rollbackForClassName           String[]  {}                  需要回滚的异常类名
noRollbackFor                          Class[]  {}                  不需要回滚的异常类
noRollbackForClassName     String[]  {}                  不需要回滚的异常类名


//事务传播属性
    @Transactional(propagation=Propagation.REQUIRED) //如果有事务,那么加入事务,没有的话新建一个(不写的情况下)
    @Transactional(propagation=Propagation.NOT_SUPPORTED) //容器不为这个方法开启事务
    @Transactional(propagation=Propagation.REQUIRES_NEW) //不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
    @Transactional(propagation=Propagation.MANDATORY) //必须在一个已有的事务中执行,否则抛出异常
    @Transactional(propagation=Propagation.NEVER) //必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)
    @Transactional(propagation=Propagation.SUPPORTS) //如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务.
    
 
    @Transactional(propagation=Propagation.NESTED) 
    @Transactional (propagation = Propagation.REQUIRED,readOnly=true) //readOnly=true只读,不能更新,删除 
    @Transactional (propagation = Propagation.REQUIRED,timeout=30)//设置超时时间 
    @Transactional (propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT)//设置数据库隔离级别


用 spring 事务管理器,由spring来负责数据库的打开,提交,回滚.
默认遇到运行期例外(throw new RuntimeException("注释");)会回滚，即遇到不受检查（unchecked）的例外时回滚；
而遇到需要捕获的例外(throw new Exception("注释");)不会回滚,即遇到受检查的例外（就是非运行时抛出的异常，编译器会检查到的异常叫受检查例外或说受检查异常）时，需我们指定方式来让事务回滚 ,如下:
@Transactional(rollbackFor=Exception.class) //指定回滚,遇到异常Exception时回滚
    public void methodName() {
       throw new Exception("注释");
       
    }
@Transactional(noRollbackFor=Exception.class)//指定不回滚,遇到运行期例外(throw new RuntimeException("注释");)会回滚
    public ItimDaoImpl getItemDaoImpl() {
        throw new RuntimeException("注释");
    }