使用Spring Framework設計和開發SCA組件，第2部分

使用Spring Framework設計和開發SCA組件，第2部分 - 使用Apache Tuscany的高級技巧

簡介

本系列的 使用 Spring Framework 設計和開發 SCA 組件，第 1 部分：三劍客：Spring、SCA 和 Apache Tuscany 概述了綜合使用 SCA 和 Spring 的益處。您了解了如何作為一種 SCA 服務公開 Spring bean 以及如何 在 Spring 應用程序內訪問 SCA 服務和屬性。

本文將探討 Apache Tuscany 運行時支持的一些高級特性。了解如何將多種 應用程序上下文綜合起來用作 SCA 組件的一個實現。SCA 注釋可用來在 Spring bean 類內顯式聲明 SCA 服務、引用和屬性。下載 計算器示例的源代碼。

本文中的示例使用了 Apache Tuscany SCA Java™ 技術運行時 V1.5.1。要運行這個示例應用程序，需要下載 Apache Tuscany SCA Java 實現 的二進制發行版。

為 SCA 組件使用多種應用程序上下文

在 使用 Spring Framework 設 計和開發 SCA 組件，第 1 部分：三劍客：Spring、SCA 和 Apache Tuscany， 您了解了一個 Spring 應用程序可被定義為 SCA 復合集（即 SCDL）內的一個 SCA 組件，其格式如清單 1 所示。

清單 1. 具有一個 Spring 組件的 SCA 復合集

<composite　 xmlns="http://www.osoa.org/xmlns/sca/1.0"　
　　　 xmlns:tuscany="http://tuscany.apache.org/xmlns/sca/1.0"　
　　　 targetNamespace="http://calc"　
　　　xmlns:c="http://calc"　
　　　name="Calculator">　
　
　　<component　 name="CalculatorServiceComponent">　
　　　　　　　 <implementation.spring　location="targetURI"/>　
　　 </component>　
　
</composite>　

<implementation.spring> 元素的 location 屬性可將目標 URI 指定 為指向一個歸檔文件（JAR）、一個目錄或直接指向一個 Spring 應用程序上下 文文件。在任何情況下，在使用 <implementation.spring> 組件的 location 屬性時，Apache Tuscany 只允許一個應用程序上下文作為目標應用程 序上下文，用作 SCA 組件的實現。

Apache Tuscany 允許使用多種應用程序上下文來實現 SCA 組件，方法是在 這個目標應用程序上下文（由此 SCA 復合集文件內的 <implementation.spring> 元素的 location 屬性標識）中定義一個 ClassPathXmlApplicationContext（如 清單 3 所示）bean。清單 2 給出了一 個示例。

清單 2. 具有一個 Spring 組件的 SCA 復合集

<composite　xmlns="http://www.osoa.org/xmlns/sca/1.0"
　　　 xmlns:tuscany="http://tuscany.apache.org/xmlns/sca/1.0"
　　　 targetNamespace="http://calc"
　　　 xmlns:c="http://calc"
　　　 name="Calculator">

　　 <component　name="CalculatorServiceComponent">
　　　　　　　 <implementation.spring　location="beanRefContext.xml"/>
　　 </component>
</composite>

清單 3. beanRefContext.xml

<beans　 xmlns="http://www.springframework.org/schema/beans"
　　　　 xmlns:xsi="http://www.w3.org/2001/XMLSchema- instance"
　　　　 xmlns:sca="http://www.springframework.org/schema/sca"
　　　　 xsi:schemaLocation="
　　 http://www.springframework.org/schema/beans
　　　　 http://www.springframework.org/schema/beans/spring- beans.xsd
　　　　 http://www.springframework.org/schema/sca　
　　　　 http://www.osoa.org/xmlns/sca/1.0/spring- sca.xsd">

　　　 <bean　class=”　 org.springframework.context.support.ClassPathXmlApplicationContext” >
　 <constructor-arg>
　　　　　　　　　　 <list>
　　　　　　　　　　　　　 <value>context1.xml</value>
　　　　　　　　　　　　　 <value>context2.xml</value>
　　　　　　　　　　　　　 <value>context3.xml</value>
　　　　　　　　　 </list>
　　　　　 </constructor-arg>
　　　 </bean>
</beans>

這個 Apache Tuscany 運行時的意圖是將具有一個 bean 定義（以 ClassPathXmlApplicationContext 作為 bean 類）的所有目標應用程序上下文 視為一個具有多種應用程序上下文的場景。這個 Tuscany 運行時之後將會為由 ClassPathXmlApplicationContext bean 的 constructor 參數標識的這列應用 程序上下文文件創建一個組合的應用程序上下文實例。

