spring框架簡介

概述

Spring 是最受歡迎的企業級Java 應用程序開發框架。數以百萬的來自世界各地的開發人員使用 Spring 框架來創建好性能、易于測試、可重用的代碼。

Spring 框架是一個開源的Java 平臺，它最初是由 Rod Johnson 編寫的，并且 2003 年 6 月首次在Apache 2.0 許可下發布。

當談論到大小和透明度時， Spring 是輕量級的。 Spring 框架的基礎版本是在 2 MB 左右的。

Spring 框架的核心特性可以用于開發任何 Java 應用程序，但是在 Java EE 平臺上構建 web 應用程序是需要擴展的。 Spring 框架的目標是使 J2EE 開發變得更容易使用，通過啟用基于 POJO 編程模型來促進良好的編程實踐。

體系結構

Spring 有可能成為所有企業應用程序的一站式服務點，然而，Spring是模塊化的，允許你挑選和選擇適用于你的模塊，不必要把剩余部分也引入。下面的部分對在Spring 框架中所有可用的模塊給出了詳細的介紹。

Spring 框架提供約20 個模塊，可以根據應用程序的要求來使用。

核心容器

核心容器由核心，Bean，上下文和表達式語言模塊組成，它們的細節如下：

·        核心模塊提供了框架的基本組成部分，包括IoC 和依賴注入功能。

·        Bean 模塊提供 BeanFactory，它是一個工廠模式的復雜實現。

·        上下文模塊建立在由核心和Bean 模塊提供的堅實基礎上，它是訪問定義和配置的任何對象的媒介。ApplicationContext接口是上下文模塊的重點。

·        表達式語言模塊在運行時提供了查詢和操作一個對象圖的強大的表達式語言。

數據訪問/集成

數據訪問/集成層包括 JDBC，ORM，OXM，JMS 和事務處理模塊，它們的細節如下：

·        JDBC 模塊提供了刪除冗余的 JDBC 相關編碼的 JDBC 抽象層。

·        ORM 模塊為流行的對象關系映射 API，包括 JPA，JDO，Hibernate和 iBatis，提供了集成層。

·        OXM 模塊提供了抽象層，它支持對 JAXB，Castor，XMLBeans，JiBX 和 XStream 的對象/XML 映射實現。

·        Java 消息服務 JMS 模塊包含生產和消費的信息的功能。

·        事務模塊為實現特殊接口的類及所有的 POJO 支持編程式和聲明式事務管理。

Web

Web 層由Web，Web-MVC，Web-Socket 和 Web-Portlet 組成，它們的細節如下：

·        Web 模塊提供了基本的面向 web 的集成功能，例如多個文件上傳的功能和使用 servlet 監聽器和面向 web 應用程序的上下文來初始化 IoC 容器。

·        Web-MVC 模塊包含 Spring 的模型-視圖-控制器（MVC），實現了web 應用程序。

·        Web-Socket 模塊為 WebSocket-based 提供了支持，而且在 web 應用程序中提供了客戶端和服務器端之間通信的兩種方式。

·        Web-Portlet 模塊提供了在 portlet 環境中實現 MVC，并且反映了 Web-Servlet 模塊的功能。

其他

還有其他一些重要的模塊，像AOP，Aspects，Instrumentation，Web 和測試模塊，它們的細節如下：

·        AOP 模塊提供了面向方面的編程實現，允許你定義方法攔截器和切入點對代碼進行干凈地解耦，它實現了應該分離的功能。

·        Aspects 模塊提供了與 AspectJ 的集成，這是一個功能強大且成熟的面向切面編程（AOP）框架。

·        Instrumentation 模塊在一定的應用服務器中提供了類 instrumentation 的支持和類加載器的實現。

·        Messaging 模塊為 STOMP 提供了支持作為在應用程序中 WebSocket 子協議的使用。它也支持一個注解編程模型，它是為了選路和處理來自WebSocket 客戶端的 STOMP 信息。

·        測試模塊支持對具有 JUnit 或 TestNG 框架的 Spring 組件的測試。

Spring 框架和通用日志安裝目錄所需的核心 JAR 文件：

·        commons-logging-1.1.1

·        spring-aop-4.1.6.RELEASE

·        spring-aspects-4.1.6.RELEASE

·        spring-beans-4.1.6.RELEASE

·        spring-context-4.1.6.RELEASE

·        spring-context-support-4.1.6.RELEASE

