事务模板接入
 
这里接入的是spring的编程式事务，代理一下spring的TransactionTemplate就可以了。
 
 
 
import org.springframework.transaction.TransactionException;
 
import org.springframework.transaction.support.TransactionCallback;
 
import org.springframework.transaction.support.TransactionTemplate;
 
 
 
/**
 
 * 事务模板
 
 *
 
 * @author jiacheng.yjc
 
 * @version $Id: TranscationTemplate.java, v 0.1 2015年11月18日 上午11:17:58 jiacheng.yjc Exp $
 
 */
 
public class TrancTemplateImpl implements TrancTemplate {
 
 
 
    private TransactionTemplate transactionTemplate;
 
    //这个是为了一个事务不够的时候也不用再new一个,直接用这个就行
 
    private TransactionTemplate transactionNewTemplate;
 
 
 
    /**
 
     *
 
     * @see com.mybank.bkloanapply.core.service.component.tx.TrancTemplate#execute(org.springframework.transaction.support.TransactionCallback)
 
     */
 
    @Override
 
    public <T> T execute(TransactionCallback<T> action) throws TransactionException {
 
        return transactionTemplate.execute(action);
 
    }
 
 
 
    /**
 
     *
 
     * @see com.mybank.bkloanapply.core.service.component.tx.TrancTemplate#executeReqNew(org.springframework.transaction.support.TransactionCallback)
 
     */
 
    @Override
 
    public <T> T executeReqNew(TransactionCallback<T> action) throws TransactionException {
 
        return transactionNewTemplate.execute(action);
 
    }
 
 
 
    /**
 
     * Setter method for property <tt>transactionTemplate</tt>.
 
     *
 
     * @param transactionTemplate value to be assigned to property transactionTemplate
 
     */
 
    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
 
        this.transactionTemplate = transactionTemplate;
 
    }
 
 
 
    /**
 
     * Setter method for property <tt>transactionNewTemplate</tt>.
 
     *
 
     * @param transactionNewTemplate value to be assigned to property transactionNewTemplate
 
     */
 
    public void setTransactionNewTemplate(TransactionTemplate transactionNewTemplate) {
 
        this.transactionNewTemplate = transactionNewTemplate;
 
    }
 
}
 
 
 
模板的接入使用
 
/**
 
     * 测试用例，插入一条日志记录
 
     *
 
     */
 
    @Override
 
    public String logTest(LogModel logModel) {
 
        final LogModel logModel_ = logModel;
 
        trancTemplate.execute(new TransactionCallback<LogModel>() {
 
            @Override
 
            public LogModel doInTransaction(TransactionStatus status) {
 
                logComponent.insert(logModel_);
 
                //do otherthings…
 
                return logModel_;
 
            }
 
        });
 
        return "执行成功";
 
}
 
当insert语句执行出错或者do otherthings时出错都会自动回滚，不需要手动trycatch然后status.setRollbackOnly();回滚，很方便。

事务管理（ACID）
 
谈到事务一般都是以下四点
 
原子性（Atomicity）
 原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
 一致性（Consistency）
 事务前后数据的完整性必须保持一致。
 隔离性（Isolation）
 事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
 持久性（Durability）
 持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响
 
举个简单的例子理解以上四点
 
原子性
 
针对同一个事务
 
 
这个过程包含两个步骤
 
A： 800 - 200 = 600
 B: 200 + 200 = 400
 
原子性表示，这两个步骤一起成功，或者一起失败，不能只发生其中一个动作
 
一致性（Consistency）
 
针对一个事务操作前与操作后的状态一致
 
 
操作前A：800，B：200
 操作后A：600，B：400
 
一致性表示事务完成后，符合逻辑运算
 
持久性（Durability）
 
表示事务结束后的数据不随着外界原因导致数据丢失
 
操作前A：800，B：200
 操作后A：600，B：400
 如果在操作前（事务还没有提交）服务器宕机或者断电，那么重启数据库以后，数据状态应该为
 A：800，B：200
 如果在操作后（事务已经提交）服务器宕机或者断电，那么重启数据库以后，数据状态应该为
 A：600，B：400
 
