春天JDBC事務管理

JDBC事務管理


春天提供編程式的事務管理（編程式事務管理）與聲明式的事務管理（聲明式事務management），爲不同的事務實現提供了一致的編程模型，這節以JDBC事務爲例，介紹Spring的事務管理。

5.3 。1   春天對事務的支持
事務是一組原子（Atomic）操作的工作單元，以數據庫存取的實例來說，就是一組SQL指令，這一組SQL指令必須全部執行成功，若因爲某個原因未全部執行成功（例如其中一行SQL有錯誤），則先前所有執行過的SQL指令都會被撤消。

舉個簡單的例子，一個客戶從A銀行轉賬至B銀行，要作的動作爲從A銀行的賬戶扣款、在B銀行的賬戶加上轉賬的金額，兩個動作必須成功，如果有一個動作失敗，則此次轉賬失敗。

事務還必須保持所參與資源的一致性（Consistent），例如在銀行賬戶的例子中，兩個賬戶的轉賬金額，B賬戶取款的金額不能大於A賬戶的存款金額。每個事務彼此之間必須是隔離的（Isolated），例如在A賬戶中可能有兩筆事務，同時進行存款與提款的動作，兩個事務基本上不需意識到彼此的存在。事務還必須是可持續的（Durable），在某一筆事務之後，這筆事務必須是被記錄下來的。

在這裏將介紹JDBC如何使用事務管理。首先來看看事務的原子性實現，在JDBC中，可以操作Connection的setAutoCommit()方法，給定false 參數，在下達一連串的SQL語句後，自行執行Connection的commit()來送出變更，如果中間發生錯誤，則執行rollback()來撤消所有的執行，例如：


在Spring中對JDBC的事務管理加以封裝，Spring事務管理的抽象關鍵在於org.springframework.transaction.PlatformTransactionManager接口的實現：

...

【JAVA]鑑於plaincopy
公共 接口 的PlatformTransactionManager {

    的TransactionStatus getTransaction（TransactionDefinition的

                    定義）   拋出 TransactionException;

    無效 提交（TransactionStatus對象的狀態）

                                   拋出 TransactionException;

    無效 回滾（TransactionStatus對象的狀態）

                                   拋出 TransactionException;

}

PlatformTransactionManager接口有許多具體的事務實現類，例如DataSourceTransactionManager、HibernateTransactionManager、JdoTransaction- Manager、JtaTransactionManager等，通過依賴於PlatformTransactionManager接口及各種的技術實現，Spring在事務管理上可以讓開發人員使用一致的編程模型，即使所使用的是不同的事務管理技術。

TransactionException是未選中Exception。事務的失敗通常都是致命的錯誤，Spring不強迫您一定要處理，而是讓您自行選擇是否要捕捉異常。

getTransaction（）級），傳播行爲（傳播

...

【JAVA]鑑於plaincopy
公共 接口 的TransactionStatus {

    布爾 isNewTransaction（）;

    無效 的setRollbackOnly（）;

    布爾 isRollbackOnly（）;

}

春天提供編程式的事務管理（編程式事務管理）與聲明式的事務管理（聲明式事務管理）：

升編程式的事務管理

編程式的事務管理可以清楚地控制事務的邊界，也就是讓您自行實現事務開始時間、撤消操作的時機、結束時間等，可以實現細粒度的事務控制。

升聲明式的事務管理

然而多數的情況下，事務並不需要細粒度的控制，而是採用聲明式的事務管理，好處是Spring事務管理的相關API可以不用介入程序之中，從對象的角度來看，它並不知道自己正被納入事務管理之中，在不需要事務管理的時候，只要在設置文件上修改一下設置，即可移去事務管理服務。

5.3 。2   JDBC編程事務管理
春天提供兩種方式實現編程式的事務管理，一是直接使用PlatformTransaction-經理實現，二是使用org.springframework.transaction.support.Transaction-模板。

先來看看如何使用PlatformTransactionManager，在這裏使用它的實現類DataSourceTransactionManager，可以改寫一下之前5.2 . 1 節中的JdbcTemplateDemo項目，讓它具有事務管理功能，修改一下UserDAO類的insert()方法來作示範：
ProgrammaticTransactionDemo UserDAO.java

【JAVA]鑑於plaincopy
包裝 onlyfun.caterpillar;

進口 java.util.Iterator的;

進口 的java.util.List;

進口 的java.util.Map;

進口 javax.sql.DataSource的;

進口 org.springframework.dao.DataAccessException;

進口 org.springframework.jdbc.core.JdbcTemplate;

