@transactional 使用注意事宜

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的Personage
    public void del(Integer Personageid) ;

    //删除指定id的Personage,flag
    public 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的Personage
    public void del(Integer Personageid) ;

    //获取Personage
    public Personage getPersonage(Integer Personageid);
    }

    //PersonageServiceBean 实现了PersonageService 接口，则基于接口的仍是基于类的代理 均可以实现事务
    @Transactional public class PersonageServiceBean implements PersonageService {
    private JdbcTemplate jdbcTemplate;

    //发生了unchecked异常,事务回滚, @Transactional
    public 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的Personage
    public void delete(Integer Personageid) throws Exception;

    //获取Personage
    public Personage getPersonage(Integer Personageid);
    }

    @Transactional
    public class PersonageServiceBean implements PersonageService {

    //发生了checked异常,事务不回滚,即数据库记录仍能被删除，
    //checked的例外，须要咱们在外部用try/catch语法对调用该方法的地方进行包含 @Transactional
    public 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这个注解来修改它的行为。

@Transactional
public 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方法执行前就不会开启事务.

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

 

 

 

 

 

 

方法的可见度和 @Transactional
注解应该只被应用到可见度的方法上。 
    若是你在 protected、private 或者 package-visible 的方法上使用 @Transactional注解，它也不会报错， 
可是这个被注解的方法将不会展现已配置的事务设置。
@Transactional注解能够被应用于接口定义和接口方法、类定义和类的方法上。
   然而，请注意仅仅注解的出现不足于开启事务行为，它仅仅是一种元数据，可以被能够识别@Transactional注解和上述
的配置适当的具备事务行为的beans所使用。
   Spring团队的建议是你在具体的类（或类的方法）上使用@Transactional注解，而不要使用在类所要实现的任何接口上。
你固然能够在接口上使用@Transactional注解，可是这将只能当你设置了基于接口的代理时它才生效。由于注解是不能继承
的，这就意味着若是你正在使用基于类的代理时，那么事务的设置将不能被基于类的代理所识别，并且对象也将不会被事务代理
所包装（将被确认为严重的）。所以，请接受Spring团队的建议而且在具体的类上使用@Transactional注解。 
注意: 
当使用@Transactional风格的进行声明式事务定义时，你能够经过 <tx:annotation-driven/> 元素的 
proxy-target-class 属性值来控制是基于接口的仍是基于类的代理被建立。若是 "proxy-target-class" 
属值被设置为 "true"，那么基于类的代理将起做用（这时须要CGLIB库cglib.jar在CLASSPATH中）。
若是 "<code class=literal>proxy-target-class</code>" 属值被设置为 "<code class=literal>false</code>"
 或者这个属性被省略，那么标准的JDK基于接口的代理将起做用。 
在多数情形下，方法的事务设置将被优先执行。在下列状况下，例如： <code class=classname>DefaultFooService</code> 类被注解为只读事务，可是，这个
类中的 <code class=methodname>updateFoo(Foo)</code> 方法的 <code class=interfacename>@Transactional</code>
 注解的事务设置将优先于类级别注解的事务设置。