利用Spring Framework设计和开拓SCA组件，第1部门 – 三剑客
副标题#e#
利用Spring Framework设计和开拓SCA组件，第1部门 – 三剑客：Spring、SCA和Apache Tuscany
在 “利用 Spring Framework 设计和开拓 SCA 组件” 系列文章 中，进修如何有效团结处事组件架构（Service Component Architecture，SCA ）与 Spring Framework 来建设漫衍式处事应用措施。第一篇文章将概述 SCA 与 Spring 两者相团结的优势。进修如何利用 Spring Framework 来设计和开拓 SCA 组件，如何将 Spring beans 果真为 SCA 处事，以及如安在 Spring 应用 措施中会见 SCA 处事和属性。本文中的示例将利用 Apache Tuscany SCA Java™ 技能运行时。
简介
在 Open SOA (OSOA) 项目宣布标题为 “强大的组合：SCA 、OSGi 和 Spring” 的白皮书之后，这三种技能的团结引起了人们的一些 存眷。Spring Dynamic Module 就是这种基本架构的一种贸易实现，它团结了 Spring 和 OGSi。Spring beans 可以作为处事组件架构（SCA）的组件实现利用 。Apache Tuscany 的Java 实现成立在 Apache 的OSGi 框架 (Felix) 的基本之 上。
在本系列中，进修如何利用 Spring Framework 和 Apache Tuscany SCA Java 运行时来设计和开拓 SCA 组件。示例和代码片断将辅佐您领略 SCA 与 Spring 两者团结所带来的长处。您还将相识如何团结 SCA 与 Spring 来创 建漫衍式处事应用措施。
本文将先容利用 Spring 开拓 SCA 组件时需要 把握的一些根基设计原则。您将摸索如何将 Spring beans 果真为 SCA 处事， 以及如安在 Spring 应用措施中会见 SCA 处事和属性。
第 2 部门将深 入接头一些高级特性，好比说通过 SCA 处理惩罚多种应用措施上下文以及在 Spring beans 中利用 SCA 注释。
下载 示例源代码。此示例需要在 Apache Tuscany 运行时中运行，但其偏重 点并不是展示如何开拓 SCA 组件。本文将重点接头如何将 Spring 应用措施作 为 SCA 组件的一种实现技能来利用。
措施
本文将接头以下措施。
SCA提供了一个编程模子，用于建设基于面向处事架构（Service-Oriented Architecture ，SOA）的应用措施息争决方案。SCA 所依托的理念是将业务成果 作为一系列处事提供，从而建设能满意特定业务需求的办理方案。这些复合集可 以包括为已有系统中的应用措施和业务成果建设的新处事，以及作为复合应用的 一部门重用的应用措施。SCA 提供了：
一个用于处事复合以及处事组件建设的模子，包罗在 SCA 复合会合重用已有 应用措施。
机动的复合、重用、技能和陈设选择，这使它成为了构建异构漫衍式系统的 抱负情况。
支持多种实现语言和通信机制。
简化的组件编程模子，用于利用各类技能（好比说 Enterprise JavaBeans、 Java POJOs、Spring beans、BPEL Process、COBOL、C++ 和 PHP 等）来实现业 务处事。
Spring Framework凡是称作 Spring，它是一个实验通过办理企业应用措施开 发的巨大性来提高 J2EE 情况合用性的开源项目。Spring 的一个优势在于它的 分层架构。它答允您选择所利用的组件，同时为 J2EE 应用措施开拓提供了一个 细密团结的框架。Spring 为简朴的Java 工具提供了一个框架，从而使它们可以或许 通过包装器类和 XML 设置来利用 J2EE 容器。Spring 的方针是，通过提高开拓 出产力和运行时机能，让项目从中得到庞大的长处，并改进测试范畴和应用措施 质量。人们常常将 Spring 描写为一种轻量级的容器情况，但越发得当的比喻或 许是 “能简化开拓的框架“。Apache Tuscany开源 Apache Tuscany 项目致力 于实现 SCA 类型（和一些其他的SCA 类型，如 Service Data Objects 和 Data Access Service）。依照 Open Service-Oriented Architecture (OSOA) 和针 对全球信息社会 (OASIS SCA Java) 类型的一些尺度，Apache Tuscany 为 SCA 运行时提供了一个全面的基本架构。本文中的示例将利用 Apache Tuscany V1.5 ，它是截至本文撰写时的最新版本。要运行示例应用措施，需要 下载 Apache Tuscany SCA Java 实现的二进制刊行版。
SCA Assembly Model
SCA 的根基工件是组件，它是 SCA 的根基组成单位。组件包括一个颠末设置 的实现实例，个中，实现是提供业务成果的措施代码。业务成果将由其他组件作 为处事提供。实现有时需要依赖于其他组件提供的处事。这些依赖干系被称作 引用。
实现具有可配置的属性，它们是影响业务成果运转的数据值。组件通过为属 性提供值以及将引用关联到其他组件所提供的处事来设置实现。多个组件可以使 用和设置同一实现，而每个组件可以回收差异的方法来设置实现。
SCA 支持：
各类实现技能，好比说 Java POJOs、EJBs、Spring beans、BPEL Process、 COBOL 和 C++
一些剧本语言，好比说 PHP 和 JavaScript
一些声明式语言，好比说 XQuery 和 SQL
#p#分页标题#e#
SCA 在一种被称作复合集（composites） 的荟萃中描写应用措施的内容和关 联，如图 1 所示。复合集可以包括组件、处事、引用、属性声明以及这些元素 之间的关联描写。复合集可以分组和链接回收差异实现技能构建的组件，从而允 许在各业务任务中回收适当的技能。复合集将陈设在 SCA 域中。
图 1. SCA 复合图
SCA Assembly Model 包括一系列工件，它们在复合集方面界说了 SCA 域的 设置，个中包罗处事组件以及描写组件之间的关联的相关工件。
#p#副标题#e#
SCA 与 Spring 两者相团结的优势
Spring Framework 与 SCA 回收很多沟通的设计原则。SCA 将 Spring 视为 其组件的一种实现技能。SCA Spring Component Implementation Specification 界说了如何回收这种方法来利用 Spring。
与 Spring bean 雷同，SCA 组件可以包括到其他组件所提供的处事的引用， 而且有一些属性可供设置。与 Spring 形成比拟的是，SCA 是一种跨语言的漫衍 式组件架构，它支持多种组件通信机制。通过将 Spring beans 宣布为可由其他 组件会见的处事并为 Spring beans 提供关联到其他（大概为长途）组件的处事 的引用，SCA 可以扩展 Spring 组件的成果。
要将 SCA 与 Spring 相团结，一种有效的要领是利用 Spring 来构建 “粗 粒度” 的处事组件实现，并引入到 SCA 中以便果真处事、关联处事组件以及处 理异构和漫衍式系统。SCA 可以在利用 Spring 实现的应用措施中添加一些有用 的成果，好比说：
对长途组件以及多种协议的扩展支持
支持利用不受 JVM 支持的各类编程语言来编写组件
支持 WS-Policy 针对安详性和事务等勾当指定的计策
易于测试组件是 Spring 的一项优异的特性。缺少 API 和注入技能导致您只 能利用简朴的模仿工具举办测试。SCA 在处事方面临此举办了增补，因为关于服 务组件的SCA 复合集可以利便地切换到模仿设置以举办测试。
将 Spring 应用措施界说为 SCA 组件
在 Apache Tuscany SCA 实现中，SCA 利用 Spring 作为其组件在 SCA 复合 会合的实现技能。可以将 Spring 应用措施界说为 SCA 复合会合的SCA 组件， 即 SCDL，其名目如下所示。
清单 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> 元素的位置属性可以指定方针 URI 指向某 个存档文件 (.jar) 或 方针，可能 直接指向 Spring 应用措施上下文。
以下列表给出了指定 <implementation.spring> 位置属性的方针 URI 的大概要领。
指定 Spring 应用措施上下文文件
<implementation.spring location="application-context.xml"/>
指定目次
<implementation.spring location="./spring"/>
方针 URI 将资源指定为名称为 spring 的目次，个中包括所有与 Spring 相 关的文件。META-INF/MANIFEST.MF 文件必需包括在 Spring 目次中，它利用 Spring-Context ::= <path> 名目标Spring-Context 头部指定到上下文 设置的路径。个中，path 相对付 Spring 目次。假如 MANIFEST 文件中没有 MANIFEST.MF 文件或 Spring-Context 头部，则默认行为是利用 Spring 目次下 的META-INF/spring 目次中的application-context.xml 文件成立应用措施上下 文。 指定存档文件
<implementation.spring location="spring.jar"/>
方针 URI 将资源指定为 spring.jar 存档文件，个中包括与 Spring 相关的 所有文件。META-INF/MANIFEST.MF 文件必需位于 spring.jar 存档文件中，它 利用 Spring-Context ::= <path>. 名目标Spring-Context 头部指定到 上下文设置文件的路径。个中，path 指向 spring.jar 存档中的文件。假如 MANIFEST 文件中没有 MANIFEST.MF 文件或 Spring-Context 头部，则默认行为 是利用目次 spring.jar 存档文件中 META-INF/spring 目次下的application- context.xml 文件成立应用措施上下文。
基于 Spring 的SCA 组件
组件实现的业务成果将由其他组件作为处事 提供。实现可以依赖其他组件提 供的处事；这些依赖干系被称作引用。实现可以有可配置的属性，即影响业务功 能运转的数据值。下面的例子展示了如何将 Spring beans 提供为 SCA 处事， 以及如安在您的Spring 应用措施上下文中设置 SCA 引用和 SCA 属性。
示例
#p#分页标题#e#
我们以图 2 中的CalculatorComponent 为例。它需要依赖其他组件 （AddComponent、SubtractComponent、MultiplyComponent 和 DivideComponent）来实现所需的成果。在本例中，CalculatorComponent 的业 务成果是利用 Spring beans 实现的，AddComponent 是利用 JavaScript 实现 的，SubtractComponent 和 MultiplyComponent 是利用简朴 POJO 实现的，而 DivideComponent 是利用 Groovy 剧本实现的。
图 2. 基于 Spring 的CalculatorComponent
下一步是建设一个名称为 calculator.composite 的SCA 复合集（如清单 2 所示）来界说组件、处事、引用、属性声明以及这些元素之间的关联描写。具体 信息请拜见 下载 小节。
清单 2. 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">
<component name="CalculatorComponent">
<implementation.spring location="META-INF/spring/calculator- context.xml"/>
<service name="CalculatorService">
<interface.java interface="calculator.CalculatorService"/>
<t:binding.rmi host="localhost" port="8099"
serviceName="CalculatorRMIService"/>
</service>
<reference name="addService" target="AddComponent" />
<reference name="subtractService" target="SubtractComponent" />
<reference name="multiplyService" target="MultiplyComponent"/>
<reference name="divideService" target="DivideComponent" />
</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>
calculator.composite 利用 <reference> 元素界说 CalculatorComponent 与其他四个处事之间的依赖干系，好比说 AddComponent 、SubtractComponent、MultiplyComponent 和 DivideComponent。它们是利用 差异技能实现的。AddComponent 提供 addService 实现，用于返回两数之和。 同样，SubtractComponent 提供 subtractService 实现，用于返回两数之差。 MultiplyComponent 提供 multiplyService 实现，用于返回两数之积。 DivideComponent 则提供 divideService 实现。
您大概留意到在 calculator.composite 中，AddComponent、 SubtractComponent、MultiplyComponent 和 DivideComponent 并未利用 <service> 元素明晰果真任那里事（回收这种方法，本示例声明为 CalculatorComponent 果真了 CalculatorService）。这样，当您的SCA 组件未 利用 <service> 元素明晰果真任那里事时，则 SCA 运行时默认会利用 binding.sca 绑定果真您的组件。同样，在 CalculatorComponent 中，您不必 为这些组件引用指定任何详细的绑定信息。SCA 运行时提供了默认的 binding.sca 绑定，用于关联各组件。有关 binding.sca 的具体信息，请参阅 SCA Assembly Model Specification。
在本例中，CalculatorComponent 是一个 Spring 应用措施，它利用 Spring beans 界说了业务逻辑。在您的Spring 应用措施上下订亲义文件中声明所需的 SCA 依赖干系很是重要。
建设一个名称为 calculator-context.xml 的Spring 应用措施上下订亲义文 件。如清单 3 所示，通过声明实现所需成果需要的beans 以及它们的依赖干系 ，提供了 CalculatorComponent 的业务逻辑。
清单 3. calculator-context.xml
#p#分页标题#e#
<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="add" ref="addService"/>
<property name="subtract" ref="subtractService"/>
<property name="multiply" ref="multiplyService"/>
<property name="divide" ref="divideService"/>
</bean>
</beans>
在 calculator-context.xml 中，calculator bean 通过将所需的依赖干系 配置为属性界说了 CalculatorComponent 的业务逻辑。对付 Spring bean 来说 ，每个属性都是对要配置的值的实际界说，或容器中另一个 bean 的引用。在本 例中，calculator bean 依赖于复合会合的组件所提供的各类 SCA 处事，因此 应该将属性配置为引用（配置 ref 属性的值）calculator.composite 中界说的 SCA 引用。由于方针是将 CalculatorComponent 果真为处事，因此还应声明需 要为 calculator.composite 中界说的SCA 处事果真哪些 bean。
Spring 组件实现类型和 Apache Tuscany SCA 运行时答允您将 SCA 引用和 属性声明为 bean 属性。您还可以声明被显式或隐式地果真为 SCA 处事的bean ，如下所述。
声明明式 SCA 处事、引用和属性
SCA Spring Component Implementation Specification 和 Apache Tuscany SCA 运行时答允您利用 Spring SCA 模式中的自界说 SCA 名称空间元素在 Spring 应用措施上下文文件中声明 SCA 处事、引用和属性。您可以利用自界说 SCA 名称空间元素将 Spring beans 声明为 SCA 处事，并通过 SCA 组件界说指 定到所获取的SCA 处事和属性的引用。利用 Spring 应用措施上下文文件中的 SCA 名称空间元素被称作 SCA 处事、引用和属性的显式声明。
用于在应用措施上下文文件中声明 SCA 处事、引用和属性的自界说 SCA 名 称空间将在下面具体接头。
<sca:service> 答允您节制需要将哪些 Spring bean 果真为 SCA 服 务。为您提供一种方法来节制将哪些 Spring bean 果真为 SCA 处事。SCA 运行 时认真建设符合的处事器绑定，按照 SCDL 设置将需要的计接应用到这些处事上 。<sca:reference> 为您提供一种方法来声明 Spring 应用措施上下文对 复合会合的其他 SCA 组件所提供的处事的依赖干系。该 SCA 运行时认真建设合 适的引用绑定，按照 SCDL 设置将需要的计接应用到这些处事上。 <sca:property> 为您提供一种方法来声明 Spring 应用措施上下文对由 SCA 组件实现提供的可配置属性的依赖干系。<sca:property> 元素的 name 属性应该在复合会合拥有一个与所含组件相匹配的SCA 属性。
在 calculator-context.xml（在 清单 3）中利用自界说名称空间元素声明 SCA 处事、引用和属性，如下所示。
清单 4. calculator-context.xml
<beans xmlns="http://www.springf
ramework.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"
> <sca:service
name="CalculatorService" type="calculator.CalculatorService" target="Calculator"/>
<bean id="Calculator" class="calculator.
CalculatorServiceImpl">
<property name=
"add" ref="addService"/>
<property name=
"subtract" ref="subtractService"/>
<property name=
"multiply" ref="multiplyService"/>
<property name=
"divide" ref=
"divideService"/>
</bean>
<sca:reference name=
"addService" type=
"calculator.AddService"/>
<sca:reference name=
"subtractService" type="calculator.SubtractService"/>
<sca:reference name=
"multiplyService" type="calculator.MultiplyService"/>
<sca:reference name=
"divideService" type=
"calculator.DivideService"/>
</beans>
#p#分页标题#e#
如清单 4 所示，<sca:service> 元素声明提供 CalculatorService 作为来自方针 calculator bean 的SCA 处事。必须的name 属性拥有的值应该与 在 calculator.composite 中为 CalculatorComponent 界说的<service> 元素的名称沟通。必须的type 属性应该将处事范例声明为一个 Java 类的完全 限命名。必须的target 属性应该拥有应用措施上下文中的一个 <bean/> 元素的名称，该元素提供由此 <sca:service> 元素声明的处事。
清单 4 中的<sca:reference> 元素声明此应用措施上下文对由复合集 中其他可用的SCA 组件提供的处事的依赖干系。在本示例中，calculator bean 依赖于 SCA 处事，好比 AddComponent、SubtractComponent、 MultiplyComponent 和 DivideComponent。这些依赖干系利用 <sca:reference> 元素举办声明。此元素的必须 name 属性拥有的值应该 与在 calculator.composite 中为 CalculatorComponent 界说的 <reference> 元素的名称沟通。必须的type 属性应该将处事的范例声明 为一个 Java 类的完全限命名。对付 calculator.composite 的 CalculatorComponent 中的每个 <reference> 元素，会在 Spring 应用 措施上下文中声明一个等效的<sca:reference> 元素。
雷同地，<sca:property> 元素答允您声明此应用措施上下文对 calculator.composite 中的CalculatorComponent 提供的SCA 属性的依赖干系 。必须的name 属性拥有的值应该与 calculator.composite 中为 CalculatorComponent 界说的<property/> 元素名称沟通（如 清单 2 中 所示）。必须的type 属性应该将属性范例声明为一个 Java 类的完全限命名。
声明隐式的SCA 处事、引用和属性
SCA Spring Component Implementation Specification 和 Apache Tuscany SCA 运行时支持直接在 Spring 应用措施上下文文件中声明 SCA 处事、引用和 属性，无需利用在 Spring SCA 模式中界说的任何自界说 SCA 名称空间元素。 在 Spring 应用措施上下文文件中直接利用 SCA 引用和属性（无需自界说 SCA 名称空间）称为 SCA 处事、引用和属性的隐式声明。清单 3 中的calculator- context.xml 是一个例子。
在 calculator.composite 文件中界说的具有 addService、 subtractService、multiplyService 和 divideService 等名称的SCA 引用（参 见 清单 2）可以直接用作 Spring 应用措施上下文中的bean 引用（如 清单 3 所示）。calculator bean 属性可以配置为利用 SCA 引用名直接引用（配置 ref 属性的值）在 calculator.composite 中界说的SCA 引用（清单 2）。在这 种环境下，bean 引用的范例将由 Tuscany 运行时从 bean 类界说中举办内省（ introspect），以验证它并将它与在复合会合界说的SCA 应用范例相匹配。
雷同地，在 SCA 复合会合界说的SCA 属性可以直接用作 Spring 应用措施上 下文中的bean 引用。将 bean 属性配置（配置 ref 属性的值）为利用 SCA 属 性名称引用在 calculator.composite 中界说的SCA 属性。
当应用措施上下文中没有显式的<sca:service> 元素时，所有顶级的 bean 都将被果真为 SCA 处事，利用 bean 名称作为处事名称。任何内部 bean 或抽象 bean 都不会被用于隐式处事建设。当 Spring bean 实现类实现多个接 口时，这些 bean 可以被果真为单个或多个处事。您利用显式的 <sca:service> 元素，个中每个 <sca:service> 元素引用沟通的 <bean> 元素，但 type 属性仅利用由 bean 提供的接口之一。在隐式创 建处事时，bean 被果真为单一处事，要领是将 bean 类自己声明为处事的一个 接口。
尽量 Apache Tuscany SCA 运行时支持利用隐式 SCA 处事、引用和属性，但 也有一些场景不适合利用隐式声明。
场景 1. 为荟萃利用隐式 SCA 引用和属性
在 Spring 中，<list/>、<set/>、<map/> 和 <props/> 元素答允别离界说和配置 Java Collection 范例 List、Set、 Map 和 Properties 的属性和参数。清单 5 中的示例 bean 界说演示了在 Spring 的<list/>、<set/> 和 <map/> 元素中利用隐式 SCA 引用和属性的范围性。
清单 5. 荟萃的隐式 SCA 引用
#p#分页标题#e#
<bean id="moreComplexObject" class="example.ComplexObject">
<!-- results in a setSomeList(java.util.List) call -->
<property name="someList">
<list>
<value>a list element followed by a reference</value>
<ref bean="mySCAReference1" />
</list>
</property>
<!-- results in a setSomeMap(java.util.Map) call -->
<property name="someMap">
<map>
<entry>
<key>
<value>an entry</value>
</key>
<value>just some string</value>
</entry>
<entry>
<key>
<value>a ref</value>
</key>
<ref bean="mySCAReference2" />
</entry>
</map>
</property>
<!-- results in a setSomeSet(java.util.Set) call -->
<property name="someSet">
<set>
<value>just some string</value>
<ref bean="mySCAReference3" />
</set>
</property>
</bean>
假设名为 someList 的bean 属性的bean 实现被界说为清单 6 的内容。List 被声明为泛型，以吸收其荟萃中任何范例的Java 类。
清单 6. someList 属性的bean 实现
private
List<?> someList;
public List<?> getSomeList() {
return someList;
}
public
void setSomeList(List<?> someList) {
this.someList = someList;
}
在此场景中，Apache Tuscany 运行时无法内省此荟萃所需的SCA 引用工具的 精确范例（范例 mySCAReference1、mySCAReference2 和 mySCAReference3）。 必须的SCA 引用注入将失败。当 someMap 和 someSet 属性被声明为接管其荟萃 中任何范例的Java 类时，沟通的法则也合用于它们。发起您老是显式地利用 <sca:reference> 元素声明 SCA 引用，并在这类场景中利用必须的name 和 type 属性。
场景 2. 为结构函数注入利用隐式 SCA 引用和属性
Spring 中的结构函数注入答允您通过类结构函数注入依赖干系。为了淘汰潜 在的歧义，Spring 发起只要在 bean 实现中界说了多个结构函数，就为 <constructor-arg> 元素适当利用 index 和 type 属性。
Tuscany 还发起为 <constructor-arg> 元素利用 index 和 type 属 性，为所有结构函数注入场景显式声明相关的SCA 引用，纵然 bean 只有一个构 造函数。
譬喻，假设您想要利用结构函数为 calculator bean 注入必须的依赖干系（ 必须的SCA 引用）。您应该像清单 7 所示的那样界说 bean。在 Tuscany 中， 不支持为结构函数利用隐式 SCA 引用和属性。
清单 7. 针对 calculator bean 的结构函数注入
<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">
<constructor-arg index="0" type="calculator.AddService" ref="addService"/>
<constructor-arg index="1" type="alculator.SubtractService"
ref="subtractService"/>
<constructor-arg index="2" type="calculator.MultiplyService"
ref="multiplyService"/>
<constructor-arg index="3" type="calculator.DivideService" ref="divideService"/>
</bean>
<sca:reference name="addService" type="calculator.AddService"/>
<sca:reference name="subtractService" type="calculator.SubtractService"/>
<sca:reference name="multiplyService" type="calculator.MultiplyService"/>
<sca:reference name="divideService" type="calculator.DivideService"/>
</beans>
SCA 运行时中的应用措施上下文建设
#p#分页标题#e#
在 Spring 中，主要的模块单位是应用措施上下文，它包括必然数量的bean （由 Spring 应用措施上下文打点的工具）。应用措施上下文可以在一个分层结 构中设置，在个中，子应用措施上下文可以看到父应用措施上下文中界说的bean ，但反之则不可。
默认环境下，Spring 容器在建设容器时验证每个 bean 的设置，包罗验证 bean 引用是否实际引用了有效的bean。对付包括对 SCA 引用和属性的引用的 Spring 应用措施上下文，为在 Spring 应用措施上下文中利用的所有 SCA 引用 和属性建设有效 bean 是 SCA 运行时的职责。然后，Spring 容器可以验证 bean 并乐成加载应用措施上下文。图 3 给出了一个示例。
图 3. 具有父上下文的SCA 运行时
Tuscany 运行时利用 Spring Binary V2.5.5 加载和运行方针应用措施上下 文，这些上下文在 <implementation.spring> 元素的location 属性中指 定，而该元素在 calculator.composite 文件中界说（如 清单 2 所示）。在加 载方针应用措施上下文之前，Tuscany 运行时实验：
内省方针应用措施上下订亲义文件，确定在 Spring 应用措施上下文中声明 的SCA 处事、引用和属性。
利用符合的Spring bean，为在方针应用措施上下文中声明的所有 SCA 引用 属性建设一个 SCAParentApplicationContext。
在上面的示例中，利用符合的Spring bean 为在 calculator-context.xml 文件中声明的所有 SCA 引用（好比 addService、subtractService、 multiplyService 和 divideService）建设了一个 SCAParentApplicationContext（拜见 图 3）。随后，利用 org.springframework.context.support.GenericApplicationContext 建设方针 应用措施上下文，将 SCAParentApplicationContext 声明为它的父上下文。
Tuscany 运行时还提供了须要的基本设施来建设符合的处事绑定，按照 SCDL 设置，为利用 Spring bean 实现的这些处事提供必须的计策。
竣事语
本文先容了如何利用基于 Spring 的应用措施设计和开拓 SCA 组件。您此刻 可以利用自界说 SCA 名称空间元素，在 Spring 应用措施上下文中显式声明 SCA 处事、引用和属性，可以在 Spring 应用措施上下文中直接声明 SCA 引用 和属性。您相识了 SCA 运行时如作甚 SCA 组件建设方针应用措施上下文。借助 示例，本文简短先容了在应用措施上下文中利用隐式 SCA 引用和属性的范围性 。
SCA 和 Spring 可以或许组成一个强大的组合。Spring 提供了基本设施来开拓具 有更高效率和运行时机能的组件，还改造了测试包围率和应用措施质量。SCA 提 供了须要的基本设施来组装和建模基于 SOA 的组件，支持组件果真处事，将服 务组件毗连在一起，以及处理惩罚异构的漫衍式系统。
敬请等候第 2 部门的推出，第 2 部门将先容一些高级特性，好比利用 SCA 处理惩罚多种应用措施上下文，在 Spring bean 中利用 SCA 注释。
本文配套源码