進口 org.springframework.jdbc。

            datasource.DataSourceTransactionManager;

進口 org.springframework.transaction.TransactionDefinition;

進口 org.springframework.transaction.TransactionStatus;

進口 org.springframework.transaction。

            support.DefaultTransactionDefinition;

公共 類 的UserDAO  實現 IUserDAO
{

    私人 的DataSourceTransactionManager transactionManager的;

    私人 DefaultTransactionDefinition DEF;

    私人 的JdbcTemplate JdbcTemplate的;



    公共 無效 的setDataSource（數據源數據源）{

        的JdbcTemplate =  新 的JdbcTemplate（數據源）;

        transactionManager的=

            新 的DataSourceTransactionManager（數據源）;

        //建立事務的定義

        高清=  新 DefaultTransactionDefinition（）;

        def.setPropagationBehavior（

                TransactionDefinition.PROPAGATION_REQUIRED）;

    }



    公共 無效 插入（用戶用戶）{

       字符串名稱= user.getName（）;

       INT  年齡= user.getAge（）的intValue（）。



       TransactionStatus對象狀態=

           transactionManager.getTransaction（DEF）;

       嘗試 {

           jdbcTemplate.update（“INSERT INTO的用戶（姓名，年齡）”

                   +  “VALUES（'”  +名稱+  “'，”  +年齡+  “）” ）;

           //下面的SQL有錯誤，用以測試事務

           jdbcTemplate.update（“INSER INTO用戶（姓名，年齡）”

                   +  “VALUES（'”  +名稱+  “'，”  +年齡+  “）” ）;

       }

       抓（DataAccessException的E）{

           transactionManager.rollback（狀態）;

           扔 é;

       }

       transactionManager.commit（狀態）;

    }

    公衆 用戶發現（整數ID）{

        列表行= jdbcTemplate.queryForList（

          “SELECT * FROM WHERE用戶ID =”  + id.intValue（））;



        迭代它= rows.iterator（）;

        如果（it.hasNext（））{

            地圖中userMap =（圖）it.next（）;

            整數I =  新的 整數（

                    userMap.get（“ID” ）的ToString（））;

            字符串名稱= userMap.get（ “ 名” ）的ToString（）;

            整數年齡=  新的 整數（

                    userMap.get（ “ 時代” ）的ToString（））;

            用戶的用戶=  新 用戶（）;



            user.setId（ⅰ）;

            user.setName（名）;

            user.setAge（年齡）;



            返回 用戶;

        }

        返回 空值;

    }

}

在insert()方法中使用了DataSourceTransactionManager來進行事務管理，如果發生了異常，則catch 區塊中會進行事務的Rollback，在insert()方法中故意寫入錯誤的SQL（注意INSERT方法少寫了一個T），因此實際上數據並不會被儲存至數據庫中。

要使用MySQL數據庫進行事務處理，必須建立支持事務的表格類型，例如InnoDB的表格類型，這裏用來建立表格的SQL如下所示：

【JAVA]鑑於plaincopy
 CREATE TABLE的用戶（

    ID INT（11 ）NOT NULL AUTO_INCREMENT PRIMARY KEY，

    命名VARCHAR（100 ）NOT NULL  默認 ' ，

    年齡INT

）TYPE = InnoDB的;

另一個實現編程式事務管理的方法是使用TransactionTemplate，它需要一個TransactionManager實例，如下所示：

...

【JAVA]鑑於plaincopy
TransactionTemplate的TransactionTemplate的=

        新 TransactionTemplate的（transactionManager的）;

...

transactionTemplate.execute（新 TransactionCallback（）{

    公共 對象doInTransaction（TransactionStatus對象的狀態）{

         返回 jdbcTemplate.update（“INSERT INTO的用戶（姓名，年齡）”

               +  “VALUES（'”  +名稱+  “'，”  +年齡+  “）” ）;

    }

}）;

如果發生了異常，則會進行Rollback，否則提交事務，如果沒有回傳值，則也可以使用TransactionCallbackWithoutResult：

...

【JAVA]鑑於plaincopy
transactionTemplate.execute（

        新 TransactionCallbackWithoutResult（）{

                公共 無效 doInTransactionWithoutResult（

                                TransactionStatus對象的狀態）{

            。...

                }

            }）;

5.3 。3   JDBC聲明事務管理
Spring聲明式的事務管理依賴它的AOP框架來完成。使用聲明事務管理的好處是，事務管理不能侵入您所開發的組件，具體來說，DAO對象不會意識到正在事務管理之中，事實上也應當如此，因爲事務管理是屬於系統層面的服務，而不是業務邏輯的一部分，如果想要改變事務管理策略的話，也只需要在定義文件中重新配置。