·        spring-core-4.1.6.RELEASE

·        spring-expression-4.1.6.RELEASE

·        spring-instrument-4.1.6.RELEASE

·        spring-instrument-tomcat-4.1.6.RELEASE

·        spring-jdbc-4.1.6.RELEASE

·        spring-jms-4.1.6.RELEASE

·        spring-messaging-4.1.6.RELEASE

·        spring-orm-4.1.6.RELEASE

·        spring-oxm-4.1.6.RELEASE

·        spring-test-4.1.6.RELEASE

·        spring-tx-4.1.6.RELEASE

·        spring-web-4.1.6.RELEASE

·        spring-webmvc-4.1.6.RELEASE

·        spring-webmvc-portlet-4.1.6.RELEASE

·        spring-websocket-4.1.6.RELEASE

Spring IoC 容器

IoC 容器

Spring 容器是Spring 框架的核心。容器將創建對象，把它們連接在一起，配置它們，并管理他們的整個生命周期從創建到銷毀。Spring容器使用依賴注入（DI）來管理組成一個應用程序的組件。這些對象被稱為Spring Beans，我們將在下一章中進行討論。

通過閱讀配置元數據提供的指令，容器知道對哪些對象進行實例化，配置和組裝。配置元數據可以通過XML，Java 注釋或 Java 代碼來表示。下圖是 Spring 如何工作的高級視圖。 Spring IoC 容器利用 Java 的 POJO 類和配置元數據來生成完全配置和可執行的系統或應用程序。

Spring 提供了以下兩種不同類型的容器。

ApplicationContext 容器包括 BeanFactory 容器的所有功能，所以通常建議超過 BeanFactory。BeanFactory 仍然可以用于輕量級的應用程序，如移動設備或基于 applet 的應用程序，其中它的數據量和速度是顯著。

Sping 的 BeanFactory 容器

這是一個最簡單的容器，它主要的功能是為依賴注入（DI）提供支持，這個容器接口在org.springframework.beans.factory.BeanFactor 中被定義。BeanFactory 和相關的接口，比如，BeanFactoryAware、 DisposableBean、InitializingBean，仍舊保留在 Spring 中，主要目的是向后兼容已經存在的和那些 Spring 整合在一起的第三方框架。

在 Spring 中，有大量對 BeanFactory 接口的實現。其中，最常被使用的是 XmlBeanFactory 類。這個容器從一個 XML 文件中讀取配置元數據，由這些元數據來生成一個被配置化的系統或者應用。

在資源寶貴的移動設備或者基于applet 的應用當中，BeanFactory 會被優先選擇。否則，一般使用的是ApplicationContext，除非你有更好的理由選擇BeanFactory。

Spring ApplicationContext 容器

Application Context 是 spring 中較高級的容器。和 BeanFactory 類似，它可以加載配置文件中定義的 bean，將所有的 bean 集中在一起，當有請求的時候分配 bean。另外，它增加了企業所需要的功能，比如，從屬性文件從解析文本信息和將事件傳遞給所指定的監聽器。這個容器在org.springframework.context.ApplicationContext interface 接口中定義。

ApplicationContext 包含 BeanFactory 所有的功能，一般情況下，相對于 BeanFactory，ApplicationContext 會被推薦使用。BeanFactory 仍然可以在輕量級應用中使用，比如移動設備或者基于 applet 的應用程序。

最常被使用的ApplicationContext 接口實現：

·        FileSystemXmlApplicationContext：該容器從 XML 文件中加載已被定義的 bean。在這里，你需要提供給構造器 XML 文件的完整路徑

·        ClassPathXmlApplicationContext：該容器從 XML 文件中加載已被定義的 bean。在這里，你不需要提供 XML 文件的完整路徑，只需正確配置 CLASSPATH 環境變量即可，因為，容器會從 CLASSPATH 中搜索 bean 配置文件。

·        WebXmlApplicationContext：該容器會在一個 web 應用程序的范圍內加載在 XML 文件中已被定義的 bean。

Bean 定義

被稱作 bean 的對象是構成應用程序的支柱也是由 Spring IoC 容器管理的。bean 是一個被實例化，組裝，并通過 Spring IoC 容器所管理的對象。這些 bean 是由用容器提供的配置元數據創建的，例如，已經在先前章節看到的，在 XML 的表單中的定義。

