Spring事務管理入門與進階

事務管理

一個數據庫事務是一個單一的工作單元操作序列。這些操作應該要么完整地執行，要么完全不執行。事務管理是一個重要組成部分，事務管理可以確保數據完整性和一致性。事務具有以下四個關鍵特性分別是 ACID：

• 原子性：事務應該當作一個單獨單元的操作，這意味着整個序列操作要么是成功，要么是失敗的。

• 一致性：這表示數據庫的引用完整性的一致性，表中唯一的主鍵等。

• 隔離性：可能同時處理很多有相同的數據集的事務，每個事務應該與其他事務隔離，以防止數據損壞。

• 持久性：一個事務一旦完成全部操作后，這個事務的結果必須是永久性的，不能因系統故障而從數據庫中刪除。

一個真正的關系型數據庫管理系統應該為每個事務保證所有的四個特性。使用 SQL 發布到數據庫中的事務的簡單視圖如下：

• 使用 begin transaction 命令開始事務。

• 使用 SQL 查詢語句執行各種刪除、更新或插入操作。

• 如果所有的操作都成功，則執行提交操作，否則回滾所有操作。

Spring 支持編程式和聲明式事務管理。EJB 需要一個應用程序服務器，但 Spring 事務管理可以在不需要應用程序服務器的情況下實現。

 

編程式 vs. 聲明式

Spring 支持兩種類型的事務管理:

• 編程式事務管理 ：這意味着你在編程的幫助下有管理事務。這給了你極大的靈活性，但卻很難維護。

• 聲明式事務管理 ：這意味着你從業務代碼中分離事務管理。你僅僅使用注解或 XML 配置來管理事務。

聲明式事務管理比編程式事務管理更可取，盡管它不如編程式事務管理靈活，但它允許你通過代碼控制事務。但作為一種橫切關注點，聲明式事務管理可以使用 AOP 方法進行模塊化。Spring 支持使用 Spring AOP 框架的聲明式事務管理。

 

Spring 事務抽象

Spring 事務抽象的關鍵是由 org.springframework.transaction.PlatformTransactionManager 接口定義，如下所示：

public interface PlatformTransactionManager {
   TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
   void commit(TransactionStatus status) throws TransactionException;
   void rollback(TransactionStatus status) throws TransactionException;
}

TransactionStatus getTransaction(TransactionDefinition definition)：根據指定的傳播行為，該方法返回當前活動事務或創建一個新的事務。

void commit(TransactionStatus status)：該方法提交給定的事務和關於它的狀態。

void rollback(TransactionStatus status)：該方法執行一個給定事務的回滾。

 

TransactionDefinition 是在 Spring 中事務支持的核心接口，它的定義如下：

public interface TransactionDefinition {
   int getPropagationBehavior();
   int getIsolationLevel();
   String getName();
   int getTimeout();
   boolean isReadOnly();
}

int getPropagationBehavior()：該方法返回傳播行為。Spring 提供了與 EJB CMT 類似的所有的事務傳播選項。

int getIsolationLevel()：該方法返回該事務獨立於其他事務的工作的程度。

String getName()：該方法返回該事務的名稱。

int getTimeout()：該方法返回以秒為單位的時間間隔，事務必須在該時間間隔內完成。

boolean isReadOnly()：該方法返回該事務是否是只讀的。

下面是隔離級別的可能值:

TransactionDefinition.ISOLATION_DEFAULT：這是默認的隔離級別。

TransactionDefinition.ISOLATION_READ_COMMITTED：表明能夠阻止誤讀；可以發生不可重復讀和虛讀。

TransactionDefinition.ISOLATION_READ_UNCOMMITTED：表明可以發生誤讀、不可重復讀和虛讀。

TransactionDefinition.ISOLATION_REPEATABLE_READ：表明能夠阻止誤讀和不可重復讀；可以發生虛讀。

TransactionDefinition.ISOLATION_SERIALIZABLE：表明能夠阻止誤讀、不可重復讀和虛讀。