舉個例子來說，可以將5.2 . 1 節中的JdbcTemplateDemo項目修改一下，在不修改UserDAO類的情況下，可以爲它加入事務管理的服務，一個簡單的方法是使用TransactionProxyFactoryBean，指定要介入的事務管理對象及其方法，這需要在定義文件中修改，如下所示：

DeclarativeTransactionDemo豆-config.xml中

【JAVA]鑑於plaincopy
<？XML版本= “1.0”  編碼= “UTF-8” ？>

<豆的xmlns = “http://www.springframework.org/schema/beans”

  XMLNS：XSI = “http://www.w3.org/2001/XMLSchema-instance”

  XSI：的schemaLocation =“HTTP：//www.springframework.org/schema/beans

  HTTP：//www.springframework.org/schema/beans/spring-beans-2.0.xsd“>



    <bean的ID = “數據源”

          類=“org.springframework.jdbc。

                   →datasource.DriverManagerDataSource“

          破壞法= “關閉” >

        <屬性名= “driverClassName”

                  值= “com.mysql.jdbc.Driver” />

        <屬性名= “URL”

                  值= “的jdbc：mysql的：//本地主機：3306 /演示” />

        <屬性名= “用戶名”  值= “毛毛蟲” />

        <屬性名= “密碼”  值= “123456” />

    </豆>



    <bean的ID = “transactionManager的”

          類=“org.springframework.jdbc。

                   →datasource.DataSourceTransactionManager“>

        <屬性名= “數據源”  參考= “數據源” />

    </豆>



    <bean的ID = “userDAO的”

          類= “onlyfun.caterpillar.UserDAO” >

        <屬性名= “數據源”  參考= “數據源” />

    </豆>



    <bean的ID = “userDAOProxy”

          類=“org.springframework.transaction。

                   →interceptor.TransactionProxyFactoryBean“>

        <屬性名= “proxyInterfaces” >

            <目錄>

                <值> onlyfun.caterpillar.IUserDAO </值>

            </表>

        </物業>

        <屬性名= “目標”  參考= “userDAO的” />

        <屬性名= “transactionManager的”

                  REF = “transactionManager的” />

        <屬性名= “transactionAttributes” >

            <道具>

                <支撐鍵= “插入*” > PROPAGATION_REQUIRED </道具>

            </道具>

        </物業>

    </豆>

</豆>

TransactionProxyFactoryBean需要一個TransactionManager，由於這裏使用的是JDBC，所以使用DataSourceTransactionManager，TransactionProxyFactoryBean是個代理對象，"target"  屬性指定要代理的對象，事務管理會自動介入指定的方法前後，這裏使用  "transactionAttributes"  屬性指定，"insert*"  表示指定方法名稱以insert開頭的都要納入事務管理，您也可以指定方法全名，如果在方法執行過程中發生錯誤，則所有先前的操作自動撤回，否則正常提交。

在"insert*"  等方法上指定了  "PROPAGATION_REQUIRED" ，表示在目前的事務中執行操作，如果事務不存在就建立一個新的，相關的常數意義都可以在API文件的TransactionDefinition接口中找到。您可以加上多個事務定義，中間使用逗號  ","  區隔，例如可以加上只讀，或者是指定某個異常發生時撤回操作：

PROPAGATION_REQUIRED，只讀，-MyCheckedException

MyCheckedException前面加上  "-"  時，表示發生指定異常時撤消操作，如果前面加上  "+" ，表示發生異常時立即提交。

由於"userDAO" 被"userDAOProxy" 代理了，所以要做的是取得"userDAOProxy" ，而不是"userDAO" ，例如：

DeclarativeTransactionDemo SpringDAODemo.java

【JAVA]鑑於plaincopy
包裝 onlyfun.caterpillar;

進口 org.springframework.context.ApplicationContext;

進口 org.springframework.context。

              support.ClassPathXmlApplicationContext;

公共 類 SpringDAODemo {

    公共 靜態 無效 的主要（字串[]
args）{

        ApplicationContext的背景下=

            新 的ClassPathXmlApplicationContext（

                    “豆-config.xml文件” ）;



        用戶的用戶=  新 用戶（）;



        user.setName（ “ 毛毛蟲” ）;

        user.setAge（新的 整數（30 ））;



        IUserDAO userDAO的=

            （IUserDAO）context.getBean（“userDAOProxy” ）;



        userDAO.insert（用戶）;



        用戶= userDAO.find（新 整型（1 ））;



        的System.out.println（ “ 名”  + user.getName（））;

    }

}

