Apache Tuscany SCA 用户指南

介绍

这篇用户指南帮助你熟悉SCA概念，并且带你浏览示范怎样创建SCA 应用的一个例子。它也说明了Tuscany支持的多种不同环境（例如命令行客户端或Web应用）以及如何打包程序以运行在这行环境中。

本说明或许不需要，因为创建一个SCA应用很简单。Tuscany和SCA的主要目的之一是，避免强加的规则和要求，以制约如何去编写应用。我们想让程序员在开发应用的时候，不用担心将要被使用的环境。基本上，你是为了兴趣而写代码，Tuscany提供环境让它运行。因此，本指南只是一个例子，说明怎样开发SCA应用，而不是一个规则。

SCA快速指南

SCA快速指南给你做SCA概念的概述，并且为下面的例子给你打好基础。如果你已经熟悉SCA，请略过次章。

例子概要 
我们将使用这个计算示例如何开发一个SCA 应用。 顾名思义，这个例子是实现典型的计算操作。典型操作就是给两个数字被要求对这两个数字进行一些操作，我们的计算程序将能处理加减乘除四则运算。

我们开始于一个简单的计算程序并会逐渐的扩展一些高级SCA特性。 

对于SCA的更多细节，请参考相关规范，打开SCA网站。

准备

• 下载Tuscany Java SCA release
• 下载必要的：
  • Java 5
  • Maven 2.0.4+ 或者 Ant 1.7.0

运行示例

Calculator 程序随着SCA二进制包一起分发，在我们开始编写它之前先运行一下示例，很简单！

• 到../samples/calculator 目录
  
  ant run
• 如果你打算直接使用命令行来执行例程，那么使用以下的命令
  
  java  - cp ....lib uscany - sca - manifest.jar;targetsample - calculator.jar calculator.CalculatorClient

一切正常的话，你将会得到以下结果：

3 + 2=5.0
3 - 2=1.0
3 * 2=6.0
3 / 2=1.5

如果你使用的是源代码分发包的话，我们建议你使用Maven构建并运行这个计算器实例，因为tuscany-sca-manifest.jar 是不随源代码分发包一起提供的，它是包含在二进制分发包内，它包含了全部的tuscany的jar包，这样可以让运行实例的命令行漂亮且比较短。

构建Calculator实例

你将学到的

这个例子说明，当你集中于业务逻辑的时候，如何定义你的程序。本教程会带你通过一系列步骤构建一个叫做calculator的集成构建应用，在这个集成应用中所有组件间的连接器都是本地的，使用java定义的接口。

实例通览

步骤1：定义所需要的功能块：考虑下你的应用如何被分解为一个个较小的功能/服务，每个块都是一个可以在总的应用里使用的逻辑操作单元，这样的话，Calculator应用可以被分为五个功能块：AddService（加）、SubstractService（减）、MultiplyService（乘）、DivideService（除）和一个主功能块，起接收请求并引导到正确操作的控制器的作用。我们可以叫这个控制器为CalculatorService。

步骤2：实现每个功能块：既然你已经识别了应用中的功能块，现在将准备创建它们。在SCA里，功能性的块称为组件，那么让我们看看如何去实现一个组件。我们将把AddService组件作为我们的第一个例子。

AddService组件将提供两数相加的服务。每当执行相加操作的时候，CalcualtorService组件就会使用AddService组件。如果我们使用java来编写AddService组件的话，我们从描述一个（Java）接口开始。

public   interface  AddService {

     double  add( double  n1,  double  n2);
}

现在，我们提供这个接口的实现。

public   class  AddServiceImpl  implements  AddService {

     public   double  add( double  n1,  double  n2) {
         return  n1  +  n2;
    }
}

等等！我们不是在写一个SCA组件么？那一定是很复杂的，仅仅只有Java接口和实现，这是对的么？嗯，实际上一个SCA组件可以是一个普通的Java，因此我们已经做完了实现这个SCA AddService组件所需要的编码。我们能使用SCA暴露AddService组件在任何支持的绑定上提供服务，例如，WebServices，JMS或者RMI，

不需要更改AddService的实现。

让我们看一下CalculatorService组件，这很有趣因为它会调用AddService组件，在完整应用中，它会调用SubtractService、MultiplyService以及DivideService 组件，但我们目前会忽略其他的，因为它们和我们实现的AddService是一个模式。