隔离性（Isolation）
 
针对多个用户同时操作，主要是排除其他事务对本次事务的影响
 

 事务一）A向B转账200
 事务二）C向B转账100
 
两个事务同时进行，其中一个事务读取到另外一个事务还没有提交的数据，执行步骤如图所示，按照数字顺序执行
 
 隔离性用于解决以上问题
 
 
事务的隔离级别
 
脏读：
 
指一个事务读取了另外一个事务未提交的数据。
 
 
不可重复读：
 
在一个事务内读取表中的某一行数据，多次读取结果不同。（这个不一定是错误，只是某些场合不对）
 
页面统计查询值
 
 生成报表的时候，B有人转账进来300（B事务已经提交）
 
 
虚读(幻读)
 
是指在一个事务内读取到了别的事务插入的数据，导致前后读取数量总量不一致。
 （一般是行影响，如下图所示：多了一行）
 
 
四种隔离级别设置
 
数据库
 
set transaction isolation level 设置事务隔离级别
 select @@tx_isolation 查询当前事务隔离级别
 
设置
描述
Serializable
可避免脏读、不可重复读、虚读情况的发生。（串行化）
Repeatable read
可避免脏读、不可重复读情况的发生。（可重复读）
Read committed
可避免脏读情况发生（读已提交）。
Read uncommitted
最低级别，以上情况均无法保证。(读未提交)
java
 
适当的 Connection 方法，比如 setAutoCommit 或 setTransactionIsolation
 
设置
描述
TRANSACTION_SERIALIZABLE
指示不可以发生脏读、不可重复读和虚读的常量。
TRANSACTION_REPEATABLE_READ
指示不可以发生脏读和不可重复读的常量；虚读可以发生。
TRANSACTION_READ_UNCOMMITTED
指示可以发生脏读 (dirty read)、不可重复读和虚读 (phantom read) 的常量。
TRANSACTION_READ_COMMITTED
指示不可以发生脏读的常量；不可重复读和虚读可以发生。
事务演示
 
 
这里使用控制台演示，命令行登录方式
 
mysql -h localhost -uroot -p
 
数据测试准备
 
create database db_test;
use db_test;

CREATE TABLE `AMOUNT` (
`id`  varchar(10) NULL,
`money`  numeric NULL
)
;

insert into amount(id,money) values('A', 800);
insert into amount(id,money) values('B', 200);
insert into amount(id,money) values('C', 1000);
insert into amount(id,money) values('D', 1000);
 

 操作成功如图所示，检查数据：select * from amount;
 
mysql事务隔离性相关语句说明
 
--  查询当前控制台（客户端）当前事务级别
SELECT @@session.tx_isolation;   
SELECT @@tx_isolation;  
--  设置当前控制台（客户端）当前事务级别
SET SESSION TRANSACTION ISOLATION LEVEL read uncommitted;  
SET SESSION TRANSACTION ISOLATION LEVEL read committed;  
SET SESSION TRANSACTION ISOLATION LEVEL repeatable read;  
SET SESSION TRANSACTION ISOLATION LEVEL serializable;  

--开启事务
start transaction;
--提交事务，同时事务结束
commit;
--回退事务，回退操作，同时事务结束
rollback
 
案列1：脏读演示，读到其他事务未提交的数据
 
操作步骤
 
事务一（右）：A向B转200，不提交事务
事务二（左）：查看B金额
事务一（右）：回滚事务
事务二（左）：查看B金额
 
改变事务二（左）事务级别为READ-UNCOMMITTED
 
 
gif演示
 
 转账SQL
 
update amount set money = money - 200 where id = 'A';
update amount set money = money + 200 where id = 'B';
 
事务二（左）在事务中，查询到其他事务还没有提交（commit/rollback）的事务
 
其他事务级别请自行测试（与理论预期一致）
 
案列2，将事务二（左）在事务设置为REPEATABLE-READ，再看看操作结果（操作步骤同案例1，步骤三改为提交事务-commit）
案列3，将事务二（左）在事务设置为REPEATABLE-READ，再看看操作结果（操作步骤同案例1，步骤三改为提交事务-commit）
案列4，将事务二（左）在事务设置为SERIALIZABLE，再看看操作结果（操作步骤同案例1）
 
