面向成功,实现梦想!

一起分享,一起成长,共创辉煌!
构客网首页  博客  论坛

 
  SOA我有话说
  本文的标签
SCA (收录6148篇)SOA我有话说 (收录167篇)SOA服务构造与实现 (收录36篇)
  用户信息
 
帐号:  新手必读
密码: 保存密码
 
  分类列表
全部类别(14 篇)
我的文章(14 篇)
  按月归档
2008年-0月(14 篇)
  SOA2007 - SOA实践
我们何时迈向SOA
——SOA在中国的整体发展现状究竟如何?
我们如何迈向SOA
——中国企业如何迈出实施SOA的第一步?
我们应采用何种技术
——SOA国际标准SCA/SDO的具体内涵?
我们还需要何种技能
——SOA将如何改变系统架构设计以及项目管理过程?

SCA Assembly Model Specification V1.0.0 中文翻译(四)

发布时间:2007年12月05日 作者:liang_ma

阅读次数:358次 类别:我的文章 永久链接 Trackback 
参加SOA我有话说

此部分描述SCA组装模型规范--1.6 构件(Composite)与1.6.1 属性(Property).一个SCA构件以逻辑分组的方式来组装SCA元素,它是一个SCA域里组合(composition)的基本单元。一个SCA 构件是一个集合,它包含组件、服务、引用以及连接它们的连线,还有一个被用来配置组件的属性集。。。

 