您也可以設置不同的TransactionInterceptor來得到更多的管理細節，例如：

【JAVA]鑑於plaincopy
<？XML版本= “1.0”  編碼= “UTF-8” ？>

<豆的xmlns = “http://www.springframework.org/schema/beans”

  XMLNS：XSI = “http://www.w3.org/2001/XMLSchema-instance”

  XSI：的schemaLocation =“HTTP：//www.springframework.org/schema/beans

  HTTP：//www.springframework.org/schema/beans/spring-beans-2.0.xsd“>



    <bean的ID = “數據源”

          類=“org.springframework.jdbc。

                   →datasource.DriverManagerDataSource“

          破壞法= “關閉” >

        <屬性名= “driverClassName”

                  值= “com.mysql.jdbc.Driver” />

        <屬性名= “URL”

                  值= “的jdbc：mysql的：//本地主機：3306 /演示” />

        <屬性名= “用戶名”  值= “毛毛蟲” />

        <屬性名= “密碼”  值= “123456” />

    </豆>

    <bean的ID = “transactionManager的”

          類=“org.springframework.jdbc。

                   →datasource.DataSourceTransactionManager“>

        <屬性名= “數據源”  參考= “數據源” />

    </豆>



    <bean的ID = “userDAO的”

          類= “onlyfun.caterpillar.UserDAO” >

        <屬性名= “數據源”  參考= “數據源” />

    </豆>

    <bean的ID = “transactionInterceptor”

          類=“org.springframework.transaction。

                   →interceptor.TransactionInterceptor“>

        <屬性名= “transactionManager的”  參考= “transactionManager的” />

        <屬性名= “transactionAttributeSource”

                  值=“onlyfun.caterpillar.UserDAO.insert * =

                            →PROPAGATION_REQUIRED“/>

    </豆>



    <bean的ID = “userDAOProxy”

          類=“org.springframework.aop。

                   →framework.ProxyFactoryBean“>

        <屬性名= “proxyInterfaces” >

            <目錄>

                <值> onlyfun.caterpillar.IUserDAO </值>

            </表>

        </物業>

        <屬性名= “目標”  參考= “userDAO的” />

        <屬性名= “interceptorNames” >

            <目錄>

                <值> transactionInterceptor </值>

            </表>

        </物業>

    </豆>

</豆>

即使後來不再需要事務管理，也可以直接在Bean定義文件中修改配置，而不用修改程序重新進行編譯等動作。

聲明事務管理是利用彈簧AOP來達成的，所以執行以上的程序時，請記得您的Classpath設置中必須包括spring-aop.jar。

5.3 。4   事務的屬性介紹
Spring使用AOP來完成聲明式的事務管理，因而聲明式事務是以方法爲邊界的，Spring的事務屬性（Transaction attribute）自然就在於描述事務應用至方法上的策略，在Spring中事務屬性分作以下的幾個參數：

升傳播行爲（傳播行爲）

傳播行爲定義了事務應用於方法上之邊界（Boundaries），它告知何時該開始一個新的事務，或何時事務該被暫停，或方法是否要在事務中進行。

Spring定義了幾個傳播行爲，可以在TransactionDefinition的API文件說明上找到相對應的常數與說明，以下列出幾個：

表5.1   事務傳播行爲說明

傳播行爲說明

PROPAGATION_MANDATORY方法必須在一個現存的事務中進行，否則丟出異常

PROPAGATION_NESTED在一個嵌入的事務中進行，如果不是，則同PROPAGATION_REQUIRED

PROPAGATION_NEVER指出不應在事務中進行，如果有就丟出異常

PROPAGATION_NOT_SUPPORTED指出不應在事務中進行，如果有就暫停現存的事務

PROPAGATION_REQUIRED支持現在的事務，如果沒有就建立一個新的事務

PROPAGATION_REQUIRES_NEW建立一個新的事務，如果現存一個事務就暫停它

PROPAGATION_SUPPORTS支持現在的事務，如果沒有就以非事務的方式執行


舉個例子來說，如果傳播行爲被聲明爲PROPAGATION_REQUIRED，則事務的邊界在開始第一個事務的方法呼叫及結束時，如果先前沒有事務被開始，則事務邊界即爲目前方法的執行前後。又如果傳播行爲被聲明爲PROPAGATION_REQUIRES_NEW，則事務的邊界即爲該方法執行的前後。

升隔離層級（隔離級別）