bean 定義包含稱為配置元數據的信息，下述容器也需要知道配置元數據：

·        如何創建一個bean

·        bean 的生命周期的詳細信息

·        bean 的依賴關系

上述所有的配置元數據轉換成一組構成每個bean 定義的下列屬性。

Spring 配置元數據

Spring IoC 容器完全由實際編寫的配置元數據的格式解耦。有下面三個重要的方法把配置元數據提供給Spring 容器：

·        基于 XML 的配置文件。

·        基于注解的配置

·        基于 Java 的配置

你已經看到了如何把基于 XML 的配置元數據提供給容器，但是讓我們看看另一個基于 XML 配置文件的例子，這個配置文件中有不同的 bean 定義，包括延遲初始化，初始化方法和銷毀方法的：

<?xml version="1.0"encoding="UTF-8"?>

<beansxmlns="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">

  <!-- A simple bean definition -->

  <bean id="..." class="...">

      <!-- collaborators and configuration for this bean go here -->

  </bean>

  <!-- A bean definition with lazy init set on -->

  <bean id="..." class="..."lazy-init="true">

      <!-- collaborators and configuration for this bean go here -->

  </bean>

  <!-- A bean definition with initialization method -->

  <bean id="..." class="..."init-method="...">

      <!-- collaborators and configuration for this bean go here -->

  </bean>

  <!-- A bean definition with destruction method -->

  <bean id="..." class="..."destroy-method="...">

      <!-- collaborators and configuration for this bean go here -->

  </bean>

  <!-- more bean definitions go here -->

</beans>

Bean 的作用域

當在 Spring 中定義一個 bean 時，你必須聲明該 bean 的作用域的選項。例如，為了強制 Spring 在每次需要時都產生一個新的 bean 實例，你應該聲明 bean 的作用域的屬性為 prototype。同理，如果你想讓 Spring 在每次需要時都返回同一個bean實例，你應該聲明 bean 的作用域的屬性為 singleton。

Spring 框架支持以下五個作用域，如果你使用web-aware ApplicationContext 時，其中三個是可用的。

Bean 的生命周期

理解 Springbean 的生命周期很容易。當一個 bean 被實例化時，它可能需要執行一些初始化使它轉換成可用狀態。同樣，當 bean 不再需要，并且從容器中移除時，可能需要做一些清除工作。

盡管還有一些在 Bean 實例化和銷毀之間發生的活動，但是本章將只討論兩個重要的生命周期回調方法，它們在bean 的初始化和銷毀的時候是必需的。

為了定義安裝和拆卸一個 bean，我們只要聲明帶有 init-method 和/或 destroy-method 參數的。init-method屬性指定一個方法，在實例化 bean 時，立即調用該方法。同樣，destroy-method 指定一個方法，只有從容器中移除 bean 之后，才能調用該方法。

初始化回調

org.springframework.beans.factory.InitializingBean 接口指定一個單一的方法：

void afterPropertiesSet() throws Exception;

因此，你可以簡單地實現上述接口和初始化工作可以在afterPropertiesSet() 方法中執行，如下所示：

public class ExampleBean implements InitializingBean{

   public void afterPropertiesSet(){  // do some initialization work

   }

}

在基于 XML 的配置元數據的情況下，你可以使用 init-method 屬性來指定帶有 void 無參數方法的名稱。例如：

<bean id="exampleBean"

         class="examples.ExampleBean" init-method="init"/>

下面是類的定義：

public class ExampleBean{

   public void init(){ // do some initialization work

   }

}

銷毀回調

org.springframework.beans.factory.DisposableBean 接口指定一個單一的方法：

void destroy() throws Exception;

因此，你可以簡單地實現上述接口并且結束工作可以在destroy() 方法中執行，如下所示：

public class ExampleBean implements DisposableBean{

   public void destroy(){

      // do some destruction work

   }

}

在基于 XML 的配置元數據的情況下，你可以使用 destroy-method 屬性來指定帶有 void 無參數方法的名稱。例如：

<bean id="exampleBean" class="examples.ExampleBean" destroy-method="destroy"/>

下面是類的定義：

public class ExampleBean{

   public void destroy(){    // do some destruction work

   }

}

如果你在非 web 應用程序環境中使用 Spring 的 IoC 容器；例如在豐富的客戶端桌面環境中；那么在 JVM 中你要注冊關閉 hook。這樣做可以確保正常關閉，為了讓所有的資源都被釋放，可以在單個 beans 上調用 destroy 方法。