1.6 构件(composite

一个SCA构件以逻辑分组的方式来组装SCA元素,它是一个SCA域里组合(composition)的基本单元。一个SCA 构件是一个集合,它包含组件、服务、引用以及连接它们的连线,还有一个被用来配置组件的属性集。

构件可以在高层次的构件中形成组件实现(component implementations),即构件可以作为组件来使用。换句话说,高层次的构件可以有这样的组件,它是由构件实现的。关于构件作为组件实现的使用的更多细节参见Using Composites as Component Implementations

构件的内容可以通过inclusion在另一个构件里使用。当一个构件(如A)被其它构件(如B)包括(include)时,A的所有内容都可以在构件B中使用,也就是说,在构件B里,A的内容是完全可见的且可以被其它元素引用。参见Using Composites through Inclusion

构件可以被用来作为一个部署单元。当使用的时候,构件把元素贡献给一个SCA域。一个构件可以通过inclusion被部署到SCA域,或者作为一个实现被部署到SCA域。更多关于构件部署的细节参见处理SCA Domain的部分

构件在一个xxx.composite文件中定义。构件通过一个composite元素表示。下面的代码片段展示了composite元素的模式(schema)。

  1. <?xml version="1.0" encoding="ASCII"?>
  2. <!-- Composite schema snippet -->
  3. <composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
  4.                   targetNamespace="xs:anyURI"
  5.                   name="xs:NCName" local="xs:boolean"?
  6.                   autowire="xs:boolean"? constrainingType="QName"?
  7.                   requires="list of xs:QName"? policySets="list of xs:QName"?>
  8.  
  9.       <include name="xs:QName"/>*
  10.       <service name="xs:NCName" promote="xs:anyURI"
  11.                   requires="list of xs:QName"? policySets="list of xs:QName"?>*
  12.             <interface/>?
  13.             <binding uri="xs:anyURI"? name="xs:QName"?
  14.                         requires="list of xs:QName"? policySets="list of xs:QName"?/>*
  15.                    <callback>?
  16.                          <binding uri="xs:anyURI"? name="xs:QName"?
  17.                                           requires="list of xs:QName"?
  18.                                           policySets="list of xs:QName"?/>+
  19.                     </callback>
  20.         </service>
  21.  
  22.         <reference name="xs:NCName" target="list of xs:anyURI"?
  23.                             promote="list of xs:anyURI" wiredByImpl="xs:boolean"?
  24.                             multiplicity="0..1 or 1..1 or 0..n or 1..n"?
  25.                         requires="list of xs:QName"? policySets="list of xs:QName"?>*
  26.                 <interface/>?
  27.                 <binding uri="xs:anyURI"? name="xs:QName"?
  28.                              requires="list of xs:QName"? policySets="list of xs:QName"?/>*
  29.                        <callback>?
  30.                               <binding uri="xs:anyURI"? name="xs:QName"?
  31.                                                requires="list of xs:QName"?
  32.                                                policySets="list of xs:QName"?/>+
  33.                       </callback>
  34.         </reference>
  35.  
  36.        <property name="xs:NCName" (type="xs:QName" | element="xs:QName")
  37.                          many="xs:boolean"? mustSupply="xs:boolean"?>*
  38.               default-property-value?
  39.        </property>
  40.  
  41.        <component name="xs:NCName" autowire="xs:boolean"?
  42.                            requires="list of xs:QName"? policySets="list of xs:QName"?>*
  43.               <implementation/>?
  44.               <service name="xs:NCName" requires="list of xs:QName"?
  45.                               policySets="list of xs:QName"?>* 
  46.                        <interface/>?
  47.                        <binding uri="xs:anyURI"? name="xs:QName"?
  48.                                          requires="list of xs:QName"?
  49.                                          policySets="list of xs:QName"?/>*
  50.                         <callback>?
  51.                                  <binding uri="xs:anyURI"? name="xs:QName"?
  52.                                                   requires="list of xs:QName"?
  53.                                                   policySets="list of xs:QName"?/>+
  54.                         </callback>
  55.                </service>
  56.                <property name="xs:NCName" (type="xs:QName" | element="xs:QName")
  57.                                  source="xs:string"? file="xs:anyURI"?>*
  58.                        property-value
  59.               </property>
  60.               <reference name="xs:NCName" target="list of xs:anyURI"?
  61.                                   autowire="xs:boolean"? wiredByImpl="xs:boolean"?
  62.                                   requires="list of xs:QName"? policySets="list of xs:QName"?
  63.                                   multiplicity="0..1 or 1..1 or 0..n or 1..n"?/>*
  64.                     <interface/>?
  65.                     <binding uri="xs:anyURI"? name="xs:QName"?
  66.                                      requires="list of xs:QName"?
  67.                                      policySets="list of xs:QName"?/>*
  68.                     <callback>?
  69.                             <binding uri="xs:anyURI"? name="xs:QName"?
  70.                                              requires="list of xs:QName"?
  71.                                              policySets="list of xs:QName"?/>+
  72.                    </callback>
  73.               </reference> 
  74.      </component>
  75.  
  76.      <wire source="xs:anyURI" target="xs:anyURI" />*
  77.  
  78. </composite>

composite元素有下列属性(attributes):

l       name(必需):构件的名称。其形式是一个XML QName,在命名空间中由        targetNamespace属性标识。

l       targetNamespace(可选):构件被声明的目标命名空间中的一个标识符。

l       local(可选):此构件里的所有组件是否都必须运行在同一个操作系统进程里。值为true,表示必须运行在同一操作系统进程里。默认为false,表示此构件里的不同组件可以运行在不同的操作系统进程里,甚至可以运行在网络中的不同节点。

l       autowire(可选):构件所包含的组件引用是否应该被自动连线,参见the Autowire section. 默认是false

l       constrainingType(可选):contrainingType的名字。指定后,构件的服务、引用、属性还有相关意图都要受到constrainingType定义的约束。参见the ConstrainingType Section

l       requires(可选):策略意图列表。参见Policy Framework specification[10].

l       policySets(可选):策略集列表。参见Policy Framework specification[10].

构件(composites)包含0个或多个propertiesservicescomponentsreferenceswiresincluded composites。这些部件在下面的部分详细描述。

组件(components)包含可配置的实现,它掌握着构件的业务逻辑。组件提供服务,并且需要对其它服务的引用。构件服务(composite services)定义了由构件提供的公共服务,这些服务可以从构件的外面被访问。构件引用(composite references)代表着构件对它外部其它地方提供服务的依赖。连线(wires)描述构件里的组件服务和组件引用之间的联系。被包含进来的构件(included composites)把它们包含的元素贡献给使用它的构件。

构件服务(composite services)包括构件里的某个组件的一个服务的提升(promotion)。这意味着构件的服务实际上是由它里面的组件之一提供的。构件引用包括1个或多个引用的提升,这些引用来自1个或多个组件。多个组件引用可以被提升为相同的构件引用,只要所有的组件引用彼此是兼容的,在这种情况下,这些组件引用都可以共享相同的配置,包括相同的目标服务。

构件服务和构件引用可以各自使用它们提升的服务以及引用的配置(比如BindingsPolicy Sets)。通过构件服务或引用的binidngs及其它方面的配置,它们也可以覆盖被提升的服务及引用的部分或所有配置。

组件服务和组件引用可以被提升为构件服务和构件引用,同时也可以在构件内被连线。对于一个引用,这一点仅在此引用的multiplicity属性值大于1时才有意义。

1.6.1 属性(property-定义和配置

属性(properties)允许在实现的外面设定数据的值。一个实现(implementation),也包括构件,可以声明0个或多个属性。每一个属性有一个类型,类型可以是简单的也可以是复杂的。实现也可以为属性定义一个默认值。属性可以在使用此实现的组件里用值来配置。

构件里一个属性的声明可以遵循下面代码描述的格式:

  1. <?xml version="1.0" encoding="ASCII"?>
  2.  
  3. <composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
  4.                       name="xs:QCName" ... >
  5.  ...
  6.        <property name="xs:NCName" (type="xs:QName" | element="xs:QName")
  7.                          many="xs:boolean"? mustSupply="xs:boolean"?>*
  8.               default-property-value?
  9.        </property>
  10. ...
  11. </composite>

property元素有下列属性:

l         name(必需):属性的名字。

l         typeelement之一(必需):

²        type,属性的类型,是一个XML模式类型的限定名。

²        element,属性的类型,它是一个全局element

l         many(可选):属性是否是单值(false)或多值(true)的。默认是false,在多值的情况下,属性的值在实现里被表示为一个集合类(Collection)。

l         mustSupply(可选):此值表示属性的值是否由使用此实现的组件提供。当mustSupply为“true”是,组件必须提供一个值,因为实现没有为属性提供默认值。仅当mustSupply=false”时,实现应该提供一个默认属性值(default-property-value)。此属性默认为false,意味着这个值不被使用它的组件提供。

property元素可以包含一个可选的default-property-value,它提供了此property的默认值。这个默认值必须匹配property声明的类型:

²        一个字符串,如果type是一个简单的类型(必须匹配声明的type

²        一个复杂类型的值,同样要匹配type的声明

²        一个元素,匹配名称为element的元素

²        多个值,如果many=true

   不同于构件,实现类型能够以一个实现依赖(implementation-dependent)的形式(比如Java类里的注解)声明属性,或通过componentType文件里的属性声明的形式来声明,componentType文件的形式已在上面描述。

当一个实现被组件使用的时候,property的值可以被配置。the section on Components展示了property配置的形式。

1.6.1.1 property举例

下面的例子展示了属性声明和值设定,接下来的例子是一个复杂类型的使用:

  1. <xsd:schema xmlns="http://www.w3.org/2001/XMLSchema"
  2.                          targetNamespace="http://foo.com/"
  3.                          xmlns:tns="http://foo.com/">
  4. <!-- ComplexProperty schema -->
  5. <xsd:element name="fooElement" type="MyComplexType"/>
  6. <xsd:complexType name="MyComplexType">
  7.           <xsd:sequence>
  8.                   <xsd:element name="a" type="xsd:string"/>
  9.                   <xsd:element name="b" type="anyURI"/>
  10.           </xsd:sequence>
  11.           <attribute name="attr" type="xsd:string" use="optional"/>
  12. </xsd:complexType>
  13. </xsd:schema>

下面的构件展示了一个复杂类型的属性声明,带有一个默认值,它还展示了一个复杂类型的属性值在组件里的设定:

  1. <?xml version="1.0" encoding="ASCII"?>
  2.  
  3. <composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
  4.                        xmlns:foo="http://foo.com"
  5.                        targetNamespace="http://foo.com"
  6.                        name="AccountServices">
  7. <!-- AccountServices Example1 -->
  8.   ...
  9.       <property name="complexFoo" type="foo:MyComplexType">
  10.              <MyComplexPropertyValue xsi:type="foo:MyComplexType">
  11.                    <foo:a>AValue</foo:a>
  12.                    <foo:b>InterestingURI</foo:b>
  13.               </MyComplexPropertyValue>
  14.      </property>
  15.  
  16.      <component name="AccountServiceComponent">
  17.              <implementation.java class="foo.AccountServiceImpl"/>
  18.              <property name="complexBar" source="$complexFoo"/>
  19.              <reference name="accountDataService"
  20.                                  target="AccountDataServiceComponent"/>
  21.              <reference name="stockQuoteService" target="StockQuoteService"/>
  22.      </component>
  23.   ...
  24.   </composite>

在构件AccountService里名字为complexFoo的属性声明中,属性定义为类型fooMyComplexType。命名空间foo在构件里声明,它引用了XSDXSDMyComplexType定义的地方。complexFoo的声明包含了一个默认值。它被作为property元素的内容声明。在这个例子中,默认值由fooMyComplexTypeMyComplexPropertyValue元素,以及它的两个子元素<foo:a><foo:b>组成,默认值在MyComplexType的定义之后被声明。

在组件AccountServiceComponent中,组件设定了属性complexBar的值,这个属性在组件配置的实现(implementation)中声明。在这种情况下,complexBar的类型是foo:MyComplextype。例子表明,属性complexBar的值被属性complexFoo的值设定,名字为complexBarproperty元素的source属性表明,这个property的值由构件中包含的property的值设定。source属性的值是$complexFoo,这里complexFoo是构件中的property的名字。这个值意味着,源property的所有值都用来设定组件中property的值。

下面的例子说明了,一个简单类型(如String)的property的值可以设定为一个构件中的复杂类型属性的部分属性值:

  1. <?xml version="1.0" encoding="ASCII"?>
  2.  
  3. <composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
  4.                        xmlns:foo="http://foo.com"
  5.                        targetNamespace="http://foo.com"
  6.                        name="AccountServices">
  7. <!-- AccountServices Example2 -->
  8.   ...
  9.       <property name="complexFoo" type="foo:MyComplexType">
  10.                <MyComplexPropertyValue xsi:type="foo:MyComplexType">
  11.                          <foo:a>AValue</foo:a>
  12.                          <foo:b>InterestingURI</foo:b>
  13.                </MyComplexPropertyValue>
  14.       </property>
  15.  
  16.       <component name="AccountServiceComponent">
  17.               <implementation.java class="foo.AccountServiceImpl"/>
  18.               <property name="currency" source="$complexFoo/a"/>
  19.               <reference name="accountDataService"
  20.                                    target="AccountDataServiceComponent"/>
  21.               <reference name="stockQuoteService" target="StockQuoteService"/>
  22.       </component>
  23.   ...
  24.   </composite>

在这个例子中,组件AccountServiceComponent设定了名为currency 属性 的值,它的是String类型。这个值由构件AccountServices的一个属性值设定的,通过source属性的值$complexFoo/a。这是一个XPath表达式,它选择了名为complexFoo属性中子元素a的值。“a”子元素是一个String,与currency属性的类型相匹配。

进一步的例子展示了组件中声明属性及设定属性值:

类型为简单类型且有默认值的属性声明:

<property name="SimpleTypeProperty" type="xsd:string">
              MyValue
        </property>
 

类型为复杂类型且有默认值的属性声明:

  1. <property name="complexFoo" type="foo:MyComplexType">
  2.     <MyComplexPropertyValue xsi:type="foo:MyComplexType">
  3.            <foo:a>AValue</foo:a>
  4.            <foo:b>InterestingURI</foo:b>
  5.     </MyComplexPropertyValue>
  6. </property>

element类型的属性声明:

  1. <property name="elementFoo" element="foo:fooElement">
  2.       <foo:fooElement>
  3.            <foo:a>AValue</foo:a>
  4.            <foo:b>InterestingURI</foo:b>
  5.      </foo:fooElement>
  6. </property>

简单类型的属性值:

  1. <property name="SimpleTypeProperty">
  2. MyValue
  3. </property>

复杂类型的属性值,也展示了复杂类型属性值的设定:


  1. <property name="complexFoo">
  2.       <MyComplexPropertyValue xsi:type="foo:MyComplexType" attr="bar">
  3.             <foo:a>AValue</foo:a>
  4.             <foo:b>InterestingURI</foo:b>
  5.       </MyComplexPropertyValue>
  6. </property>

element类型的属性值(property value for an element type):

  1. <property name="elementFoo">
  2.          <foo:fooElement attr="bar">
  3.                <foo:a>AValue</foo:a>
  4.                <foo:b>InterestingURI</foo:b>
  5.         </foo:fooElement>
  6. </property>

复杂类型的属性声明,这里提供了多值:

  1. <property name="complexFoo" type="foo:MyComplexType" many="true"/>

多值属性的值设定:

  1. <property name="complexFoo">
  2.          <MyComplexPropertyValue1 xsi:type="foo:MyComplexType" attr="bar">
  3.                 <foo:a>AValue</foo:a>
  4.                <foo:b>InterestingURI</foo:b>
  5.          </MyComplexPropertyValue1>
  6.          <MyComplexPropertyValue2 xsi:type="foo:MyComplexType" attr="zing">
  7.                <foo:a>BValue</foo:a>
  8.               <foo:b>BoringURI</foo:b>
  9.          </MyComplexPropertyValue2>
  10. </property>

此部分结束。。。


本文参加了“SOA中国的关键任务”博客大赢家,评论文章即可参与活动,赢取万元奖金!

 评论 查看全部评论