下面是傳播類型的可能值:

TransactionDefinition.PROPAGATION_MANDATORY：支持當前事務；如果不存在當前事務，則拋出一個異常。

TransactionDefinition.PROPAGATION_NESTED：如果存在當前事務，則在一個嵌套的事務中執行。

TransactionDefinition.PROPAGATION_NEVER：不支持當前事務；如果存在當前事務，則拋出一個異常。

TransactionDefinition.PROPAGATION_NOT_SUPPORTED：不支持當前事務；而總是執行非事務性。

TransactionDefinition.PROPAGATION_REQUIRED：支持當前事務；如果不存在事務，則創建一個新的事務。

TransactionDefinition.PROPAGATION_REQUIRES_NEW：創建一個新事務，如果存在一個事務，則把當前事務掛起。

TransactionDefinition.PROPAGATION_SUPPORTS：支持當前事務；如果不存在，則執行非事務性。

TransactionDefinition.TIMEOUT_DEFAULT：使用默認超時的底層事務系統，或者如果不支持超時則沒有。

 

TransactionStatus 接口為事務代碼提供了一個簡單的方法來控制事務的執行和查詢事務狀態。

public interface TransactionStatus extends SavepointManager {
   boolean isNewTransaction();
   boolean hasSavepoint();
   void setRollbackOnly();
   boolean isRollbackOnly();
   boolean isCompleted();
}

boolean hasSavepoint()：該方法返回該事務內部是否有一個保存點，也就是說，基於一個保存點已經創建了嵌套事務。

boolean isCompleted()：該方法返回該事務是否完成，也就是說，它是否已經提交或回滾。

boolean isNewTransaction()：在當前事務是新的情況下，該方法返回 true。

boolean isRollbackOnly()：該方法返回該事務是否已標記為 rollback-only。

void setRollbackOnly()：該方法設置該事務為 rollback-only 標記。

 

Spring 編程式事務管理

編程式事務管理方法允許你在對你的源代碼編程的幫助下管理事務。這給了你極大地靈活性，但是它很難維護。

在我們開始之前，至少要有兩個數據庫表，在事務的幫助下我們可以執行多種 CRUD 操作。以 Student 表為例，用下述 DDL 可以在 MySQL TEST 數據庫中創建該表：

CREATE TABLE Student(
   ID   INT NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(20) NOT NULL,
   AGE  INT NOT NULL,
   PRIMARY KEY (ID)
);

第二個表是 Marks，用來存儲基於年份的學生的標記。這里 SID 是 Student 表的外鍵。

CREATE TABLE Marks(
   SID INT NOT NULL,
   MARKS  INT NOT NULL,
   YEAR   INT NOT NULL
);

讓我們直接使用 PlatformTransactionManager 來實現編程式方法從而實現事務。要開始一個新事務，你需要有一個帶有適當的 transaction 屬性的 TransactionDefinition 的實例。這個例子中，我們使用默認的 transaction 屬性簡單的創建了 DefaultTransactionDefinition 的一個實例。

當 TransactionDefinition 創建后，你可以通過調用 getTransaction() 方法來開始你的事務，該方法會返回 TransactionStatus 的一個實例。 TransactionStatus 對象幫助追蹤當前的事務狀態，並且最終，如果一切運行順利，你可以使用 PlatformTransactionManager 的 commit() 方法來提交這個事務，否則的話，你可以使用 rollback() 方法來回滾整個操作。

現在讓我們編寫我們的 Spring JDBC 應用程序，它能夠在 Student 和 Mark 表中實現簡單的操作。讓我們適當的使用 Eclipse IDE，並按照如下所示的步驟來創建一個 Spring 應用程序：

步驟一：創建一個名為 SpringExample 的項目，並在創建的項目中的 src 文件夾下創建包com.tutorialspoint。

步驟二：使用 Add JARs 選項添加必需的 Spring 庫。