在一個應用程序中，可能有多個事務同時在進行，這些事務應當彼此之間互相不知道另一個事務的存在，好比現在整個應用程序就只有一個事務存在，由於事務彼此之間獨立，若讀取的是同一個數據的話，就容易發生問題，例如：

ñ髒讀

某個事務已更新一份數據，另一個事務在此時讀取了同一份數據，由於某些原因，前一個Roll回來了操作，則後一個事務所讀取的數據就會是不正確的。

n不重複讀

在一個事務的兩次查詢之中數據不一致，這可能是因爲兩次查詢過程中間插入了一個事務更新的原有的數據。

ñ幻影讀

在一個事務的兩次查詢中數據筆數不一致，例如有一個事務查詢了幾列（Row）數據，而另一個事務卻在此時插入了新的幾列數據，先前的事務在接下來的查詢中，就會發現有幾列數據是它先前所沒有的。

爲了避免以上問題的方法之一，需要在某個事務進行過程中鎖定正在更新或查詢的數據字段，直到目前的事務完成，然而完全鎖定字段時，若另一個事務來查詢同一份數據就必須等待，直到前一個事務完成並解除鎖定爲止，因而會造成應用程序在查詢或更新數據時效率上的問題，而事實上根據需求的不同，並不用在事務進行時完全地鎖定數據，隔離層級可以讓您根據實際的需求，對數據的鎖定進行設置。

Spring提供了幾種隔離層級設置，同類型的設置可以在TransactionDefinition的API文件說明上找到相對應的常數與說明，以下列出幾個：

表5.2   事務隔離層級說明

        隔離層級說明

ISOLATION_DEFAULT使用底層數據庫預設的隔離層級

ISOLATION_READ_COMMITTED允許事務讀取其他並行的事務已經送出（提交）的
                                 數據字段，可以防止髒讀問題

ISOLATION_READ_UNCOMMITTED允許事務讀取其他並行的事務還沒送出的數據，會發
                                 生骯髒的，不可重複，幻影讀取等問題


續表

          隔離層級說明

ISOLATION_REPEATABLE_READ要求多次讀取的數據必須相同，除非事務本身更新
                                   數據，可防止髒污，不可重複讀問題

ISOLATION_SERIALIZABLE完整的隔離層級，可防止髒污，Nonrepeatabl
                               E，幻影讀取等問題，會鎖定對應的數據表
                                    格，因而有效率問題


升只讀提示（只讀提示）

如果事務只進行讀取的動作，則可以利用底層數據庫在只讀操作時發生的一些最佳化動作，由於這個動作利用到數據庫在只讀的事務操作最佳化，因而必須在事務中才有效，也就是說要搭配傳播行爲PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED來設置。

升事務超時期間​​（交易超時時間）

有的事務操作可能延續很長一段的時間，事務本身可能關聯到數據表格的鎖定，因而長時間的事務操作會有效率上的問題，對於過長的事務操作，您要考慮Roll回事務並要求重新操作，而不是無限時的等待事務完成。

您可以設置事務超時期間，計時是從事務開始時，所以這個設置必須搭配傳播行爲PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED來設置。

5.3 。5   TransactionAttributeSource，TransactionAttribute
在TransactionProxyFactoryBean的上有setTransactionAttributeSource（）與setTransaction屬性（）方法，它們是用來設置事務屬性的策略實例。

org.springframework.transaction.interceptor.TransactionAttributeSource接口上有一個getTransactionAttribute()方法，您可以根據傳遞給它的Method實例與Class實例，決定該回傳一個什麼內容的org.springframework.transaction. interceptor.TransactionAttribute實例，一個最簡單的TransactionAttributeSource實現是org.springframework.transaction.interceptor.MatchAlwaysTransaction-
AttributeSource，對於每一個方法執行都會應用事務，它回傳的TransactionAttribute實例的默認傳播行爲是PROPAGATION_REQUIRED，隔離層級爲ISOLATION_DEFAULE。

一個應用的例子如下所示：

...

【JAVA]鑑於plaincopy
<bean的ID = “transactionAttributeSource”

      類=“org.springframework.transaction.interceptor。

            →的MatchAlwaysTransactionAttributeSource“/>

<bean的ID = “userDAOProxy”

      類=“org.springframework.transaction。

            →interceptor.TransactionProxyFactoryBean“>

    <屬性名= “proxyInterfaces” >

        <目錄>

            <值> onlyfun.caterpillar.IUserDAO </值>

        </表>

    </物業>

    <屬性名= “目標”  參考= “userDAO的” />

    <屬性名= “transactionManager的”  參考= “transactionManager的” />

    <屬性名= “transactionAttributeSource”

              REF = “transactionAttributeSource” />