我们将再次从定义一个接口开始，因为CalcultorService是一个自身提供给其他程序调用的接口。

public   interface  CalculatorService {

     double  add( double  n1,  double  n2);
     double  subtract( double  n1,  double  n2);
     double  multiply( double  n1,  double  n2);
     double  divide( double  n1,  double  n2);
}

现在，我们实现这个接口。

public   class  CalculatorServiceImpl  implements  CalculatorService {

     private  AddService addService;
     private  SubtractService subtractService;
     private  MultiplyService multiplyService;
     private  DivideService divideService;
   
    @Reference
     public   void  setAddService(AddService addService) {
         this .addService  =  addService;
    }

    ...set methods  for  the other attributes would go here

     public   double  add( double  n1,  double  n2) {
         return  addService.add(n1, n2);
    }

    ...implementations of the other methods would go here
}

步骤3：组装应用：那么，我们该如何让这两个组件运行呢？我们当中的Java程序员说了，写一个main函数，然后就可以将两个组件联系到一起然后运行，这样做很简单。

public   class  CalculatorClient {
     public   static   void  main(String[] args)  throws  Exception {

        CalculatorServiceImpl calculatorService  =   new  CalculatorServiceImpl();
        AddService            addService         =   new  AddServiceImpl();
        calculatorService.setAddService(addService);
      
        System.out.println( " 3 + 2= "   +  calculatorService.add( 3 ,  2 ));
         //  calls to other methods go here if we have implemented SubtractService, MultiplyService, DivideService
    }
}

但这样做，没有使用Tuscany SCA运行时，也没有将代码延展至提供Webservice接口，那样的话，会稍微复杂些。那么，我们怎样做可以让它运行在Tuscany内，可以得到很多像自由提供Webservice那样的特性?首先，在我们调用这些组件前，先改变客户端以启动Tuscany SCA运行时。

public   class  CalculatorClient {
     public   static   void  main(String[] args)  throws  Exception {

        SCADomain scaDomain  =  SCADomain.newInstance( " Calculator.composite " );
        CalculatorService calculatorService  =  scaDomain.getService(CalculatorService. class ,  " CalculatorServiceComponent " );

        System.out.println( " 3 + 2= "   +  calculatorService.add( 3 ,  2 ));
         //  calls to other methods go here if we have implemented SubtractService, MultiplyService, DivideService

        scaDomain.close();
    }
}

你可以看到我们从使用静态方法创建一个SCADomain自身实例开始。SCADomain是一个SCA概念，表示一个SCA系统的边界。它可以跨很多处理器部署，现在，让我们先关注它与在单Java虚拟机内运行。

参数"Calculator.composite"指的是告诉SCA 这些组件在我们计算器应用内如何集成工作的一个XML 文件。这里是Calculator.composite内的XML。

< composite  xmlns ="http://www.osoa.org/xmlns/sca/1.0"
           name ="Calculator" >

     < component  name ="CalculatorServiceComponent" >
     < implementation .java class ="calculator.CalculatorServiceImpl" />
         < reference  name ="addService"  target ="AddServiceComponent"   />
        
     component >

     < component  name ="AddServiceComponent" >
         < implementation .java class ="calculator.AddServiceImpl" />
     component >

    

composite >

可以看到我们在这里定义了两个组件并且指定了Tuscany SCA需要加载去实现业务计算的Java实现类。它们是我们刚刚实现的那些类。

需要注意的是，CalculatorServiceComponent拥有一个对addService的引用，在这个XML配置文件里，这个引用目标是AddServiceComponent。当我们实现CalculatorServiceImpl时，引用名字"addService"，与我们建立的addService 领域的名字相配，这不是巧合。Tuscany SCA运行时从Xml配置文件解析这些信息，并且用来创建描述我们calculator应用程序的对象和关系。它首先创建了AddServiceImpl 和CalcualtorSreviceImpl的实例，然后将AddServiceImpl引用注入到CalculatorServiceImpl对象的addService字段域。如果你回过头来看下我们如何实现的CalculatorService，你会发现@Reference注释，它告诉SCA哪些字段/域需要被自动设置。这相当于来自我们正常的Java客户端代码。

CalculatorServiceImpl calculatorService  =   new  CalculatorServiceImpl();
        AddService            addService         =   new  AddServiceImpl();
        calculatorService.setAddService(addService);