这里说明一下，SERIALIZABLE事务是串行执行，演示的时候只能由其中一个客户端操作，直到提交事务，另外一个客户端才能操作。

事务的三种类型
 
Java事务的类型有三种：JDBC事务、JTA(Java Transaction API)事务、容器事务
 
1、JDBC事务
 
JDBC 事务是用 Connection 对象控制的。JDBC Connection 接口( java.sql.Connection )提供了两种事务模式：自动提交和手工提交。 java.sql.Connection 提供了以下控制事务的方法：
 
public void setAutoCommit(boolean)
public boolean getAutoCommit()
public void commit()
public void rollback()
 
使用 JDBC 事务界定时，您可以将多个 SQL 语句结合到一个事务中。JDBC 事务的一个缺点是事务的范围局限于一个数据库连接。一个 JDBC 事务不能跨越多个数据库。
 
2.JTA(Java Transaction API)事务
 
JTA是一种高层的，与实现无关的，与协议无关的API，应用程序和应用服务器可以使用JTA来访问事务。
 
JTA允许应用程序执行分布式事务处理–在两个或多个网络计算机资源上访问并且更新数据，这些数据可以分布在多个数据库上。JDBC驱动程序的JTA支持极大地增强了数据访问能力。
 
如果计划用 JTA 界定事务，那么就需要有一个实现 javax.sql.XADataSource 、 javax.sql.XAConnection 和 javax.sql.XAResource 接口的 JDBC 驱动程序。一个实现了这些接口的驱动程序将可以参与 JTA 事务。一个 XADataSource 对象就是一个 XAConnection 对象的工厂。 XAConnection s 是参与 JTA 事务的 JDBC 连接。
 
您将需要用应用服务器的管理工具设置 XADataSource 。从应用服务器和 JDBC 驱动程序的文档中可以了解到相关的指导。
 
J2EE 应用程序用 JNDI 查询数据源。一旦应用程序找到了数据源对象，它就调用 javax.sql.DataSource.getConnection() 以获得到数据库的连接。
 
XA 连接与非 XA 连接不同。一定要记住 XA 连接参与了 JTA 事务。这意味着 XA 连接不支持 JDBC 的自动提交功能。同时，应用程序一定不要对 XA 连接调用 java.sql.Connection.commit() 或者 java.sql.Connection.rollback() 。相反，应用程序应该使用 UserTransaction.begin()、 UserTransaction.commit() 和 serTransaction.rollback() 。
 
3、容器事务
 
容器事务主要是J2EE应用服务器提供的，容器事务大多是基于JTA完成，这是一个基于JNDI的，相当复杂的API实现。相对编码实现JTA事务管理，我们可以通过EJB容器提供的容器事务管理机制（CMT）完成同一个功能，这项功能由J2EE应用服务器提供。这使得我们可以简单的指定将哪个方法加入事务，一旦指定，容器将负责事务管理任务。这是我们土建的解决方式，因为通过这种方式我们可以将事务代码排除在逻辑编码之外，同时将所有困难交给 J2EE容器去解决。使用EJB CMT的另外一个好处就是程序员无需关心JTA API的编码，不过，理论上我们必须使用EJB。
 
三种事务差异：
 
1、JDBC事务控制的局限性在一个数据库连接内，但是其使用简单。
 2、JTA事务的功能强大，事务可以跨越多个数据库或多个DAO，使用也比较复杂。
 3、容器事务，主要指的是J2EE应用服务器提供的事务管理，局限于EJB应用使用。
 
总结：
 
事务控制是构建J2EE应用不可缺少的一部分，合理选择应用何种事务对整个应用系统来说至关重要。一般说来，在单个JDBC 连接连接的情况下可以选择JDBC事务，在跨多个连接或者数据库情况下，需要选择使用JTA事务，如果用到了EJB，则可以考虑使用EJB容器事务。
 
参考：https://www.cnblogs.com/baizhanshi/p/5159332.html
 