在 清單 2 的例子中，被作為 CalculatorServiceComponent 的一個實現定 義的目標應用程序上下文是 beanRefContext.xml。在一個典型的場景中（在單 個應用程序上下文場景）中，Tuscany 運行時將會為 beanRefContext.xml 創建 一個應用程序上下文實例並將其用作 CalculatorServiceComponent 的一個實現 實例。

在 清單 3 內，beanRefContext.xml 只定義了一個 bean 定義（以 ClassPathXmlApplicationContext 作為 bean 類）。這個場景被 Tuscany 運行 時視為是一個包含多種應用程序上下文的場景。由 ClassPathXmlApplicationContext bean 定義的 constructor 參數標識的這列 應用程序上下文文件（context1.xml、context2.xml 和 context3.xml）被綜合 起來創建一個應用程序上下文實例，以用作 CalculatorServiceComponent 的一 個實現實例。圖 1 展示了一個例子。

對於一個包含多個上下文的場景，由 ClassPathXmlApplicationContext bean 定義的 constructor 參數標識的每個應用程序上下文文件都可具備其自己 的 SCA 服務、引用和屬性（以顯式或隱式的方式聲明）。

圖 1. 具備 ClassPathXmlApplicationContext 的 SCA 運行時

對於一個單應用程序上下文的場景，正如在 使用 Spring Framework 設計和 開發 SCA 組件，第 1 部分：三劍客：Spring、SCA 和 Apache Tuscany 中所討 論的，Tuscany 運行時會嘗試：

內省這個目標應用程序上下文定義文件以決定所聲明的 SCA 服務、引用和屬 性。

使用適當的 Spring beans 為在這個目標應用程序上下文內聲明的所有 SCA 引用和屬性創建一個 SCAParentApplicationContext。

之後，將 SCAParentApplicationContext 聲明為父上下文，使用 org.springframework.context.support.GenericApplicationContext 創建這個 目標應用程序上下文的實例。

在一個含多種應用程序上下文的場景中，如 圖 1 所示，Tuscany 運行時會 嘗試：

內省由 ClassPathXmlApplicationContext bean（在目標應用程序上下文中 定義）的 constructor 參數標識的這列應用程序上下文文件（context1.xml、 context2.xml 和 context3.xml）來決定所聲明的 SCA 服務、引用和屬性。

用適當的 Spring bean 為已標識的這列應用程序上下文文件內聲明的所有 SCA 引用和屬性創建一個 SCAParentApplicationContext。

之後，通過將 SCAParentApplicationContext 聲明為其父上下文，為這列應 用程序上下文文件創建一個 org.springframework.context.support.ClassPathXmlApplicationContext 實 例。

在目標應用程序上下文上使用 ClassPathXmlApplicationContext bean 定義 來提供對含多種應用程序上下文的場景的支持，這個內容超出了 SCA Spring 組 件實現規范 V1.0 的建議。

不同於目標應用程序上下文內的 ClassPathXmlApplicationContext bean 定 義，在應用程序上下文的層次結構內標識的任何一個 ClassPathXmlApplicationContext bean 定義都將被 Spring 運行時視為一個常 規的 ClassPathXmlApplicationContext bean 並被相應處理。

Spring beans 的 SCA 注釋

Apache Tuscany 對 Spring beans 內的 SCA 注釋的支持超出了由 OSOA 定 義的 SCA Spring 組件實現規范 V1.0 的建議。

在 使用 Spring Framework 設計和開發 SCA 組件，第 1 部分：三劍客： Spring、SCA 和 Apache Tuscany 中，您了解到可以使用自定義 SCA 名稱空間 元素，比如 <sca:service>、<sca:reference> 和 <sca:property>，在 Spring 應用程序上下文文件內顯式聲明 SCA 服務 、引用和屬性。同樣地，Apache Tuscany SCA 運行時允許您使用 SCA 注釋在 Spring bean 類內顯式地聲明 SCA 服務、引用和屬性。

下面介紹了用於在 Spring bean 類內顯式地聲明 SCA 服務、引用和屬性的 SCA 注釋。

org.osoa.sca.annotations.Service用來控制哪些 Spring bean 可被公開為 SCA 服務。@Service 注釋一般用在 Java 類上，用來指定由該實現提供的服務 的接口。org.osoa.sca.annotations.Reference用來在由此復合集內可用的其他 SCA 組件提供的服務上聲明一個 Spring bean 的依賴項。通過定義一個字段、 一個 setter 方法參數或一個 constructor 參數（由此服務接口鍵入並由一個 @Reference 注釋），可以使用引用注入訪問服務。 org.osoa.sca.annotations.Property用來在由 SCA 組件實現提供的可設置屬性 上聲明一個 Spring 應用程序上下文的依賴項。@Property 注釋被用來定義一個 SCA 屬性。