一旦配置文件被SCADomain加载，我们的客户端代码就会要求SCADomain提供CalculatorServiceComponent组件的对象实例引用。

CalculatorService calculatorService  =  scaDomain.getService(CalculatorService. class ,  " CalculatorServiceComponent " );

我们现在使用这个引用就好像是我们自己创建的一样，例如，来自于CalculatorServiceImpl.add()方法实现：

return  addService.add(n1, n2);

SCA规范往往使用图解的形式描述SCA应用，这往往有利于快速的概览有说明组件组成了该应用以及如何将它们联系在一起，如果我们画一张我们刚刚创建的calculator例子的图，我们会得到如下类似的图：

 你会发现这些图随我们所有的示例提供。如果你喜欢使用一种可视化的角度去看图的话，这就帮助你快速理解各个例子中的组件。可以看一下每个例子的顶级目录的那些".png" 文件。

步骤4：部署应用：只要"Calculator.composite"文件和其他的tuscany jar包一起,存在于classpath内，我们就可以像之前做的那样运行我们的例子。这些例子包含一个Ant部署文件build.xml，所以，如果你想测试例子代码的话，你可以如此做并重编译它。

ant compile

重新编译以后，你可以像在“运行示例”章节那样运行它，我们还在Ant的build.xml脚本里面提供了一个run target以供运行，你可以这样：

ant  run

 在calculator内使用更多高级特性

回顾以下，我们编写的启动calculator应用的代码，使用的Tuscany SCA运行时不比使用普通java代码更长，然而，我们现在确实有一个XML集成配置文件，描述我们的应用如何被组装。

但我们的应用变得更复杂，并且我们想要改变它，重用它，和其他应用集成或者使用一个和我们其他SCA应用一致的编程模型进一步开发它的时候，集成的概念就是一个很大的优势。而不管它们是用说明语言实现的。

举个例子，我们认为我们的计算器示例足够强大和易用，我们打算将它放在公司内部网，以供其他人使用他们基于Web2.0的程序，通过浏览器进行直接访问，这个时候我们通常会找书本以努力寻找实现它的办法，因为我们有一个描述我们应用的XML文件，这在Tuscany很容易。如下内容应该达到目的。

< composite  xmlns ="http://www.osoa.org/xmlns/sca/1.0"
           name ="Calculator" >

      < service  name ="CalculatorService"  promote ="CalculatorServiceComponent/CalculatorService" >
          < interface .java interface ="calculator.CalculatorService" />
          < binding .jsonrpc />
      service >     

     < component  name ="CalculatorServiceComponent" >
         < implementation .java class ="calculator.CalculatorServiceImpl" />
         < reference  name ="addService"  target ="AddServiceComponent"   />
        
     component >

     < component  name ="AddServiceComponent" >
         < implementation .java class ="calculator.AddServiceImpl" />
     component >

    

composite >

我们所做的就是增加元素，告诉Tuscany SCA如何暴露CalculatorServiceComponent作为一个JSONRPC服务。注意，我们不需要更改我们组件的Java代码。这只是配置上的一个改变。 helloworld-jsonrpc 示例展示了一个jsonrpc绑定的工作例子。

如果我们需要一个基于SOAP/HTTP 的WebService也很容易，helloworld-ws-service 和helloworld-ws-reference 两个例子展示了如何使用Webservice。

SCA允许其他方式的灵活性。我们可以重新连接我们的组件，例如，使用其中一个远超绑定，比如RMI，我们可以让运行在一台机器上的CalculatorServiceCompone连接到另一台机器上运行的远端版本应用，calculator-rmi-service 和 calculator-rmi-reference 展示了如何使用RMI绑定的方法。

我们也能引进用不同的语言实现的组件，例如，让我们增加Ruby实现的SubtractServiceComponent组件。

< composite  xmlns ="http://www.osoa.org/xmlns/sca/1.0"
           name ="Calculator" >

     < component  name ="CalculatorServiceComponent" >
         < implementation .java class ="calculator.CalculatorServiceImpl" />
         < reference  name ="addService"  target ="AddServiceComponent"   />
         < reference  name ="subtractService"  target ="SubtractServiceComponent"   />
        
     component >

     < component  name ="AddServiceComponent" >
         < implementation .java class ="calculator.AddServiceImpl" />
     component >

     < component  name ="SubtractServiceComponent" >
         < implementation .script script ="calculator/SubtractServiceImpl.rb" />
     component >

    