</豆>
...

您可以使用org.springframework.transaction.interceptor.DefaultTransaction-屬性，並設置自己的事務策略，之後設置給TransactionAttributeSource，例如：

...

【JAVA]鑑於plaincopy
<bean的ID = “myTransactionAttribute”

      類=“org.springframework.transaction。

         →interceptor.DefaultTransactionAttribute“>

    <屬性名= “propagationBehaviorName”

              值= “PROPAGATION_REQUIRES_NEW” />

    <屬性名= “isolationLevelName”

              值= “ISOLATION_REPEATABLE_READ” />

</豆>

<bean的ID = “transactionAttributeSource”

      類=“org.springframework.transaction。

      →interceptor.MatchAlwaysTransactionAttributeSource“>

    <屬性名= “transactionAttribute”

              REF = “myTransactionAttribute” />

</豆>

<bean的ID = “userDAOProxy”

      類=“org.springframework.transaction。

            →interceptor.TransactionProxyFactoryBean“>

    <屬性名= “proxyInterfaces” >

        <目錄>

            <值> onlyfun.caterpillar.IUserDAO </值>

        </表>

    </物業>

    <屬性名= “目標”  參考= “userDAO的” />

    <屬性名= “transactionManager的”  參考= “transactionManager的” />

    <屬性名= “transactionAttributeSource”

              REF = “transactionAttributeSource” />

</豆>

...

可以使用org.springframework.transaction.interceptor.NameMatchTransaction- AttributeSource來指定某些方法要應用事務，以及要應用的事務策略，例如：

...

【JAVA]鑑於plaincopy
<bean的ID = “transactionAttributeSource”

      類=“org.springframework.transaction。

        →interceptor.NameMatchTransactionAttributeSource“>

    <屬性名= “屬性” >

        <道具>

            <支撐鍵= “插入*” > PROPAGATION_REQUIRES_NEW </道具>

        </道具>

    </物業>

</豆>

<bean的ID = “userDAOProxy”

      類=“org.springframework.transaction。

          →interceptor.TransactionProxyFactoryBean“>

    <屬性名= “proxyInterfaces” >

        <目錄>

            <值> onlyfun.caterpillar.IUserDAO </值>

        </表>

    </物業>

    <屬性名= “目標”  參考= “userDAO的” />

    <屬性名= “transactionManager的”  參考= “transactionManager的” />

    <屬性名= “transactionAttributeSource”

              REF = “transactionAttributeSource” />

</豆>

...

在NameMatchTransactionAttributeSource的  "properties" 屬性上，可以指定方法名稱與事務策略，方法名稱的指定可以指定全名，也可以使用Wildcard來指定，例如上面的指定中，只要方法名稱以insert爲開頭的都會應用相對應的事務策略。

在指定事務策略時，指定的格式如下：

傳播行爲，隔離層級，只讀，+異常 - 異常

除了傳播行爲一定要設置之外，其他都可選擇性的設置，中間以逗號區隔，例如：

PROPAGATION_REQUIRED，只讀，-MyCheckedException

MyCheckedException前面加上  "-"  時，表示發生指定異常時撤消操作，如果前面加上  "+" ，表示發生異常時立即提交。

在比較簡單的設置中，可以僅設置TransactionProxyFactoryBean，並在它的  "transactionAttributes"  屬性上直接設置要應用事務的方法及事務策略，例如：

...

【JAVA]鑑於plaincopy
<bean的ID = “userDAOProxy”

      類=“org.springframework.transaction。

          →interceptor.TransactionProxyFactoryBean“>

    <屬性名= “proxyInterfaces” >

        <目錄>

            <值> onlyfun.caterpillar.IUserDAO </值>

        </表>

    </物業>

    <屬性名= “目標”  參考= “userDAO的” />

    <屬性名= “transactionManager的”  參考= “transactionManager的” />

    <屬性名= “transactionAttributes” >

        <道具>

            <支撐鍵= “插入*” > PROPAGATION_REQUIRED </道具>

        </道具>

    </物業>

</豆>

...

甚至也可以直接指定TransactionInterceptor，以獲得更多的控制，例如：

...

【JAVA]鑑於plaincopy
<bean的ID = “transactionInterceptor”

      類=“org.springframework.transaction。

              →interceptor.TransactionInterceptor“>

    <屬性名= “transactionManager的” >

              REF = “transactionManager的” />

    <屬性名= “transactionAttributeSource”

     值= “onlyfun.caterpillar.UserDAO.insert * =→PROPAGATION_REQUIRED” />