如下這個示例展示了如何在 Spring bean 類中使用 SCA 注釋。仍然使用在 使用 Spring Framework 設計和開發 SCA 組件，第 1 部分：三劍客：Spring、 SCA 和 Apache Tuscany 內討論的 CalculatorComponent 示例展示 SCA 注釋的 用法。

calculator.composite，如清單 4 所示，定義了 CalculatorComponent，它 依賴於其他四個服務：AddComponent、SubtractComponent、MultiplyComponent 和 DivideComponent。

清單 4. calculator.composite

<composite　xmlns="http://www.osoa.org/xmlns/sca/1.0"
　　　 xmlns:t="http://tuscany.apache.org/xmlns/sca/1.0"
　　　 targetNamespace="http://calc"
　　　 xmlns:c="http://calc"
　　　 name="Calculator">

　　 <service　name="CalculatorService"　promote=” CalculatorComponent">
　　　　 <interface.java　interface="calculator.CalculatorService"/>
　　　　 <t:binding.rmi　host="localhost"　port="8099"　 serviceName="CalculatorRMIService"/>
　　 </service>

　　 <component　name="CalculatorComponent">
　　　　 <implementation.spring　location="META-INF/spring/calculator- context.xml"/>
　　　　 <reference　name="addService"　target="AddComponent"　/>
　　　　 <reference　name="subtractService"　 target="SubtractComponent"　/>
　　　　 <reference　name="multiplyService"　 target="MultiplyComponent"/>
　　　　 <reference　name="divideService"　 target="DivideComponent"　/>
　　　　 <property　name="message">HelloWorld</property>
　　 </component>

　　 <component　name="AddComponent">
　　　　 <t:implementation.script　 script="calculator/AddServiceImpl.js"/>
　　 </component>

　　 <component　name="SubtractComponent">
　　　　 <implementation.java　 class="calculator.SubtractServiceImpl"/>
　　 </component>

　　 <component　name="MultiplyComponent">
　　　　 <implementation.java　 class="calculator.MultiplyServiceImpl"/>
　　 </component>

　　 <component　name="DivideComponent">
　　　　 <t:implementation.script　 script="calculator/DivideServiceImpl.groovy"/>
　　 </component>
</composite>

在這個例子中，CalculatorComponent 是一個 Spring 應用程序，它定義了 使用 Spring bean 的業務邏輯。創建一個名為 calculator-context.xml 的應 用程序上下文文件，如清單 5 所示，它通過將所需的依賴項設置為 bean 屬性 定義了 CalculatorComponent 的業務邏輯。

清單 5. calculator-context.xml

<beans　 xmlns="http://www.springframework.org/schema/beans"
　　　　 xmlns:xsi="http://www.w3.org/2001/XMLSchema- instance"
　　　　 xmlns:sca="http://www.springframework.org/schema/sca"
　　　　 xsi:schemaLocation="
　　 http://www.springframework.org/schema/beans
　　　　 http://www.springframework.org/schema/beans/spring- beans.xsd
　　　　 http://www.springframework.org/schema/sca　
　　　　 http://www.osoa.org/xmlns/sca/1.0/spring- sca.xsd">

　　 <bean　id="Calculator"　 class="calculator.CalculatorServiceImpl">
　　　　 <property　name="addService"　ref="addService"/>
　　　　 <property　name="subtractService"　ref="subtractService"/>
　　　　 <property　name="multiplyService"　ref="multiplyService"/>
　　　　 <property　name="divideService"　ref="divideService"/>
　　 </bean>

</beans>

在 使用 Spring Framework 設計和開發 SCA 組件，第 1 部分：三劍客： Spring、SCA 和 Apache Tuscany，您了解到自定義 SCA 名稱空間元素，比如 <sca:service>、<sca:reference> 和 <sca:property>，可 用於在這個應用程序上下文文件內（參見清單 5）顯式聲明 SCA 服務、引用和 屬性。在本文中，您又了解了 SCA 注釋是如何在 CalculatorServiceImpl bean 類內用作一種顯式聲明 SCA 服務、引用和屬性的備選方式。清單 6 給出了一個 示例。

清單 6. CalculatorServiceImpl.java