举例：Spring容器事务：
 
Spring事务管理的实现有许多细节，如果对整个接口框架有个大体了解会非常有利于我们理解事务，下面通过讲解Spring的事务接口来了解Spring实现事务的具体策略。
 
Spring事务管理涉及的接口及其联系：
 
 Spring并不直接管理事务，而是提供了多种事务管理器，他们将事务管理的职责委托给Hibernate或者JTA等持久化机制所提供的相关平台框架的事务来实现。 Spring事务管理器的接口是org.springframework.transaction.PlatformTransactionManager，通过这个接口，Spring为各个平台如JDBC、Hibernate等都提供了对应的事务管理器，但是具体的实现就是各个平台自己的事情了
 
Public interface PlatformTransactionManager{  
       // 由TransactionDefinition得到TransactionStatus对象
       TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
    // 提交
       Void commit(TransactionStatus status) throws TransactionException;  
       // 回滚
       Void rollback(TransactionStatus status) throws TransactionException;  
}
 
1)、Spring JDBC事务
 
如果应用程序中直接使用JDBC来进行持久化，DataSourceTransactionManager会为你处理事务边界。为了使用 DataSourceTransactionManager，你需要使用如下的XML将其装配到应用程序的上下文定义中
 
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource" ref="dataSource" />
</bean>
 
实际上，DataSourceTransactionManager是通过调用java.sql.Connection来管理事务。通过调用连接的commit()方法来提交事务，同样，事务失败则通过调用rollback()方法进行回滚
 
2)、Hibernate事务
 
如果应用程序的持久化是通过Hibernate实现的，那么你需要使用HibernateTransactionManager。对于Hibernate3，需要在Spring上下文定义中添加如下的<bean>声明
 
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
     <property name="sessionFactory" ref="sessionFactory" />
</bean>
 
sessionFactory属性需要装配一个Hibernate的session工厂，HibernateTransactionManager的实现细节是它将事务管理的职责委托给org.hibernate.Transaction对象，而后者是从Hibernate Session中获取到的。当事务成功完成时，HibernateTransactionManager将会调用Transaction对象的commit()方法，反之，将会调用rollback()方法。
 
3)、Java持久化API事务（JPA）
 Hibernate多年来一直是事实上的Java持久化标准，但是现在Java持久化API作为真正的Java持久化标准进入大家的视野。如果你计划使用JPA的话，那你需要使用Spring的JpaTransactionManager来处理事务。你需要在Spring中这样配置JpaTransactionManager：
 
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
     <property name="sessionFactory" ref="sessionFactory" />
</bean>
 
JpaTransactionManager只需要装配一个JPA实体管理工厂（javax.persistence.EntityManagerFactory接口的任意实现）。JpaTransactionManager将与由工厂所产生的JPA EntityManager合作来构建事务
 
事务管理器接口PlatformTransactionManager通过getTransaction(TransactionDefinition definition)方法来得到事务，这个方法里面的参数是TransactionDefinition类，这个类就定义了一些基本的事务属性。
 
事务属性可以理解成事务的一些基本配置，描述了事务策略如何应用到方法上。
 
事务属性包含了5个方面:
 
传播行为、隔离规则、回滚规则、事务超时、是否只读
 
public interface TransactionDefinition {
    int getPropagationBehavior(); // 返回事务的传播行为
    int getIsolationLevel(); // 返回事务的隔离级别，事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据
    int getTimeout();  // 返回事务必须在多少秒内完成
    boolean isReadOnly(); // 事务是否只读，事务管理器能够根据这个返回值进行优化，确保事务是只读的
}
 
参考 https://blog.csdn.net/weixin_37934748/article/details/82774230
 
与事务相关的理论
 