步驟三：在項目中添加 Spring JDBC 指定的最新的庫 mysql-connector-java.jar，org.springframework.jdbc.jar 和 org.springframework.transaction.jar。如果沒有這些庫，你可以下載它們。

步驟四：創建 DAO 接口 StudentDAO 並列出所有需要的方法。盡管它不是必需的並且你可以直接編寫 StudentJDBCTemplate 類，但是作為一個好的實踐，我們還是做吧。

步驟五：在com.tutorialspoint包下創建其他必需的 Java 類 StudentMarks，StudentMarksMapper，StudentJDBCTemplate 和 MainApp。如果需要的話，你可以創建其他的 POJO 類。

步驟六：確保你已經在 TEST 數據庫中創建了 Student 和 Marks 表。還要確保你的 MySQL 服務器運行正常並且你使用給出的用戶名和密碼可以讀/寫訪問數據庫。

步驟七：在 src 文件夾下創建 Beans 配置文件 Beans.xml 。

最后一步：最后一步是創建所有 Java 文件和 Bean 配置文件的內容並按照如下所示的方法運行應用程序。

下面是數據訪問對象接口文件 StudentDAO.java 的內容：

package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
   /** 
    * This is the method to be used to initialize
    * database resources ie. connection.
    */
   public void setDataSource(DataSource ds);
   /** 
    * This is the method to be used to create
    * a record in the Student and Marks tables.
    */
   public void create(String name, Integer age, Integer marks, Integer year);
   /** 
    * This is the method to be used to list down
    * all the records from the Student and Marks tables.
    */
   public List<StudentMarks> listStudents();
}

下面是 StudentMarks.java 文件的內容：

package com.tutorialspoint;
public class StudentMarks {
   private Integer age;
   private String name;
   private Integer id;
   private Integer marks;
   private Integer year;
   private Integer sid;
   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
   public void setMarks(Integer marks) {
      this.marks = marks;
   }
   public Integer getMarks() {
      return marks;
   }
   public void setYear(Integer year) {
      this.year = year;
   }
   public Integer getYear() {
      return year;
   }
   public void setSid(Integer sid) {
      this.sid = sid;
   }
   public Integer getSid() {
      return sid;
   }
}

以下是 StudentMarksMapper.java 文件的內容：

package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMarksMapper implements RowMapper<StudentMarks> {
   public StudentMarks mapRow(ResultSet rs, int rowNum) throws SQLException {
      StudentMarks studentMarks = new StudentMarks();
      studentMarks.setId(rs.getInt("id"));
      studentMarks.setName(rs.getString("name"));
      studentMarks.setAge(rs.getInt("age"));
      studentMarks.setSid(rs.getInt("sid"));
      studentMarks.setMarks(rs.getInt("marks"));
      studentMarks.setYear(rs.getInt("year"));
      return studentMarks;
   }
}

下面是定義的 DAO 接口 StudentDAO 實現類文件 StudentJDBCTemplate.java：

package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   private PlatformTransactionManager transactionManager;
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public void setTransactionManager(
      PlatformTransactionManager transactionManager) {
      this.transactionManager = transactionManager;
   }
   public void create(String name, Integer age, Integer marks, Integer year){
      TransactionDefinition def = new DefaultTransactionDefinition();
      TransactionStatus status = transactionManager.getTransaction(def);
      try {
         String SQL1 = "insert into Student (name, age) values (?, ?)";
         jdbcTemplateObject.update( SQL1, name, age);
         // Get the latest student id to be used in Marks table
         String SQL2 = "select max(id) from Student";
         int sid = jdbcTemplateObject.queryForInt( SQL2 );
         String SQL3 = "insert into Marks(sid, marks, year) " + 
                       "values (?, ?, ?)";
         jdbcTemplateObject.update( SQL3, sid, marks, year);
         System.out.println("Created Name = " + name + ", Age = " + age);
         transactionManager.commit(status);
      } catch (DataAccessException e) {
         System.out.println("Error in creating record, rolling back");
         transactionManager.rollback(status);
         throw e;
      }
      return;
   }
   public List<StudentMarks> listStudents() {
      String SQL = "select * from Student, Marks where Student.id=Marks.sid";
      List <StudentMarks> studentMarks = jdbcTemplateObject.query(SQL, 
                                         new StudentMarksMapper());
      return studentMarks;
   }
}