Spring——Bean 后置處理器

BeanPostProcessor 接口定義回調方法，你可以實現該方法來提供自己的實例化邏輯，依賴解析邏輯等。你也可以在Spring 容器通過插入一個或多個BeanPostProcessor 的實現來完成實例化，配置和初始化一個bean之后實現一些自定義邏輯回調方法。

你可以配置多個 BeanPostProcesso r接口，通過設置 BeanPostProcessor 實現的 Ordered 接口提供的 order 屬性來控制這些 BeanPostProcessor 接口的執行順序。

BeanPostProcessor 可以對 bean（或對象）實例進行操作，這意味著 Spring IoC 容器實例化一個 bean 實例，然后 BeanPostProcessor 接口進行它們的工作。

ApplicationContext 會自動檢測由 BeanPostProcessor 接口的實現定義的 bean，注冊這些 bean 為后置處理器，然后通過在容器中創建 bean，在適當的時候調用它。

Bean 定義繼承

bean 定義可以包含很多的配置信息，包括構造函數的參數，屬性值，容器的具體信息例如初始化方法，靜態工廠方法名，等等。

子 bean 的定義繼承父定義的配置數據。子定義可以根據需要重寫一些值，或者添加其他值。

Spring Bean 定義的繼承與Java 類的繼承無關，但是繼承的概念是一樣的。你可以定義一個父bean 的定義作為模板和其他子 bean 就可以從父 bean 中繼承所需的配置。

當你使用基于 XML 的配置元數據時，通過使用父屬性，指定父 bean 作為該屬性的值來表明子 bean 的定義。

例如：

下面是配置文件 Beans.xml，在該配置文件中我們定義有兩個屬性 message1 和 message2 的 “helloWorld” bean。然后，使用 parent 屬性把 “helloIndia” bean 定義為 “helloWorld” bean 的孩子。這個子 bean 繼承 message2 的屬性，重寫 message1 的屬性，并且引入一個屬性 message3。

<?xml version="1.0" encoding="UTF-8"?>

<beansxmlns="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">

   <beanid="helloWorld" class="com.tutorialspoint.HelloWorld">

      <property name="message1"value="Hello World!"/>

      <propertyname="message2" value="Hello Second World!"/>

   </bean>

   <beanid="helloIndia" class="com.tutorialspoint.HelloIndia"parent="helloWorld">

      <propertyname="message1" value="Hello India!"/>

      <propertyname="message3" value="Namaste India!"/>

   </bean>

</beans>

這里是 HelloWorld.java 文件的內容：

package com.tutorialspoint;

public class HelloWorld {  private String message1;
private String message2;

   public void setMessage1(String message){

 this.message1  = message;

   }

   public void setMessage2(String message){

this.message2  = message;

   }

   public void getMessage1(){

      System.out.println("World Message1 : " + message1);

   }

   public void getMessage2(){

      System.out.println("World Message2 : " + message2);

   }

}

這里是 HelloIndia.java 文件的內容：

package com.tutorialspoint;

public class HelloIndia {

   private String message1;

   private String message2;

   private String message3;

   public void setMessage1(String message){

      this.message1  = message;

   }

   public void setMessage2(String message){

      this.message2  = message;

   }

   public void setMessage3(String message){

      this.message3  = message;

   }

   public void getMessage1(){

     System.out.println("India Message1 : " + message1);

   }

   public void getMessage2(){

     System.out.println("India Message2 : " + message2);

   }

   public void getMessage3(){

     System.out.println("India Message3 : " + message3);

   }

}

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

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;

importorg.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {

   public static void main(String[]args) {

      ApplicationContextcontext = new ClassPathXmlApplicationContext("Beans.xml");

      HelloWorld objA =(HelloWorld) context.getBean("helloWorld");

      objA.getMessage1();

      objA.getMessage2();

      HelloIndia objB =(HelloIndia) context.getBean("helloIndia");

      objB.getMessage1();

      objB.getMessage2();

      objB.getMessage3();

   }

}

Spring 依賴注入

依賴注入

每個基于應用程序的 java 都有幾個對象，這些對象一起工作來呈現出終端用戶所看到的工作的應用程序。當編寫一個復雜的Java 應用程序時，應用程序類應該盡可能獨立于其他 Java 類來增加這些類重用的可能性，并且在做單元測試時，測試獨立于其他類的獨立性。依賴注入（或有時稱為布線）有助于把這些類粘合在一起，同時保持他們獨立。

