Spring4筆記9--Spring的事務管理（AOP應用的例子）

Spring的事務管理：

　　事務原本是數據庫中的概念，在 Dao 層。但一般情況下，需要將事務提升到業務層，即 Service 層。這樣做是為了能夠使用事務的特性來管理具體的業務。  
　　在 Spring 中通常可以通過以下三種方式來實現對事務的管理：
　 　　（1）使用 Spring 的事務代理工廠管理事務
　　　 （2）使用 Spring 的事務注解管理事務
　　　 （3）使用 AspectJ 的 AOP 配置管理事務

　　Spring事務管理API：

　　　　Spring 的事務管理，主要用到兩個事務相關的接口。

　　　　（1）事務管理器接口
  　　　 　　事務管理器是 PlatformTransactionManager 接口對象。其主要用於完成事務的提交、回滾，及獲取事務的狀態信息。查看 SpringAPI 幫助文檔：Spring 框架解壓目錄下的docs/javadoc-api/index.html。

Modifier and Type	Method and Description
void	commit(TransactionStatus status) Commit the given transaction, with regard to its status.
TransactionStatus	getTransaction(TransactionDefinition definition) Return a currently active transaction or create a new one, according to the specified propagation behavior.
void	rollback(TransactionStatus status) Perform a rollback of the given transaction.

　　　　　　A、常用的兩個實現類
　　　　　　　　PlatformTransactionManager 接口有兩個常用的實現類：  
　　　　　　　　　　DataSourceTransactionManager：使用 JDBC 或 iBatis  進行持久化數據時使用。  
　　　　　　　　　　HibernateTransactionManager：使用 Hibernate 進行持久化數據時使用。
　　　　　　B、Spring 的回滾方式
　　　　　　　　Spring 事務的默認回滾方式是：發生運行時異常時回滾，發生受查異常時提交。不過，對於受查異常，程序員也可以手工設置其回滾方式。

　　　　（2）事務定義接口：
　　　　　　事務定義接口 TransactionDefinition 中定義了事務描述相關的三類常量：事務隔離級別、事務傳播行為、事務默認超時時限，及對它們的操作。

　　　　　　A、定義了五個事務隔離級別常量：
　　　　　　　　這些常量均是以 ISOLATION_開頭。即形如 ISOLATION_XXX。
　　　　　　　　　　DEFAULT：采用DB默認的事務隔離級別。MySql的默認為REPEATABLE_READ；  Oracle默認為 READ_COMMITTED。
　　　　　　　　　　READ_UNCOMMITTED：讀未提交。未解決任何並發問題。
　　　　　　　　　　READ_COMMITTED：讀已提交。解決臟讀，存在不可重復讀與幻讀。  
　　　　　　　　　　REPEATABLE_READ：可重復讀。解決臟讀、不可重復讀，存在幻讀  
　　　　　　　　　　SERIALIZABLE：串行化。不存在並發問題。

　　　　　　B、定義了七個事務傳播行為常量
　　　　　　　　所謂事務傳播行為是指，處於不同事務中的方法在相互調用時，執行期間事務的維護情況。如，A 事務中的方法 doSome()調用 B 事務中的方法 doOther()，在調用執行期間事務的維護情況，就稱為事務傳播行為。事務傳播行為是加在方法上的。  
事務傳播行為常量都是以 PROPAGATION_  開頭，形如 PROPAGATION_XXX。  
　　　　　　　　　　REQUIRED：指定的方法必須在事務內執行。若當前存在事務，就加入到當前事務中；若當前沒有事務，則創建一個新事務。這種傳播行為是最常見的選擇，也是Spring 默認的事務傳播行為。  
　　　　　　　　　　如該傳播行為加在 doOther()方法上。若 doSome()方法在執行時就是在事務內的，則 doOther()方法的執行也加入到該事務內執行。若 doSome()方法沒有在事務內執行，則 doOther()方法會創建一個事務，並在其中執行。

　　　　　　　　　　SUPPORTS：指定的方法支持當前事務，但若當前沒有事務，也可以以非事務方式執行。 

　　　　　　　　　　MANDATORY：指定的方法必須在當前事務內執行，若當前沒有事務，則直接拋出異常。

　　　　　　　　　　REQUIRES_NEW：總是新建一個事務，若當前存在事務，就將當前事務掛起，直到新事務執行完畢。

　　　　　　　　　　NOT_SUPPORTED：指定的方法不能在事務環境中執行，若當前存在事務，就將當前事務掛起。

　　　　　　　　　　NEVER：指定的方法不能在事務環境下執行，若當前存在事務，就直接拋出異常。