@Service(CalculatorService.class)
public
　　 class　CalculatorServiceImpl　implements　CalculatorService　 {

　　 //　setter　injection
　　 public　AddService　addService;

　　 //　field　injection
　　 @Reference
　　 public　SubtractService　subtractService;

　　 //　field　injection　(different　reference　and　field　name)
　　 @Reference(name="multiplyService")
　　 public　MultiplyService　multiply;

　　 //　setter　injection　(different　reference　and　field　 name)
　　 public　DivideService　divide;

　　 //　setter　injection
　　 public　String　message;

　　 @Reference
　　 public
　　 void　setAddService(AddService　addService)　{
　　　　 this.addService　=　addService;
　　 }

　　 public　AddService　getAddService()　{
　　　　 return　addService;
　　 }

　　 public
　　 void　setSubtractService(SubtractService　subtractService)　 {
　　　　 this.subtractService　=　subtractService;
　　 }

　　 public　SubtractService　getSubtractService()　{
　　　　 return　subtractService;
　　 }

　　 @Reference(name="divideService")
　　 public
　　 void　setDivideService(DivideService　divide)　{
　　　　 this.divide　=　divide;
　　 }

　　 public　DivideService　getDivideService()　{
　　　　 return　divide;
　　 }

　　 public
　　 void　setMultiplyService(MultiplyService　multiply)　{
　　　　 this.multiply　=　multiply;
　　 }

　　 public　MultiplyService　getMultiplyService()　{
　　　　 return　multiply;
　　 }

　　 @Property
　　 public
　　 void　setMessage(String　message)　{
　　　　 this.message　=　message;
　　 }

　　 …
}

如上所示的 @Service 注釋表明 CalculatorServiceImpl bean 被公開為一 個服務並使用 CalculatorService 作為其服務接口。對於由這些 bean 公開的 每個服務，在 SCA 復合集內都應該定義一個對等的 <service/> 元素（ 如 清單 4 所示）。

清單 6 內所示的 @Reference 注釋，在由復合集內可用的其他 SCA 組件提 供的服務上聲明了這個 bean 類的依賴項。在本例中，Calculator bean 依賴於 SCA 服務 addService、subtractService、 multiplyService 和 divideService。

在 CalculatorServiceImpl bean 內，addService 和 divideService 上的 依賴項是通過定義 setter 方法上的一個引用注入聲明的，這些方法的參數由相 應的服務接口 AddService 和 DivideService 鍵入。subtractService 和 multiplyService 上的依賴項是通過在由相應服務接口 SubtractService 和 MultiplyService 鍵入的字段上定義一個引用注入聲明的。

清單 6 所示的 @Property 注釋通過在一個適當的 setter 方法上定義 @Property 注釋，聲明了由 SCA 組件提供的可設置屬性上的依賴項。

建議

建議您獨立使用 SCA 注釋；不要與任何 Spring 本機注釋相混淆。此外，還 建議您使用 SCA 注釋或自定義 SCA 名稱空間元素（如第 1 部分內討論的）來 為 Spring 應用程序顯式聲明 SCA 服務、引用和屬性。不要將它們混在一起。

為基於 Spring 的 SCA 組件使用 SCA 綁定

綁定 是為服務和引用所用的。引用使用綁定來描繪調用一個服務所需的訪問 機制，這個服務可以是由另一個 SCA 復合集提供的一個服務。服務使用綁定來 描述客戶機（可以是來自於另一個 SCA 復合集的客戶機）用來調用服務的訪問 機制。

使用 Spring 作為其實現技術的組件無需在 Spring 配置內引入基於綁定的 SCA 元數據就可以連接 SCA 服務和引用。Spring 上下文對 SCA 環境知之不多 。因而，這個 Spring bean 實現與之前示例內的保持相同，但是要在 SCA 復合 集的級別選用不同的綁定。

Apache Tuscany 運行時支持各種綁定，比如 Web 服務、JMS、 HTTP、RMI、 JSON RPC、EJB 和 ATOM。因這些綁定獨立於 Spring 上下文，所以，所有受 SCA 支持的綁定均可被用於 Spring 實現。

請注意 Apache Tuscany 並不支持在一個基於 Spring 的 SCA 組件上的異步 對話服務編程。

結束語

在本文中，您了解了多種應用程序上下文可被綜合起來用作 SCA 組件的一個 實現。這個 SCA 運行時為含多種應用程序上下文的場景創建了一個目標應用程 序上下文實例。您還了解了如何使用 SCA 注釋在 spring bean 類內顯式聲明 SCA 服務、引用和屬性。

SCA 和 Spring 能夠構成一個強大的組合。Spring 提供了基礎設施來開發具有更高效率和運行時性能的組件，還改進了測試覆蓋率和應用程序質量。SCA 提 供了必要的基礎設施來組裝和建模基於 SOA 的組件，SCA 讓您的組件能夠公開 服務，將服務組件連接在一起，以及處理異構的分布式系統。

本文配套源碼