composite >

当然，我们需要Ruby代码去实现它：

def  subtract(n1, n2)
     return  n1  -  n2
end

Tuscany SCA运行时处理了Java组件连接到Ruby组件的问题，并且进行了必要的数据转换，calculator-script 示例展示了不同语言的使用。

那么，既然我们的应用程序已经作为SCA装配，那么将来当我们进一步开发它的时候就存在许多的可能性，并且和其他应用集成，接下来的章节会提供更多Tuscany SCA的细节。

创建一个在线商店（OnLineStore）SCA集成应用

既然你已经熟悉了SCA的概念，你可以利用本教程去创建一个OnLineStore集成SCA应用，给购物车提供Web接口。这个练习会花费少于半小时的时间，它使你熟悉创建一个真正的SCA集成应用的步骤。虽然这里使用了Eclipse作为IDE，但并不要求你具备Eclipse的相关知识。你可以很容易看到在你习惯的IDE里具有相似的步骤。

Tuscany SCA域的实现

你可能已经从以前例子的通览看到，SCA概述也有提到，SCA有个概念叫做Domain（域）。SCA集成规范的第10部分把SCA Domain描述为“SCA机制的视界”。SCA线路可用来在单个SCA Domain里把组件连接起来。

通过以前那个计算器例子可以看到，在组件引用和服务之间的连线，是通过添加一个目标组件名到一个引用，在一个SCA Domain里处理的。

< component  name ="CalculatorServiceComponent" >
         < implementation .java class ="calculator.CalculatorServiceImpl" />
         < reference  name ="addService"  target ="AddServiceComponent"   />
         < reference  name ="subtractService"  target ="SubtractServiceComponent"   />
         < reference  name ="multiplyService"  target ="MultiplyServiceComponent"   />
         < reference  name ="divideService"  target ="DivideServiceComponent"   />
     component >

     < component  name ="AddServiceComponent" >
         < implementation .java class ="calculator.AddServiceImpl" />
     component >

为了连接一个SCA Domain之外的服务（不管它们是以SCA提供的服务还是其他方式），你配置一个明确的绑定，例如，加入AddServiceComponent是网络上某处的非SCA的Web服务，因为它在SCA Domain之外，我们可以使用一个外部绑定去和它联系。

< component  name ="CalculatorServiceComponent" >
         < implementation .java class ="calculator.CalculatorServiceImpl" />
         < reference  name ="addService"   >
            < interface .java interface ="calculator.AddService"   />         
             < binding .ws uri ="http://localhost:8080/sample-calculator-ws-webapp/AddServiceComponent" />         
         reference >    
         < reference  name ="subtractService"  target ="SubtractServiceComponent" > reference >
         < reference  name ="multiplyService"  target ="MultiplyServiceComponent" > reference >
         < reference  name ="divideService"  target ="DivideServiceComponent" > reference >
     component >

Tuscany SCA支持在单JVM或扩展至多JVM来运行一个SCA Domain，这些JVM可能在不同的机器上。

 Tuscany不提供单个Domain或节点的Java程序。如果你看到了Tuscany提供的那些例子你会发现它们使用各种不同的方式使用SCA Domain接口，点击链接查看使用独立的SCA Domain和分布式SCA Domain接口。

Tuscany SCA扩展

可扩展的运行时

Tuscany SCA运行时包括一小组核心软件来处理：

• 管理Tuscany SCA运行时的扩展（核心）
• 构建并且在内存中集成SCA应用模型（集成）
• 处理部署的SCA应用（部署）
• 支持数据绑定（数据绑定）
• 支持Tuscany SCA，以在被嵌入其他环境时提供服务（嵌入）
• 支持Tuscany SCA，当运行在一个Servlet容器中时（HTTP）

描述这些特征的接口的集合被称为系统编程接口(SPI)。 开发者指南会从更细节来讨论它们，但从用户的视角重要的事情是意识到，Tuscay SCA中大多数有趣的功能，是基于核心SPI之上开发的扩展所提供的。这些扩展为Tuscany SCA提供了支持很多不同特性的能力。

• 实现类型
• 绑定类型
• 数据绑定类型
• 接口描述风格
• 宿主环境