　　　　　　　　　　NESTED：指定的方法必須在事務內執行。若當前存在事務，則在嵌套事務內執行；若當前沒有事務，則創建一個新事務。

　　　　　　C、定義了默認事務超時時限
　　　　　　　　常量 TIMEOUT_DEFAULT 定義了事務底層默認的超時時限，及不支持事務超時時限設置的 none 值。
　　　　　　　　注意，事務的超時時限起作用的條件比較多，且超時的時間計算點較復雜。所以，該值一般就使用默認值即可。

 

　　Spring事務代碼詳解：

　　　　要求：實現模擬購買股票。存在兩個實體：銀行賬戶 Account 與股票賬戶 Stock。當要購買股票時，需要從 Account 中扣除相應金額的存款，然后在 Stock 中增加相應的股票數量。而在這個過程中，可能會拋出一個用戶自定義的異常。異常的拋出，將會使兩個操作回滾。

　　　　Step1：創建數據庫表 account、stock
　　　　Step2：創建實體類 Account 與 Stock （略）
　　　　Step3：定義 Dao 接口  IAccountDao 與 IStockDao

package com.tongji.dao;

public interface IAccountDao {

    void insertAccount(String aname, double money);

    void updateAccount(String aname, double money, boolean isBuy);

}

package com.tongji.dao;

public interface IStockDao {

    void insertStock(String sname, int amount);

    void updateStock(String sname, int amount, boolean isBuy);

}

　　　　Step4：定義 Dao 實現類 AccountDaoImpl 與 StockDaoImpl

package com.tongji.dao;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {

    @Override
    public void insertAccount(String aname, double money) {
        String sql = "insert into account(aname, balance) values(?,?)";
        this.getJdbcTemplate().update(sql, aname, money);
    }

    @Override
    public void updateAccount(String aname, double money, boolean isBuy) {
        String sql = "update account set balance=balance+? where aname=?";
        if (isBuy) {
            sql = "update account set balance=balance-? where aname=?";
        }
        this.getJdbcTemplate().update(sql, money, aname);
        
    }

}

package com.tongji.dao;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class StockDaoImpl extends JdbcDaoSupport implements IStockDao {

    @Override
    public void insertStock(String sname, int amount) {
        String sql = "insert into stock(sname, count) values (?,?)";
        this.getJdbcTemplate().update(sql , sname, amount);
    }

    @Override
    public void updateStock(String sname, int amount, boolean isBuy) {
        //isBuy為true,則表示購買股票,此時應增加股票賬戶中的股票數量
        String sql = "update stock set count=count-? where sname=?";
        if (isBuy) {
            sql = "update stock set count=count+? where sname=?";
        }
        this.getJdbcTemplate().update(sql, amount, sname);
    }

}

　　　　Step5：定義異常類 StockException

package com.tongji.beans;

public class StockException extends Exception {
    private static final long serialVersionUID = 5377570098437361228L;

    public StockException() {
        super();
    }

    public StockException(String message) {
        super(message);
    }
    
}

　　　　Step6：定義 Service 接口 IStockProcessService

package com.tongji.service;

public interface IStockProcessService {
    void openAccount(String aname, double money);
    void openStock(String sname, int amount);
    void buyStock(String aname, double money, String sname, int amount);
}

　　　　Step7：定義 service 的實現類 StockProcessServiceImpl

package com.tongji.service;

import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.tongji.beans.StockException;
import com.tongji.dao.IAccountDao;
import com.tongji.dao.IStockDao;

public class StockProcessServiceImpl implements IStockProcessService{
     private IAccountDao accountDao;
     private IStockDao stockDao;
    
    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public void setStockDao(IStockDao stockDao) {
        this.stockDao = stockDao;
    }

    @Override
    public void openAccount(String aname, double money) {
        accountDao.insertAccount(aname, money);
    }

    @Override
    public void openStock(String sname, int amount) {
        stockDao.insertStock(sname, amount);
    }

    @Override
    public void buyStock(String aname, double money, String sname, int amount) throws StockException {
        boolean isBuy = true;
        accountDao.updateAccount(aname, money, isBuy);
        //故意拋出異常
        if (true) {
            throw new StockException("購買股票異常");
        }
        stockDao.updateStock(sname, amount, isBuy);
    }

}

