使用 Spring Framework 设计和开发 SCA 组件，第 2 部分: 使用 Apache Tuscany 的高级技巧

组合多种应用程序上下文

打印本页

将此 页作为电子邮件发送

样例代码

英文原文

级 别： 初级

Ramkumar Ramalingam, 软件开发人员, IBM

2010 年 2 月 04 日

在 “使 用 Spring Framework 设计和开发 SCA 组件” 系列文章中，学习如何有效结合服务组件架构（Service Component Architecture，SCA）与 Spring Framework 来创建分布式服务应用程序。本文将探讨 Apache Tuscany 运行时所支持的高级特性。了解如何结合多种应用程序上下文实现 SCA 组件。我们将通过一个例子向您展示用来在 Spring bean 类中显式声明 SCA 服务、引用和属性的所有 SCA 注释。

简介

本系列的 使用 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 所示。

                        "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">                        "CalculatorServiceComponent">                        "targetURI"/>                                                                        

元素的 location 属性可将目标 URI 指定为指向一个归档文件（JAR）、一个目录或直接指向一个 Spring 应用程序上下文文件。在任何情况下，在使用 组件的 location 属性时，Apache Tuscany 只允许一个应用程序上下文作为目标应用程序上下文，用作 SCA 组件的实现。

Apache Tuscany 允许使用多种应用程序上下文来实现 SCA 组件，方法是在这个目标应用程序上下文（由此 SCA 复合集文件内的 元素的 location 属性标识）中定义一个 ClassPathXmlApplicationContext（如 清 单 3 所示）bean。清单 2 给出了一个示例。

                        "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">                        "CalculatorServiceComponent">                        "beanRefContext.xml"/>                                                                        

                        "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">                                                                                                context1.xml                        context2.xml                        context3.xml                                                                                                                        

这个 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 服务、引用和属性（以显式或隐式的方式声明）。

对于一个单应用程序上下文的场景，正如在 使用 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 名称空间元素，比如 、 和 ，在 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。

                        "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">                        CalculatorComponent">                                                "localhost" port="8099" serviceName="CalculatorRMIService"/>                                                "CalculatorComponent">                        "META-INF/spring/calculator-context.xml"/>                        "addService" target="AddComponent" />                        "subtractService" target="SubtractComponent" />                        "multiplyService" target="MultiplyComponent"/>                        "divideService" target="DivideComponent" />                        HelloWorld                                                "AddComponent">                        "calculator/AddServiceImpl.js"/>                                                "SubtractComponent">                        "calculator.SubtractServiceImpl"/>                                                "MultiplyComponent">                        "calculator.MultiplyServiceImpl"/>                                                "DivideComponent">                        "calculator/DivideServiceImpl.groovy"/>                                                                        

在这个例子中，CalculatorComponent 是一个 Spring 应用程序，它定义了使用 Spring bean 的业务逻辑。创建一个名为 calculator-context.xml 的应用程序上下文文件，如清单 5 所示，它通过将所需的依赖项设置为 bean 属性定义了 CalculatorComponent 的业务逻辑。

                        "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">                        "Calculator" class="calculator.CalculatorServiceImpl">                        "addService" ref="addService"/>                        "subtractService" ref="subtractService"/>                        "multiplyService" ref="multiplyService"/>                        "divideService" ref="divideService"/>                                                                        

在 使用 Spring Framework 设计和开发 SCA 组件，第 1 部分：三剑客：Spring、SCA 和 Apache Tuscany， 您了解到自定义 SCA 名称空间元素，比如 、 和 ，可用于在这个应用程序上下文文件内（参见清 单 5）显式声明 SCA 服务、引用和属性。在本文中，您又了解了 SCA 注释是如何在 CalculatorServiceImpl bean 类内用作一种显式声明 SCA 服务、引用和属性的备选方式。清单 6 给出了一个示例。

                        @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 复合集内都应该定义一个对等的 元素（如 清 单 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 让您的组件能够公开服务，将服务组件连接在一起，以及处理异构的分布式系统。

下载

参考资料

• 查阅 Apache Tuscany 的相关信息，它是一个综合性基础设施，适用于基于 SCA 标准的 SOA 开发和管理。
  
  
• 了 解 Spring Framework 的所有相关信息。
  
  
• 了解关于 Open Service-Oriented Architecture (OSOA) 项目的更多信息。
  
  
• 了解 OASIS SCA Java，一个开放 SCA 技术委员会。OASIS 推动了开放标准。
  
  
• 阅读 SCA Assembly Model Specification（关于 SCA 组合模型的 OSOA 规范）。
  
  
• 从 SCA Spring Component Implementation Specification（有关 SCA Spring 组件实现的 OSOA 规范）了解更多信息。
  
  
• 了解 Spring SCA 模式， 这是关于 SCA Spring Component Implementation 实现的 OSOA 规范的一部分，主要介绍在 Spring 中声明 SCA 元素。
  
  
• SCA Java Common Annotations and APIs Specification 定义了可在某个 SCA 组件（用 Java 语言编写）的实现内使用的注释和 API。其中的一些 API 还可用在由 SCA 组件提供的那些服务的客户代码内。
  
  
• 要收听针对软件开发人员的有趣访谈和讨论，请访问 developerWorks 播客。
  
  
• 随 时关注 developerWorks 技术活动和网络广播。
  
  
• 查阅最近将在全球举办的面向 IBM 开放源码开发人员的研讨会、交易展览、网络广播和其他 活动。
  
  
• 访问 developerWorks Open source 专区 获得丰富的 how-to 信息、工具和项目更新以及 最 受欢迎的文章和教程，帮助您用开放源码技术进行开发，并将它们与 IBM 产品结合使用。
  
  
• My developerWorks 涵盖了大量主题，是一个成功社区的典范。
  
  
• 查看免费的 developerWorks 演示中心，观看并了解 IBM 及开源技术和产品功能。
  
  

• 使用 IBM 产品评估试用版软件 改进您的下一个开发项目，这些软件可以通过下载获得。
  
  
• 下载 IBM 产品评估试用版软件 或 IBM SOA Sandbox for Reuse，使用来自 DB2®、Lotus®、Rational®、Tivoli® 和 WebSphere® 的应用程序开发工具和中间件产品。

• 访问 developerWorks 博客 并加入 developerWorks 社区。
  
  

关于作者

Ramkumar Ramalingam 在印度班加罗尔的 IBM India Software Labs 担任高级软件工程师。他是 Apache Tuscany 的提交者，以及 Apache Tuscany 项目管理委员会的成员。他还是 OASIS SCA Java Specification Community 的一名成员。