現在讓我們改變主應用程序文件 MainApp.java，如下所示：

package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
             new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
      (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");     
      System.out.println("------Records creation--------" );
      studentJDBCTemplate.create("Zara", 11, 99, 2010);
      studentJDBCTemplate.create("Nuha", 20, 97, 2010);
      studentJDBCTemplate.create("Ayan", 25, 100, 2011);
      System.out.println("------Listing all the records--------" );
      List<StudentMarks> studentMarks = studentJDBCTemplate.listStudents();
      for (StudentMarks record : studentMarks) {
         System.out.print("ID : " + record.getId() );
         System.out.print(", Name : " + record.getName() );
         System.out.print(", Marks : " + record.getMarks());
         System.out.print(", Year : " + record.getYear());
         System.out.println(", Age : " + record.getAge());
      }
   }
}

下面是配置文件 Beans.xml 的內容：

<?xml version="1.0" encoding="UTF-8"?>
<beans 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-3.0.xsd ">

   <!-- Initialization for data source -->
   <bean id="dataSource" 
      class="org.springframework.jdbc.datasource.DriverManagerDataSource">
      <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
      <property name="url" value="jdbc:mysql://localhost:3306/TEST"/>
      <property name="username" value="root"/>
      <property name="password" value="password"/>
   </bean>

   <!-- Initialization for TransactionManager -->
   <bean id="transactionManager" 
      class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource"  ref="dataSource" />    
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id="studentJDBCTemplate"
      class="com.tutorialspoint.StudentJDBCTemplate">
      <property name="dataSource"  ref="dataSource" />
      <property name="transactionManager"  ref="transactionManager" />    
   </bean>

</beans>

當你完成了創建源和 bean 配置文件后，讓我們運行應用程序。如果你的應用程序運行順利的話，那么將會輸出如下所示的消息：

------Records creation--------
Created Name = Zara, Age = 11
Created Name = Nuha, Age = 20
Created Name = Ayan, Age = 25
------Listing all the records--------
ID : 1, Name : Zara, Marks : 99, Year : 2010, Age : 11
ID : 2, Name : Nuha, Marks : 97, Year : 2010, Age : 20
ID : 3, Name : Ayan, Marks : 100, Year : 2011, Age : 25

 

Spring 聲明式事務管理

聲明式事務管理方法允許你在配置的幫助下而不是源代碼硬編程來管理事務。這意味着你可以將事務管理從事務代碼中隔離出來。你可以只使用注釋或基於配置的 XML 來管理事務。 bean 配置會指定事務型方法。這是與聲明式事務相關的步驟：

• 我們使用 標簽，它創建一個事務處理的建議，同時，我們定義一個匹配所有方法的切入點，我們希望這些方法是事務型的並且會引用事務型的建議。

• 如果在事務型配置中包含了一個方法的名稱，那么創建的建議在調用方法之前就會在事務中開始進行。

• 目標方法會在 try / catch 塊中執行。

• 如果方法正常結束，AOP 建議會成功的提交事務，否則它執行回滾操作。

讓我們看看上述步驟是如何實現的。但是在我們開始之前，至少有兩個數據庫表是至關重要的，在事務的幫助下，我們可以實現各種 CRUD 操作。以 Student 表為例，該表是使用下述 DDL 在 MySQL TEST 數據庫中創建的。

CREATE TABLE Student(
   ID   INT NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(20) NOT NULL,
   AGE  INT NOT NULL,
   PRIMARY KEY (ID)
);

第二個表是 Marks，我們用來存儲基於年份的學生標記。在這里，SID 是 Student 表的外鍵。

CREATE TABLE Marks(
   SID INT NOT NULL,
   MARKS  INT NOT NULL,
   YEAR   INT NOT NULL
);