1.事务(Transaction)的四个属性(ACID）
 
 
 
原子性(Atomic) 对数据的修改要么全部执行，要么全部不执行。
 一致性(Consistent) 在事务执行前后，数据状态保持一致性。
 隔离性(Isolated) 一个事务的处理不能影响另一个事务的处理。
 持续性(Durable) 事务处理结束，其效果在数据库中持久化
 
 
2.事务并发处理可能引起的问题
 
 
 
脏读(dirty read)：一个事务读取了另一个事务尚未提交的数据，
 不可重复读(non-repeatable read) ：一个事务的操作导致另一个事务前后两次读取到不同的数据
 幻读(phantom read) ：一个事务的操作导致另一个事务前后两次查询的结果数据量不同。
 
 
3.事务并发处理可能引起的问题
 
 
 
脏读(dirty read)：一个事务读取了另一个事务尚未提交的数据，
 不可重复读(non-repeatable read) ：一个事务的操作导致另一个事务前后两次读取到不同的数据
 幻读(phantom read) ：一个事务的操作导致另一个事务前后两次查询的结果数据量不同。
 
 
4. 事务隔离级别(Transaction Isolation Levels)
 
JDBC提供了5种不同的事务隔离级别，在Connection中进行了定义。
 JDBC定义了五种事务隔离级别
 
ISOLATION_DEFAULT
这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.
ISOLATION_READ_UNCOMMITTED
允许脏读、不可重复读和幻读
ISOLATION_READ_COMMITTED
禁止脏读，但允许不可重复读和幻读
ISOLATION_REPEATABLE_READ
禁止脏读和不可重复读，但允许幻读
ISOLATION_SERIALIZABLE
禁止脏读、不可重复读和幻读
5.事务的传播行为
 
7种传播行为
 
 
 
PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
 PROPAGATION_SUPPORTS 支持当前事务，如果当前没有事务，就以非事务方式执行
 PROPAGATION_MANDATORY 支持当前事务，如果当前没有事务，就抛出异常。
 PROPAGATION_REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起
 PROPAGATION_NOT_SUPPORTED 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
 PROPAGATION_NEVER 以非事务方式执行，如果当前存在事务，则抛出异常
 
 
虽然有7种，但是常用的就第一种REQUIRED和第四种REQUIRES_NEW
 
6.保存点(SavePoint)
 
JDBC定义了SavePoint接口，提供在一个更细粒度的事务控制机制。当设置了一个保存点后，可以rollback到该保存点处的状态，而不是rollback整个事务。
 
Connection接口的setSavepoint和releaseSavepoint方法可以设置和释放保存点。
 JDBC规范虽然定义了事务的以上支持行为，但是各个JDBC驱动，数据库厂商对事务的支持程度可能各不相同。如果在程序中任意设置，可能得不到想要的效果。为此，JDBC提供了DatabaseMetaData接口，提供了一系列JDBC特性支持情况的获取方法。比如，通过DatabaseMetaData.supportsTransactionIsolationLevel方法可以判断对事务隔离级别的支持情况，通过DatabaseMetaData.supportsSavepoints方法可以判断对保存点的支持情况。
 参考 https://blog.csdn.net/weixin_40263776/article/details/79521595
 
事务的属性可同时通过注解方式或配置文件配置
 
注解方式：
 
@Transactional只能被应用到public方法上(aop方式实现的),对于其它非public的方法,如果标记@Transactional也不会报错,但方法没有事务功能.
 默认情况下,一个有事务方法, 遇到RuntimeException 时会回滚 . 遇到 受检查的异常 是不会回滚 的. 要想所有异常都回滚,要加上 @Transactional( rollbackFor={Exception.class,其它异常})
 
@Transactional(
    readOnly = false, //读写事务
    timeout = -1 ,     //事务的超时时间，-1为无限制
    noRollbackFor = ArithmeticException.class, //遇到指定的异常不回滚
    isolation = Isolation.DEFAULT, //事务的隔离级别，此处使用后端数据库的默认隔离级别
    propagation = Propagation.REQUIRED //事务的传播行为
)
 
配置文件( aop拦截器方式):
 
<tx:advice id="advice" transaction-manager="txManager">
          <tx:attributes>
            <!-- tx:method的属性:
                * name 是必须的,表示与事务属性关联的方法名(业务方法名),对切入点进行细化。通配符 
                     （*）可以用来指定一批关联到相同的事务属性的方法。
                      如：'get*'、'handle*'、'on*Event'等等.
                * propagation：不是必须的,默认值是REQUIRED表示事务传播行为,
                  包括REQUIRED,SUPPORTS,MANDATORY,REQUIRES_NEW,NOT_SUPPORTED,NEVER,NESTED
                * isolation：不是必须的 默认值DEFAULT ，表示事务隔离级别(数据库的隔离级别)
                * timeout：不是必须的 默认值-1(永不超时)，表示事务超时的时间（以秒为单位）
                * read-only：不是必须的 默认值false不是只读的表示事务是否只读？
                * rollback-for： 不是必须的表示将被触发进行回滚的 Exception(s)；以逗号分开。
                   如：'com.foo.MyBusinessException,ServletException'
                * no-rollback-for：不是必须的表示不被触发进行回滚的 Exception(s),以逗号分开。                                        
                   如：'com.foo.MyBusinessException,ServletException'   
                任何 RuntimeException 将触发事务回滚，但是任何 checked Exception 将不触发事务回滚                     
            -->
             <tx:method name="save*" propagation="REQUIRED" isolation="DEFAULT" read-only="false"/>
             <tx:method name="update*" propagation="REQUIRED" isolation="DEFAULT" read-only="false"/>
             <tx:method name="delete*" propagation="REQUIRED" isolation="DEFAULT" read-only="false"  rollback-for="Exception"/>
             <!-- 其他的方法之只读的 -->
             <tx:method name="*" read-only="true"/>
          </tx:attributes>
</tx:advice>
 
注意：
 aop方式的是无法拦截私有方法的，因为aop底层是代理，
 
 
 
jdk是代理接口，私有方法必然不会存在在接口里，所以就不会被拦截到；
 cglib是子类，private的方法照样不会出现在子类里，也不能被拦截
 
 
参考 https://www.cnblogs.com/protected/p/6652188.html
 
代码 https://github.com/baiyanlang2016/springboot-transaction

在工作中有一个在切面中需要记录一下操作日志的需求，而且要求这些操作日志要存入数据库，并且无论业务层有什么异常，日志照常记录，那就不能沿用业务层的事务，而是需要新启一个事务了。
 sping的声明式事务就是靠AOP来实现的，一般事务都在业务层中启用，那如果要在AOP的逻辑中启用一个新的事务要怎么做呢？比如下面的例子：
 
//定义一个切点，这里指com.lidehang.remote包下所有的类的方法
@Pointcut("execution(public * com.lidehang.remote..*.*(..))")
 public void remote(){}

//切点指定的方法执行完返回后调用
@AfterReturning(returning = "ret", pointcut = "remote()")
 public void doAfterReturning(JoinPoint joinPoint,Object ret) throws Throwable {
 	//一些切面逻辑，包含了数据库操作，为了即便业务层的原事务回滚也不会影响切面中的数据库操作，需要启用新的事务
...
 }
 
经过我的测试，通过在doAfterReturning方法上加上注解@Transactional，并指定传播行为是REQUIRES_NEW依然不行。因为@Transactional也是声明式事务，本身就是AOP实现的，在AOP的代码中使用不起作用。所以就只能使用spring的编程式事务了，需要引入TransactionTemplate。如下：
 
@Autowired
private TransactionTemplate transactionTemplate;

@AfterReturning(returning = "ret", pointcut = "remote()")
 public void doAfterReturning(JoinPoint joinPoint,Object ret) throws Throwable {
//声明式事务在切面中不起作用，需使用编程式事务
//设置传播行为：总是新启一个事务，如果存在原事务，就挂起原事务
transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
transactionTemplate.execute(new TransactionCallback<T>() {
@Override
		public T doInTransaction(TransactionStatus arg0) {
 			//一些切面逻辑，包含了数据库操作
...
}
});
 }
 
通过以上的步骤，切面里的逻辑会在新事务中执行，执行完就会提交，和业务层中的原事务无关，即便执行完切面逻辑后继续执行业务代码的过程中出现异常，业务层中的数据库操作因为有原事务而回滚，但切面中的数据库操作不会回滚，因为这是个新的事务！