</豆>

<bean的ID = “userDAOProxy”

      類=“org.springframework.aop。

          →framework.ProxyFactoryBean“>

    <屬性名= “proxyInterfaces” >

        <目錄>

            <值> onlyfun.caterpillar.IUserDAO </值>

        </表>

    </物業>

    <屬性名= “目標”  參考= “userDAO的” />

    <屬性名= “interceptorNames”  值= “transactionInterceptor” />

</豆>

...

選擇哪一種設置方式是需求的問題，您可以嘗試在DeclarativeTransactionDemo項目的Bean定義文件上設置以上所介紹的方式，基於篇幅的限制，以上僅列出部分的設置內容。

5.3 。6   春季  2.0 聲明式事務管理：基於XML Schmea
在Spring  2.0 中要設置聲明式事務管理，可以依賴於Spring  2.0 的<aop>與<tx>標籤，因而要記得加入相關的名稱空間聲明：

【JAVA]鑑於plaincopy
<？XML版本= “1.0”  編碼= “UTF-8” ？>

<豆的xmlns = “http://www.springframework.org/schema/beans”

  XMLNS：XSI = “http://www.w3.org/2001/XMLSchema-instance”

  的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-2.0.xsd

  HTTP：//www.springframework.org/schema/aop

  HTTP：//www.springframework.org/schema/aop/spring-aop-2.0.xsd

  HTTP：//www.springframework.org/schema/tx

  HTTP：//www.springframework.org/schema/tx/spring-tx-2.0.xsd“>

    ...

</豆>

事務是系統層面的服務，也就是一個Aspect，其實具體來說就是一個Advice，您可以使用<tx:advice>標籤來提供這個Advice，它需要設置一個TransactionManager，並在當中使用<tx:attributes>來設置事務相關屬性。

可以將先前的DeclarativeTransactionDemo項目改寫，修改其beans-config.xml爲使用<aop>與<tx>標籤的方式：

DeclarativeTransactionDemo2豆-config.xml中

【JAVA]鑑於plaincopy
<？XML版本= “1.0”  編碼= “UTF-8” ？>

<豆的xmlns = “http://www.springframework.org/schema/beans”

  XMLNS：XSI = “http://www.w3.org/2001/XMLSchema-instance”

  的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-2.0.xsd

  HTTP：//www.springframework.org/schema/aop

  HTTP：//www.springframework.org/schema/aop/spring-aop-2.0.xsd

  HTTP：//www.springframework.org/schema/tx

  HTTP：//www.springframework.org/schema/tx/spring-tx-2.0.xsd“>



    <bean的ID = “數據源”

          類=“org.springframework.jdbc。

                   →datasource.DriverManagerDataSource“

          破壞法= “關閉” >

        <屬性名= “driverClassName”

                  值= “com.mysql.jdbc.Driver” />

        <屬性名= “URL”

                  值= “的jdbc：mysql的：//本地主機：3306 /演示” />

        <屬性名= “用戶名”  值= “毛毛蟲” />

        <屬性名= “密碼”  值= “123456” />

    </豆>



    <bean的ID = “transactionManager的”

          類=“org.springframework.jdbc。

                   →datasource.DataSourceTransactionManager“>

        <屬性名= “數據源”  參考= “數據源” />

    </豆>



    <bean的ID = “userDAO的”

          類= “onlyfun.caterpillar.UserDAO” >

        <屬性名= “數據源”  參考= “數據源” />

    </豆>



    <TX：建議ID = “txAdvice”

               交易經理= “transactionManager的” >

        <TX：屬性>

            <TX：方法名= “插入*”  的傳播= “要求” />

            <TX：方法名= “發現*”  只讀= “真” />

        </ TX：屬性>

    </ TX：建議>



    <AOP：配置>

        <AOP：切入點ID = “userDAOPointcut”

      表達式= “執行（* onlyfun.caterpillar.IUserDAO。*（..））” />

        <AOP：顧問諮詢-REF = “txAdvice”

                     切入點-REF = “userDAOPointcut” />

    </ AOP：配置>

</豆>

注意到<tx:method>中的屬性設置，對於傳播行爲、隔離層級、只讀、超時、異常時撤回或提交，都有對應的"propagation" 、"isolation" 、"timeout" 、"read-only" 、"rollback-for" 、"no-rollback-for" 屬性可以設置，若不設置，"propagation" 屬性默認是"REQUIRE" ，"isolation" 屬性默認是"DEFAULT" 、"timeout" 屬性默認是"-1" （單位是秒）、"read-only" 屬性默認是"false" 。