因此，要理解怎样去使用Tuscay SCA运行时就是去理解怎样使用它的那些扩展。

可用的扩展

往往不能用延伸涉及加入资料到scdl文件或执行文件，但这种情况并非总是如此。下面的链接描述的每一项扩展，以及他们如何利用和配置。

实现类型
implementation.java	支持使用Java实现SCA组件	从0.90版本开始可用
implementation.script	支持使用脚本语言实现SCA组件	从0.90版本开始可用
implementation.bpel	支持使用BPEL实现SCA组件	从1.0版本开始可用
implementation.spring	支持spring	从0.91版本开始可用
implementation.resource	暴露文件资源	从0.91版本开始可用
implementation.osgi	支持osgi	从1.0版本开始可用
implementation.xquery	支持使用xquery实现SCA组件	从1.0版本开始可用
绑定协议
binding.ajax	同Ajax客户端通讯	从0.90版本开始可用
binding.jms	异步JMS消息	开发中
binding.jsonrpc	JSON-RPC 协议	从0.90版本开始可用
binding.rmi	Java Rmi 协议	从0.90版本开始可用
binding.ws	SOAP/HTTP web services	从0.90版本开始可用
binding.ejb	Ejb绑定	从0.90版本开始可用
binding.rss	使用或提供Rss feed	从0.91版本开始可用
binding.atom	支持原子发布（标准的REST协议），允许创建、恢复、更新、删除原子条目	从0.91版本开始可用
数据绑定
databinding-axiom	支持AXIOM 数据绑定	从0.90版本开始可用
databinding-jaxb	支持JAXB数据绑定	从0.90版本开始可用
databinding-sdo	支持SDO数据绑定	从0.90版本开始可用
databinding-sdo-axiom	支持优化的SDO到AXIOM 的转换	从0.90版本开始可用

使用扩展

Tuscany SCA使用Java服务装载机制加载扩展插件，每个插件被打包成一个jar包，以文件的形式提供。

META-INF/services/org.apache.tuscany.sca.core.ModuleActivator

Tuscany SCA运行时会加载Java Classpath中存在的所有扩展，所以如果你打算使用一个特别的特性要确认它在classpath中存在并可用，反之如果你不需要的话可以把它从classpath中拿掉。

写一个新扩展是一个主题并且被在扩展指南里描述。

运行环境

Apache Tuscany SCA Java 在以下主机环境中运行：

host.embedded	一个简单的嵌入式主机，从同一个classpath启动Tuscany核心和应用	从0.90版本开始可用
host-webapp	初始化Tuscany运行时以供Web程序使用	从0.90版本开始可用
http-jetty	Tuscany和Jetty web容器的集成	从0.90版本开始可用
http-tomcat	Tuscany和Tomcat web容器的集成	从0.90版本开始可用
Apache Geronimo	怎样在Geronimo中运行？	从1.0版本开始可用
Websphere Application Server	如何在WAS中运行？

 

Tuscany和IDE

使用IDE打开例子而不是Maven

我们不随分发包提供任何IDE文件，因此你需要手工导入那些例子，这里是个如何在Eclipse里导入的例子，tuscany_sca_install_dir 目录是Tuscany SCA二进制分发包解压后的文件夹，例如，对于0.90版本的目录将会是tuscany-sca-0.90-incubating。

在一个新的或者已有的工作空间：

• 创建一个新工程：
  
  my working dir / calculator
• 导入示例代码和资源到工程：
  
  从菜单File-Import命令，选择tuscany_sca_install_dir/samples/calculator 目录
• 设置源代码路径包含：
  
  tuscany_sca_install_dir/samples/calculator/src/main/java
  tuscany_sca_install_dir/samples/calculator/src/main/resources
• 配置输出路径：
  

  tuscany_sca_install_dir/samples/calculator/target

• 配置库目录：
  

  tuscany_sca_install_dir/lib

• 如果你选择calculator.CalculatorClient.java ，并且使用“Java Application”运行它，你将会看到如下结果：
  
  3 + 2=5.0
  3 - 2=1.0
  3 * 2=6.0
  3 / 2=1.5
  

对于其他开发环境与此大同小异。

参考资料：

原文：http://incubator.apache.org/tuscany/sca-java-user-guide.html

Tuscany官网：http://incubator.apache.org/tuscany/home.html