　　　　Step8：定義Spring 配置文件　

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!-- 注冊數據源：C3P0數據源 -->
    <bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClass}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.user}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    
    <!-- 注冊JDBC屬性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    
    <!-- 注冊Dao -->
    <bean id="accountDao" class="com.tongji.dao.AccountDaoImpl">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <bean id="stockDao" class="com.tongji.dao.StockDaoImpl">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <!-- 注冊Service -->
    <bean id="stockService" class="com.tongji.service.StockProcessServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <property name="stockDao" ref="stockDao"/>
    </bean>    
</beans>

　　　　Step9：測試類

package com.tongji.test;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.tongji.service.IStockProcessService;

public class MyTest {
    
    private IStockProcessService service;

    @Before
    public void before() {
        //創建容器
        @SuppressWarnings("resource")
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        service = (IStockProcessService) ac.getBean("stockService");
    }
    
    @Test
    public void testOpen() {
        service.openAccount("張三", 10000);
        service.openStock("華為", 5);
    }
    
    @Test
    public void testBuyStock() {
        service.buyStock("張三", 2000, "華為", 5);
    }
    
}

　　　　此配置文件沒有采用事務管理，所以購買股票的時候，出現了數據庫中賬戶金額減少了，但是股票數目沒有增加的不一致情況。

　　

　　使用 Spring 的事務代理工廠管理事務：

　　　　該方式是，需要為目標類，即 Service 的實現類創建事務代理。事務代理使用的類是TransactionProxyFactoryBean，該類需要初始化如下一些屬性：
　　　　　　（1）transactionManager：事務管理器
　　　　　　（2）target：目標對象，即 Service 實現類對象
　　　　　　（3）transactionAttributes：事務屬性設置
  　　　　對於 XML 配置代理方式實現事務管理時，受查異常的回滾方式，程序員可以通過以下方式進行設置：通過“-異常”方式，可使發生指定的異常時事務回滾；通過“+異常”方式，可使發生指定的異常時事務提交。

　　　　修改Spring配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!-- 注冊數據源：C3P0數據源 -->
    <bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClass}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.user}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    
    <!-- 注冊JDBC屬性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    
    <!-- 注冊Dao -->
    <bean id="accountDao" class="com.tongji.dao.AccountDaoImpl">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <bean id="stockDao" class="com.tongji.dao.StockDaoImpl">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <!-- 注冊Service -->
    <bean id="stockService" class="com.tongji.service.StockProcessServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <property name="stockDao" ref="stockDao"/>
    </bean>    
    
    <!-- 事務 -->
    <!-- 注冊事務管理器 -->
    <bean id="myTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <!-- 生成事務代理 -->
    <bean id="stockServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="transactionManager" ref="myTxManager"/>
        <property name="target" ref="stockService"/>
        <property name="transactionAttributes">
            <props>
                <prop key="open*">ISOLATION_DEFAULT,PROPAGATION_REQUIRED</prop>
                <prop key="buyStock">ISOLATION_DEFAULT,PROPAGATION_REQUIRED,-StockException</prop>
            </props>
        </property>
    </bean>
</beans>

　　　　由於本項目使用的是 JDBC 進行持久化，所以使用 DataSourceTransactionManager 類作為事務管理器。

　　　　修改測試類：

　　　　 public void before() {
        　　　//創建容器
        　　　@SuppressWarnings("resource")
        　　　ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        　　　service = (IStockProcessService) ac.getBean("stockServiceProxy");
    　　　}

 

　　使用 Spring 的事務注解管理事務：
　　　　通過@Transactional 注解方式，也可將事務織入到相應方法中。而使用注解方式，只需在配置文件中加入一個 tx 標簽，以告訴 spring 使用注解來完成事務的織入。該標簽只需指定一個屬性，事務管理器。

　　　　修改Spring配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx" 
        xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!-- 注冊數據源：C3P0數據源 -->
    <bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClass}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.user}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    
    <!-- 注冊JDBC屬性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    
    <!-- 注冊Dao -->
    <bean id="accountDao" class="com.tongji.dao.AccountDaoImpl">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <bean id="stockDao" class="com.tongji.dao.StockDaoImpl">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <!-- 注冊Service -->
    <bean id="stockService" class="com.tongji.service.StockProcessServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <property name="stockDao" ref="stockDao"/>
    </bean>    
    
    <!-- 事務 -->
    <!-- 注冊事務管理器 -->
    <bean id="myTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <!-- 開啟注解驅動 -->
    <tx:annotation-driven transaction-manager="myTxManager"/>
</beans>

　　　　修改 service 的實現類 StockProcessServiceImpl：

package com.tongji.service;

import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.tongji.beans.StockException;
import com.tongji.dao.IAccountDao;
import com.tongji.dao.IStockDao;