假設你有一個包含文本編輯器組件的應用程序，并且你想要提供拼寫檢查。標準代碼看起來是這樣的：

publicclassTextEditor{

   private SpellChecker spellChecker;  

   public TextEditor(){

      spellChecker = new SpellChecker();

   }

}

在這里我們所做的就是創建一個TextEditor 和SpellChecker 之間的依賴關系。在控制反轉的場景中，我們反而會做這樣的事情：

public class TextEditor{

   private SpellChecker spellChecker;

   public TextEditor(SpellChecker spellChecker){

      this.spellChecker = spellChecker;

   }

}

在這里，TextEditor不應該擔心 SpellChecker 的實現。SpellChecker 將會獨立實現，并且在 TextEditor 實例化的時候將提供給 TextEditor，整個過程是由 Spring 框架的控制。

在這里，我們已經從 TextEditor 中刪除了全面控制，并且把它保存到其他地方（即 XML 配置文件），且依賴關系（即 SpellChecker 類）通過類構造函數被注入到TextEditor 類中。因此，控制流通過依賴注入（DI）已經“反轉”，因為你已經有效地委托依賴關系到一些外部系統。

依賴注入的第二種方法是通過 TextEditor 類的 Setter 方法，我們將創建 SpellChecker 實例，該實例將被用于調用 setter 方法來初始化 TextEditor 的屬性。

因此，DI 主要有兩種變體和下面的兩個子章將結合實例涵蓋它們：

你可以混合這兩種方法，基于構造函數和基于setter 方法的 DI，然而使用有強制性依存關系的構造函數和有可選依賴關系的 setter是一個好的做法。

代碼是 DI 原理的清洗機，當對象與它們的依賴關系被提供時，解耦效果更明顯。對象不查找它的依賴關系，也不知道依賴關系的位置或類，而這一切都由Spring 框架控制的。

Spring 框架的 AOP

Spring 框架的 AOP

Spring 框架的一個關鍵組件是面向方面的編程(AOP)框架。面向方面的編程需要把程序邏輯分解成不同的部分稱為所謂的關注點。跨一個應用程序的多個點的功能被稱為橫切關注點，這些橫切關注點在概念上獨立于應用程序的業務邏輯。有各種各樣的常見的很好的方面的例子，如日志記錄、審計、聲明式事務、安全性和緩存等。

在 OOP 中，關鍵單元模塊度是類，而在 AOP 中單元模塊度是方面。依賴注入幫助你對應用程序對象相互解耦和 AOP 可以幫助你從它們所影響的對象中對橫切關注點解耦。AOP 是像編程語言的觸發物，如 Perl，.NET，Java 或者其他。

Spring AOP 模塊提供攔截器來攔截一個應用程序，例如，當執行一個方法時，你可以在方法執行之前或之后添加額外的功能。

AOP 術語

在我們開始使用 AOP 工作之前，讓我們熟悉一下 AOP 概念和術語。這些術語并不特定于 Spring，而是與 AOP 有關的。

通知的類型

Spring 方面可以使用下面提到的五種通知工作：

實現自定義方面

Spring 支持 @AspectJ annotationstyle 的方法和基于模式的方法來實現自定義方面。這兩種方法已經在下面兩個子節進行了詳細解釋。

Spring JDBC 框架

JDBC 框架概述

在使用普通的 JDBC 數據庫時，就會很麻煩的寫不必要的代碼來處理異常，打開和關閉數據庫連接等。但Spring JDBC 框架負責所有的低層細節，從開始打開連接，準備和執行SQL 語句，處理異常，處理事務，到最后關閉連接。

所以當從數據庫中獲取數據時，你所做的是定義連接參數，指定要執行的SQL 語句，每次迭代完成所需的工作。

SpringJDBC 提供幾種方法和數據庫中相應的不同的類與接口。我將給出使用 JdbcTemplate 類框架的經典和最受歡迎的方法。這是管理所有數據庫通信和異常處理的中央框架類。

JdbcTemplate 類

JdbcTemplate 類執行SQL 查詢、更新語句和存儲過程調用，執行迭代結果集和提取返回參數值。它也捕獲JDBC 異常并轉換它們到 org.springframework.dao包中定義的通用類、更多的信息、異常層次結構。

