利用Spring Framework设计和开拓SCA组件，第2部门

副标题#e#

利用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 的一个实现 实例。

#p#分页标题#e#

在 清单 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 运行时

#p#副标题#e#

对付一个单应用措施上下文的场景，正如在 利用 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

#p#分页标题#e#

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

#p#副标题#e#

在这个例子中，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;
　　 }

　　 …
}

#p#副标题#e#

#p#分页标题#e#

如上所示的 @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 让您的组件可以或许果真 处事，将处事组件毗连在一起，以及处理惩罚异构的漫衍式系统。

本文配套源码