public class StockProcessServiceImpl implements IStockProcessService{
     private IAccountDao accountDao;
     private IStockDao stockDao;
    
    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public void setStockDao(IStockDao stockDao) {
        this.stockDao = stockDao;
    }

    @Override
    @Transactional(isolation=Isolation.DEFAULT, propagation=Propagation.REQUIRED)
    public void openAccount(String aname, double money) {
        accountDao.insertAccount(aname, money);
    }

    @Override
    @Transactional(isolation=Isolation.DEFAULT, propagation=Propagation.REQUIRED)
    public void openStock(String sname, int amount) {
        stockDao.insertStock(sname, amount);
    }

    @Override
    @Transactional(isolation=Isolation.DEFAULT, propagation=Propagation.REQUIRED, rollbackFor=StockException.class)
    public void buyStock(String aname, double money, String sname, int amount) throws StockException {
        boolean isBuy = true;
        accountDao.updateAccount(aname, money, isBuy);
        if (true) {
            throw new StockException("購買股票異常");
        }
        stockDao.updateStock(sname, amount, isBuy);
    }

}

　　　　@Transactional 的所有可選屬性如下所示：
　　　　　　propagation：用於設置事務傳播屬性。該屬性類型為 Propagation 枚舉，默認值為Propagation.REQUIRED。
　　　　　　isolation：用於設置事務的隔離級別。該屬性類型為 Isolation 枚舉，默認值為Isolation.DEFAULT。
　　　　　　readOnly：用於設置該方法對數據庫的操作是否是只讀的。該屬性為 boolean，默認值為 false。
　　　　　　timeout：用於設置本操作與數據庫連接的超時時限。單位為秒，類型為 int，默認值為-1，即沒有時限。
　　　　　　rollbackFor：指定需要回滾的異常類。類型為 Class[]，默認值為空數組。當然，若只有一個異常類時，可以不使用數組。
　　　　　　rollbackForClassName：指定需要回滾的異常類類名。類型為 String[]，默認值為空數組。當然，若只有一個異常類時，可以不使用數組。
　　　　　　noRollbackFor：指定不需要回滾的異常類。類型為 Class[]，默認值為空數組。當然，若只有一個異常類時，可以不使用數組。
　　　　　　noRollbackForClassName：指定不需要回滾的異常類類名。類型為 String[]，默認值為空數組。當然，若只有一個異常類時，可以不使用數組。
  　　　需要注意的是，@Transactional 若用在方法上，只能用於 public 方法上。對於其他非public 方法，如果加上了注解@Transactional，雖然 Spring 不會報錯，但不會將指定事務織入到該方法中。因為 Spring 會忽略掉所有非 public 方法上的@Transaction 注解。  
　　　　若@Transaction 注解在類上，則表示該類上所有的方法均將在執行時織入事務。

　　使用 AspectJ 的 AOP 配置管理事務（重點）:

　　　　使用 XML 配置事務代理的方式的不足是，每個目標類都需要配置事務代理。當目標類較多，配置文件會變得非常臃腫。使用 XML 配置顧問方式可以自動為每個符合切入點表達式的類生成事務代理。

　　　　修改Spring配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx" 
        xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!-- 注冊數據源：C3P0數據源 -->
    <bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClass}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.user}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    
    <!-- 注冊JDBC屬性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    
    <!-- 注冊Dao -->
    <bean id="accountDao" class="com.tongji.dao.AccountDaoImpl">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <bean id="stockDao" class="com.tongji.dao.StockDaoImpl">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <!-- 注冊Service -->
    <bean id="stockService" class="com.tongji.service.StockProcessServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <property name="stockDao" ref="stockDao"/>
    </bean>    
    
    <!-- 事務 -->
    <!-- 注冊事務管理器 -->
    <bean id="myTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <!-- 注冊事務通知 -->
    <tx:advice id="txAdvice" transaction-manager="myTxManager">
        <tx:attributes>
            <!-- 指定在連接點方法上應用的事務屬性 -->
            <tx:method name="open*" isolation="DEFAULT" propagation="REQUIRED"/>
            <tx:method name="buyStock" isolation="DEFAULT" propagation="REQUIRED" rollback-for="StockException"/>
        </tx:attributes>
    </tx:advice>
    
    <!-- AOP配置 -->
    <aop:config>
        <!-- 指定切入點 -->
        <aop:pointcut expression="execution(* *..service.*.*(..))" id="stockPointCut"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="stockPointCut"/>
    </aop:config>
</beans>

　　總結：Spring 的事務管理，是 AOP 的應用，將事務作為切面織入到了 Service 層的業務方法中。