現在讓我們編寫 Spring JDBC 應用程序來在 Student 和 Marks 表中實現簡單的操作。讓我們適當的使用 Eclipse IDE，並按照如下所示的步驟來創建一個 Spring 應用程序：

步驟一：創建一個名為 SpringExample 的項目，並在創建的項目中的 src 文件夾下創建包 com.tutorialspoint。

步驟二：使用 Add JARs 選項添加必需的 Spring 庫。

步驟三：在項目中添加其它必需的庫 mysql-connector-java.jar，org.springframework.jdbc.jar 和 org.springframework.transaction.jar。如果你還沒有這些庫，你可以下載它們。

步驟四：創建 DAO 接口 StudentDAO 並列出所有需要的方法。盡管它不是必需的並且你可以直接編寫 StudentJDBCTemplate 類，但是作為一個好的實踐，我們還是做吧。

步驟五：在 com.tutorialspoint 包下創建其他必需的 Java 類 StudentMarks，StudentMarksMapper，StudentJDBCTemplate 和 MainApp。如果需要的話，你可以創建其他的 POJO 類。

步驟六：確保你已經在 TEST 數據庫中創建了 Student 和 Marks 表。還要確保你的 MySQL 服務器運行正常並且你使用給出的用戶名和密碼可以讀/寫訪問數據庫。

步驟七：在 src 文件夾下創建 Beans 配置文件 Beans.xml 。

最后一步：最后一步是創建所有 Java 文件和 Bean 配置文件的內容並按照如下所示的方法運行應用程序。

下面是數據訪問對象接口文件 StudentDAO.java 的內容：

package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
   /** 
    * This is the method to be used to initialize
    * database resources ie. connection.
    */
   public void setDataSource(DataSource ds);
   /** 
    * This is the method to be used to create
    * a record in the Student and Marks tables.
    */
   public void create(String name, Integer age, Integer marks, Integer year);
   /** 
    * This is the method to be used to list down
    * all the records from the Student and Marks tables.
    */
   public List<StudentMarks> listStudents();
}

以下是 StudentMarks.java 文件的內容：

package com.tutorialspoint;
public class StudentMarks {
   private Integer age;
   private String name;
   private Integer id;
   private Integer marks;
   private Integer year;
   private Integer sid;
   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
   public void setMarks(Integer marks) {
      this.marks = marks;
   }
   public Integer getMarks() {
      return marks;
   }
   public void setYear(Integer year) {
      this.year = year;
   }
   public Integer getYear() {
      return year;
   }
   public void setSid(Integer sid) {
      this.sid = sid;
   }
   public Integer getSid() {
      return sid;
   }
}

下面是 StudentMarksMapper.java 文件的內容：

package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMarksMapper implements RowMapper<StudentMarks> {
   public StudentMarks mapRow(ResultSet rs, int rowNum) throws SQLException {
      StudentMarks studentMarks = new StudentMarks();
      studentMarks.setId(rs.getInt("id"));
      studentMarks.setName(rs.getString("name"));
      studentMarks.setAge(rs.getInt("age"));
      studentMarks.setSid(rs.getInt("sid"));
      studentMarks.setMarks(rs.getInt("marks"));
      studentMarks.setYear(rs.getInt("year"));
      return studentMarks;
   }
}

下面是定義的 DAO 接口 StudentDAO 實現類文件 StudentJDBCTemplate.java：