與先前介紹春季  2.0 基於XML Schema的AOP設置相同，由於不再於設置文件中設置代理對象，所以直接取得"userDAO" 實例進行操作即可。

5.3 。7   春天  2.0 聲明式事務管理：基於註解
聲明式事務管理在Spring  2.0 中，也支持使用Annotation的標示方式，方法是使用@Transactional 來標示，例如可以將DeclarativeTransactionDemo項目的UserDAO改寫，在上頭直接標示@Transactional ，並設置相關屬性：

DeclarativeTransactionDemo3 UserDAO.java

【JAVA]鑑於plaincopy
包裝 onlyfun.caterpillar;

進口 java.util.Iterator的;

進口 的java.util.List;

進口 的java.util.Map;

進口 javax.sql.DataSource的;

進口 org.springframework.jdbc.core.JdbcTemplate;

進口 org.springframework.transaction.annotation.Propagation;

進口 org.springframework.transaction.annotation.Transactional;

公共 類 的UserDAO  實現 IUserDAO
{

    私人 的JdbcTemplate JdbcTemplate的;

    公共 無效 的setDataSource（數據源數據源）{

        的JdbcTemplate =  新 的JdbcTemplate（數據源）;

    }

    @Transactional （傳播= Propagation.REQUIRED）

    公共 無效 插入（用戶用戶）{

       字符串名稱= user.getName（）;

       INT  年齡= user.getAge（）的intValue（）。



       jdbcTemplate.update（“INSERT INTO的用戶（姓名，年齡）”

               +  “VALUES（'”  +名稱+  “'，”  +年齡+  “）” ）;

    }



    @Transactional （只讀= 真）

    公衆 用戶發現（整數ID）{

        列表行= jdbcTemplate.queryForList（

          “SELECT * FROM WHERE用戶ID =”  + id.intValue（））;



        迭代它= rows.iterator（）;

        如果（it.hasNext（））{

            地圖中userMap =（圖）it.next（）;

            整數I =  新的 整數（userMap.get（“ID” ）的ToString（））;

            字符串名稱= userMap.get（ “ 名” ）的ToString（）;

            整數年齡=

                  新的 整數（userMap.get（ “ 時代” ）的ToString（））;

            用戶的用戶=  新 用戶（）;

            user.setId（ⅰ）;

            user.setName（名）;

            user.setAge（年齡）;



            返回 用戶;

        }

        返回 空值;

    }

}

在使用@Transactional 時，相關的屬性設置爲"propagation" 、"isolation" 、"readOnly" 、"timeout" 、"rollbackFor" 、"noRollbackFor" 等，而在beans-config.xml中，則要使用<tx:annotation-driven>標籤，並指定TransactionManager，例如：

DeclarativeTransactionDemo3豆-config.xml中

【JAVA]鑑於plaincopy
<？XML版本= “1.0”  編碼= “UTF-8” ？>

<豆的xmlns = “http://www.springframework.org/schema/beans”

  XMLNS：XSI = “http://www.w3.org/2001/XMLSchema-instance”

  的xmlns：TX = “http://www.springframework.org/schema/tx”

  XSI：的schemaLocation =“HTTP：//www.springframework.org/schema/beans

  HTTP：//www.springframework.org/schema/beans/spring-beans-2.0.xsd

  HTTP：//www.springframework.org/schema/tx

  HTTP：//www.springframework.org/schema/tx/spring-tx-2.0.xsd“>



    <bean的ID = “數據源”

          類=“org.springframework.jdbc。

                   →datasource.DriverManagerDataSource“

          破壞法= “關閉” >

        <屬性名= “driverClassName”

                  值= “com.mysql.jdbc.Driver” />

        <屬性名= “URL”

                  值= “的jdbc：mysql的：//本地主機：3306 /演示” />

        <屬性名= “用戶名”  值= “毛毛蟲” />

        <屬性名= “密碼”  值= “123456” />

    </豆>



    <bean的ID = “transactionManager的”

          類=“org.springframework.jdbc。

                   →datasource.DataSourceTransactionManager“>

        <屬性名= “數據源”  參考= “數據源” />

    </豆>



    <bean的ID = “userDAO的”

          類= “onlyfun.caterpillar.UserDAO” >

        <屬性名= “數據源”  參考= “數據源” />

    </豆>



    <TX：註解驅動的事務管理器= “transactionManager的” />

</豆>

同樣的，由於不再於設置文件中設置代理對象，所以直接取得"userDAO" 實例進行操作即可。