JdbcTemplate 類的實例是線程安全配置的。所以你可以配置JdbcTemplate 的單個實例，然后將這個共享的引用安全地注入到多個DAOs 中。

使用JdbcTemplate 類時常見的做法是在你的 Spring 配置文件中配置數據源，然后共享數據源 bean 依賴注入到 DAO 類中，并在數據源的設值函數中創建了 JdbcTemplate。

配置數據源

我們需要提供一個數據源到JdbcTemplate 中，所以它可以配置本身來獲得數據庫訪問。你可以在XML 文件中配置數據源，其中一段代碼如下所示：

<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>

數據訪問對象（DAO）

DAO 代表常用的數據庫交互的數據訪問對象。DAOs提供一種方法來讀取數據并將數據寫入到數據庫中，它們應該通過一個接口顯示此功能，應用程序的其余部分將訪問它們。

在 Spring 中，數據訪問對象(DAO)支持很容易用統一的方法使用數據訪問技術，如 JDBC、Hibernate、JPA 或者 JDO。

執行 SQL 語句

我們看看如何使用 SQL 和 jdbcTemplate 對象在數據庫表中執行 CRUD(創建、讀取、更新和刪除)操作。

查詢一個整數類型：

String SQL = "select count(*) from Student;int rowCount = jdbcTemplateObject.queryForInt( SQL );

Spring 事務管理

事務管理

一個數據庫事務是一個被視為單一的工作單元的操作序列。這些操作應該要么完整地執行，要么完全不執行。事務管理是一個重要組成部分，RDBMS面向企業應用程序，以確保數據完整性和一致性。事務的概念可以描述為具有以下四個關鍵屬性說成是 ACID：

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

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

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

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

一個真正的 RDBMS 數據庫系統將為每個事務保證所有的四個屬性。使用 SQL 發布到數據庫中的事務的簡單視圖如下：

·        使用 begintransaction 命令開始事務。

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

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

Spring 框架在不同的底層事務管理APIs 的頂部提供了一個抽象層。Spring 的事務支持旨在通過添加事務能力到 POJOs 來提供給 EJB 事務一個選擇方案。Spring 支持編程式和聲明式事務管理。EJBs 需要一個應用程序服務器，但 Spring 事務管理可以在不需要應用程序服務器的情況下實現。

局部事物 vs. 全局事務

局部事務是特定于一個單一的事務資源，如一個JDBC 連接，而全局事務可以跨多個事務資源事務，如在一個分布式系統中的事務。

局部事務管理在一個集中的計算環境中是有用的，該計算環境中應用程序組件和資源位于一個單位點，而事務管理只涉及到一個運行在一個單一機器中的本地數據管理器。局部事務更容易實現。

全局事務管理需要在分布式計算環境中，所有的資源都分布在多個系統中。在這種情況下事務管理需要同時在局部和全局范圍內進行。分布式或全局事務跨多個系統執行，它的執行需要全局事務管理系統和所有相關系統的局部數據管理人員之間的協調。

編程式 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;

}

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

public interface TransactionDefinition{

   int getPropagationBehavior();

   int getIsolationLevel();

   String getName();

   int getTimeout();

   boolean isReadOnly();

}

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

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

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

public interface TransactionStatusextendsSavepointManager{

   boolean isNewTransaction();

   boolean hasSavepoint();

   void setRollbackOnly();

   boolean isRollbackOnly();

   boolean isCompleted();

}

Spring 基于注解的配置

從 Spring 2.5 開始就可以使用注解來配置依賴注入。而不是采用XML 來描述一個 bean 連線，你可以使用相關類，方法或字段聲明的注解，將 bean 配置移動到組件類本身。

在 XML 注入之前進行注解注入，因此后者的配置將通過兩種方式的屬性連線被前者重寫。

注解連線在默認情況下在 Spring 容器中不打開。因此，在可以使用基于注解的連線之前，我們將需要在我們的 Spring 配置文件中啟用它。所以如果你想在 Spring 應用程序中使用的任何注解，可以考慮到下面的配置文件。

<?xml version="1.0" encoding="UTF-8"?>

<beansxmlns="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-3.0.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- bean definitions go here -->

</beans>

一旦被配置后，你就可以開始注解你的代碼，表明 Spring 應該自動連接值到屬性，方法和構造函數。讓我們來看看幾個重要的注解，并且了解它們是如何工作的：