package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO{
   private JdbcTemplate jdbcTemplateObject;
   public void setDataSource(DataSource dataSource) {
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public void create(String name, Integer age, Integer marks, Integer year){
      try {
         String SQL1 = "insert into Student (name, age) values (?, ?)";
         jdbcTemplateObject.update( SQL1, name, age);
         // Get the latest student id to be used in Marks table
         String SQL2 = "select max(id) from Student";
         int sid = jdbcTemplateObject.queryForInt( SQL2 );
         String SQL3 = "insert into Marks(sid, marks, year) " + 
                       "values (?, ?, ?)";
         jdbcTemplateObject.update( SQL3, sid, marks, year);
         System.out.println("Created Name = " + name + ", Age = " + age);
         // to simulate the exception.
         throw new RuntimeException("simulate Error condition") ;
      } catch (DataAccessException e) {
         System.out.println("Error in creating record, rolling back");
         throw e;
      }
   }
   public List<StudentMarks> listStudents() {
      String SQL = "select * from Student, Marks where Student.id=Marks.sid";
      List <StudentMarks> studentMarks=jdbcTemplateObject.query(SQL, 
      new StudentMarksMapper());
      return studentMarks;
   }
}

現在讓我們改變主應用程序文件 MainApp.java，如下所示：

package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
             new ClassPathXmlApplicationContext("Beans.xml");
      StudentDAO studentJDBCTemplate = 
      (StudentDAO)context.getBean("studentJDBCTemplate");     
      System.out.println("------Records creation--------" );
      studentJDBCTemplate.create("Zara", 11, 99, 2010);
      studentJDBCTemplate.create("Nuha", 20, 97, 2010);
      studentJDBCTemplate.create("Ayan", 25, 100, 2011);
      System.out.println("------Listing all the records--------" );
      List<StudentMarks> studentMarks = studentJDBCTemplate.listStudents();
      for (StudentMarks record : studentMarks) {
         System.out.print("ID : " + record.getId() );
         System.out.print(", Name : " + record.getName() );
         System.out.print(", Marks : " + record.getMarks());
         System.out.print(", Year : " + record.getYear());
         System.out.println(", Age : " + record.getAge());
      }
   }
}

以下是配置文件 Beans.xml 的內容：

<?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:tx="http://www.springframework.org/schema/tx"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

   <!-- Initialization for data source -->
   <bean id="dataSource" 
      class="org.springframework.jdbc.datasource.DriverManagerDataSource">
      <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
      <property name="url" value="jdbc:mysql://localhost:3306/TEST"/>
      <property name="username" value="root"/>
      <property name="password" value="cohondob"/>
   </bean>

   <tx:advice id="txAdvice"  transaction-manager="transactionManager">
      <tx:attributes>
      <tx:method name="create"/>
      </tx:attributes>
   </tx:advice>

   <aop:config>
      <aop:pointcut id="createOperation" 
      expression="execution(* com.tutorialspoint.StudentJDBCTemplate.create(..))"/>
      <aop:advisor advice-ref="txAdvice" pointcut-ref="createOperation"/>
   </aop:config>

   <!-- Initialization for TransactionManager -->
   <bean id="transactionManager"
   class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource"  ref="dataSource" />    
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id="studentJDBCTemplate"  
   class="com.tutorialspoint.StudentJDBCTemplate">
      <property name="dataSource"  ref="dataSource" />  
   </bean>

</beans>

當你完成了創建源和 bean 配置文件后，讓我們運行應用程序。如果你的應用程序運行順利的話，那么會輸出如下所示的異常。在這種情況下，事務會回滾並且在數據庫表中不會創建任何記錄。

------Records creation--------
Created Name = Zara, Age = 11
Exception in thread "main" java.lang.RuntimeException: simulate Error condition

在刪除StudentJDBCTemplate類中create方法拋出異常的代碼后，你可以嘗試上述示例，在這種情況下，會提交事務並且你可以在數據庫中看見記錄。

 

注意：項目jar包如圖所示，其中也包含了Spring其它方面的一些jar包，小Alan偷一下懶就沒去剔除了，這一塊大家可以嘗試只留下必要的jar包，以便熟悉Spring所包含的每個jar包在項目中所能夠起到的作用，記得把jar包引入項目中才能夠運行上述的示例。

 

 

結束語：除了無可奈何地走向衰老，沒有人知道前面將會發生什么，沒有人。

 

可愛博主：AlanLee

博客地址：http://www.cnblogs.com/AlanLee

本文出自博客園，歡迎大家加入博客園。