WS-BPEL 2.0 xml schema 详解(三)

Posted on 2019-03-22 Edited on 2020-01-04 Valine:

element：exit

<xsd:element name="exit" type="tExit"/>

<xsd:complexType name="tExit">
    <xsd:complexContent>
        <xsd:extension base="tActivity"/>
    </xsd:complexContent>
</xsd:complexType>

就是tActivity的一个元素化，可以看作是一个最原始，最纯粹的activity。

和compensate、empty定义是一样的，在语义上和用法上不一样。

element：extensionActivity

<xsd:element name="extensionActivity" type="tExtensionActivity"/>

<xsd:complexType name="tExtensionActivity">
    <xsd:sequence>
        <xsd:any namespace="##other" processContents="lax"/>
    </xsd:sequence>
</xsd:complexType>

允许从其他命名空间增加元素当作activity装进来

element：flow

<xsd:element name="flow" type="tFlow"/>

<xsd:complexType name="tFlow">
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:sequence>
                <xsd:element ref="links" minOccurs="0"/>
                <xsd:group ref="activity" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

基于tActivity进行扩展，sequence中包含：

element links：可以没有，在后边定义
group activity：1到多个activity的group，算是一个嵌套的定义

element：links

<xsd:element name="links" type="tLinks"/>

<xsd:complexType name="tLinks">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="link" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:element name="link" type="tLink"/>

<xsd:complexType name="tLink">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:attribute name="name" type="xsd:NCName" use="required"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

links基于tExtensibleElements进行扩展（辣个男人又回来了），包含1至多个link

link同样基于tExtensibleElements进行扩展，增加了一个属性

name：NCName，这就是link的真相了

element：forEach

<xsd:element name="forEach" type="tForEach"/>

<xsd:complexType name="tForEach">
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:sequence>
                <xsd:element ref="startCounterValue" minOccurs="1"/>
                <xsd:element ref="finalCounterValue" minOccurs="1"/>
                <xsd:element ref="completionCondition" minOccurs="0"/>
                <xsd:element ref="scope" minOccurs="1"/>
            </xsd:sequence>
            <xsd:attribute name="counterName" type="BPELVariableName" use="required"/>
            <xsd:attribute name="parallel" type="tBoolean" use="required"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:element name="startCounterValue" type="tExpression"/>

<xsd:element name="finalCounterValue" type="tExpression"/>

看名字就知道是一个forEach循环了，element包括

startCounterValue
finalCounterValue
completionCondition
scope

这四个应该不用解释了吧，for循环要素

然后还有两个属性

counterName：计数器的名称
parallel：是否并行

element：completionCondition

<xsd:element name="completionCondition" type="tCompletionCondition"/>

<xsd:complexType name="tCompletionCondition">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="branches" minOccurs="0"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

这个condition由一组branches构成

element：branches

<xsd:element name="branches" type="tBranches"/>

<xsd:complexType name="tBranches">
    <xsd:complexContent>
        <xsd:extension base="tExpression">
            <xsd:attribute name="successfulBranchesOnly" type="tBoolean" default="no"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

branches基于tExpression进行扩展，还有一个属性

successfulBranchesOnly：默认是no

element：if

<xsd:element name="if" type="tIf"/>

<xsd:complexType name="tIf">
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:sequence>
                <xsd:element ref="condition" minOccurs="1"/>
                <xsd:group ref="activity" minOccurs="1"/>
                <xsd:element ref="elseif" minOccurs="0" maxOccurs="unbounded"/>
                <xsd:element ref="else" minOccurs="0"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

if也是一类activity，基于tAcitivity进行扩展，sequence中包括

condition：element，至少一个
activity：group，至少一个
elseif：element，0到多个
else：element，可以没有

element：elseif

<xsd:element name="elseif" type="tElseif"/>

<xsd:complexType name="tElseif">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="condition" minOccurs="1"/>
                <xsd:group ref="activity" minOccurs="1"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:element name="else" type="tActivityContainer"/>

elseif基于tExtensibleElements扩展，sequence中包括

condition：element，数量1
activity：group，数量1

Else就直接是tActivityContainer了，condition都不用。

element：invoke

<xsd:element name="invoke" type="tInvoke"/>

<xsd:complexType name="tInvoke">
    <xsd:annotation>
        <xsd:documentation>
XSD Authors: The child element correlations needs to be a Local Element Declaration, because there is another correlations element defined for the non-invoke activities.
        </xsd:documentation>
    </xsd:annotation>
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:sequence>
                <xsd:element name="correlations" type="tCorrelationsWithPattern" minOccurs="0"/>
                <xsd:element ref="catch" minOccurs="0" maxOccurs="unbounded"/>
                <xsd:element ref="catchAll" minOccurs="0"/>
                <xsd:element ref="compensationHandler" minOccurs="0"/>
                <xsd:element ref="toParts" minOccurs="0"/>
                <xsd:element ref="fromParts" minOccurs="0"/>
            </xsd:sequence>
            <xsd:attribute name="partnerLink" type="xsd:NCName" use="required"/>
            <xsd:attribute name="portType" type="xsd:QName" use="optional"/>
            <xsd:attribute name="operation" type="xsd:NCName" use="required"/>
            <xsd:attribute name="inputVariable" type="BPELVariableName" use="optional"/>
            <xsd:attribute name="outputVariable" type="BPELVariableName" use="optional"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

annotation说明就不讲了

基于tActivity扩展，用调用其他 Web 服务，element有6个

correlations：本地的元素声明
catch
catchAll
compensationHandler
toParts
fromParts

attribute有5个

partnerLink
portType
operation
inputVariable
outputVariable

感觉看名字就懂了，没啥好讲的

complexType：tCorrelationsWithPattern

<xsd:complexType name="tCorrelationsWithPattern">
    <xsd:annotation>
        <xsd:documentation>
XSD Authors: The child element correlation needs to be a Local Element Declaration, because there is another correlation element defined for the non-invoke activities.
        </xsd:documentation>
    </xsd:annotation>
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element name="correlation" type="tCorrelationWithPattern" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:complexType name="tCorrelationWithPattern">
    <xsd:complexContent>
        <xsd:extension base="tCorrelation">
            <xsd:attribute name="pattern" type="tPattern"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:simpleType name="tPattern">
    <xsd:restriction base="xsd:string">
        <xsd:enumeration value="request"/>
        <xsd:enumeration value="response"/>
        <xsd:enumeration value="request-response"/>
    </xsd:restriction>
</xsd:simpleType>

一通定义，实际上这个tCorrelationsWithPattern就是1至多个tCorrelationWithPattern

这个tCorrelationWithPattern从tCorrelation进行扩展，增加了属性pattern

这个pattern就是request、response、request-response三选一

element：fromParts

<xsd:element name="fromParts" type="tFromParts"/>

<xsd:complexType name="tFromParts">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="fromPart" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:element name="fromPart" type="tFromPart"/>

<xsd:complexType name="tFromPart">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:attribute name="part" type="xsd:NCName" use="required"/>
            <xsd:attribute name="toVariable" type="BPELVariableName" use="required"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

fromParts扩展自tExtensibleElements，由1到多个fromPart组成

fromPart同样扩展自tExtensibleElements，包含两个attribute

part
toVariable

element：toParts

<xsd:element name="toParts" type="tToParts"/>

<xsd:complexType name="tToParts">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="toPart" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:element name="toPart" type="tToPart"/>

<xsd:complexType name="tToPart">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:attribute name="part" type="xsd:NCName" use="required"/>
            <xsd:attribute name="fromVariable" type="BPELVariableName" use="required"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

toParts扩展自tExtensibleElements，由1到多个toPart组成

toPart同样扩展自tExtensibleElements，包含两个attribute

part
fromVariable

element：pick

<xsd:element name="pick" type="tPick"/>

<xsd:complexType name="tPick">
    <xsd:annotation>
        <xsd:documentation>
XSD Authors: The child element onAlarm needs to be a Local Element Declaration, because there is another onAlarm element defined for event handlers.
        </xsd:documentation>
    </xsd:annotation>
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:sequence>
                <xsd:element ref="onMessage" minOccurs="1" maxOccurs="unbounded"/>
                <xsd:element name="onAlarm" type="tOnAlarmPick" minOccurs="0" maxOccurs="unbounded"/>
            </xsd:sequence>
            <xsd:attribute name="createInstance" type="tBoolean" default="no"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

pick扩展自tActivity

两个属性都在后边定义：

onMessage
onAlarm

一个属性：

createInstance

element：onMessage

<xsd:element name="onMessage" type="tOnMessage"/>

<xsd:complexType name="tOnMessage">
    <xsd:complexContent>
        <xsd:extension base="tOnMsgCommon">
            <xsd:sequence>
                <xsd:group ref="activity" minOccurs="1"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

扩展自tOnMsgCommon

sequence中是一个activity的group

complexType：tOnAlarmPick

<xsd:complexType name="tOnAlarmPick">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:group ref="forOrUntilGroup" minOccurs="1"/>
                <xsd:group ref="activity" minOccurs="1"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

扩展自tExtensibleElements

sequence中有两个group

forOrUntilGroup
activity

都是出现一次

element：receive

<xsd:element name="receive" type="tReceive"/>

<xsd:complexType name="tReceive">
    <xsd:annotation>
        <xsd:documentation>
XSD Authors: The child element correlations needs to be a Local Element Declaration, because there is another correlations element defined for the invoke activity.
        </xsd:documentation>
    </xsd:annotation>
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:sequence>
                <xsd:element name="correlations" type="tCorrelations" minOccurs="0"/>
                <xsd:element ref="fromParts" minOccurs="0"/>
            </xsd:sequence>
            <xsd:attribute name="partnerLink" type="xsd:NCName" use="required"/>
            <xsd:attribute name="portType" type="xsd:QName" use="optional"/>
            <xsd:attribute name="operation" type="xsd:NCName" use="required"/>
            <xsd:attribute name="variable" type="BPELVariableName" use="optional"/>
            <xsd:attribute name="createInstance" type="tBoolean" default="no"/>
            <xsd:attribute name="messageExchange" type="xsd:NCName" use="optional"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

扩展自tActivity，用于（接收请求）等待客户端通过发送消息调用业务流程

2个element

correlations
fromParts

6个attribute

partnerLink
portType
operation
variable
createInstance
messageExchange

element：repeatUntil

<xsd:element name="repeatUntil" type="tRepeatUntil"/>

<xsd:complexType name="tRepeatUntil">
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:sequence>
                <xsd:group ref="activity" minOccurs="1"/>
                <xsd:element ref="condition" minOccurs="1"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

扩展自tActivity

sequence中包含

activity：group，数量为1
condition：element，数量也是1

element：reply

<xsd:element name="reply" type="tReply"/>

<xsd:complexType name="tReply">
    <xsd:annotation>
        <xsd:documentation>
XSD Authors: The child element correlations needs to be a Local Element Declaration, because there is another correlations element defined for the invoke activity.
        </xsd:documentation>
    </xsd:annotation>
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:sequence>
                <xsd:element name="correlations" type="tCorrelations" minOccurs="0"/>
                <xsd:element ref="toParts" minOccurs="0"/>
            </xsd:sequence>
            <xsd:attribute name="partnerLink" type="xsd:NCName" use="required"/>
            <xsd:attribute name="portType" type="xsd:QName" use="optional"/>
            <xsd:attribute name="operation" type="xsd:NCName" use="required"/>
            <xsd:attribute name="variable" type="BPELVariableName" use="optional"/>
            <xsd:attribute name="faultName" type="xsd:QName"/>
            <xsd:attribute name="messageExchange" type="xsd:NCName" use="optional"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

扩展自tActivity，用于生成同步操作的响应

2个element

correlations
toParts

6个attribute

partnerLink
portType
operation
variable
faultName
messageExchange

element：rethrow

<xsd:element name="rethrow" type="tRethrow"/>

<xsd:complexType name="tRethrow">
    <xsd:complexContent>
        <xsd:extension base="tActivity"/>
    </xsd:complexContent>
</xsd:complexType>

就是tActivity的一个元素化，可以看作是一个最原始，最纯粹的activity。

和compensate、empty，exit定义是一样的，就是在语义上和用法上不一样。

element：scope

<xsd:element name="scope" type="tScope"/>

<xsd:complexType name="tScope">
    <xsd:annotation>
        <xsd:documentation>
There is no schema-level default for "exitOnStandardFault" at "scope". Because, it will inherit default from enclosing scope or process.
        </xsd:documentation>
    </xsd:annotation>
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:sequence>
                <xsd:element ref="partnerLinks" minOccurs="0"/>
                <xsd:element ref="messageExchanges" minOccurs="0"/>
                <xsd:element ref="variables" minOccurs="0"/>
                <xsd:element ref="correlationSets" minOccurs="0"/>
                <xsd:element ref="faultHandlers" minOccurs="0"/>
                <xsd:element ref="compensationHandler" minOccurs="0"/>
                <xsd:element ref="terminationHandler" minOccurs="0"/>
                <xsd:element ref="eventHandlers" minOccurs="0"/>
                <xsd:group ref="activity" minOccurs="1"/>
            </xsd:sequence>
            <xsd:attribute name="isolated" type="tBoolean" default="no"/>
            <xsd:attribute name="exitOnStandardFault" type="tBoolean"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

扩展自tActivity，用于以分层方式将复杂流程划分为多个组织部分。scope为活动提供了行为上下文。换言之，scope可以为不同的活动（或在或 ) 等通用的结构化活动下收集的活动集）定义不同的故障处理程序。除了定义故障处理程序以外，scope还可以声明只在作用域中可见的变量。scope还可以定义本地关联集、补偿处理程序和事件处理程序。

sequence中有：

partnerLinks
messageExchanges
variables
correlationSets
faultHandlers
compensationHandler
terminationHandler
eventHandlers
activity

还有两个属性

isolated
exitOnStandardFault

element：compensationHandler

<xsd:element name="compensationHandler" type="tActivityContainer">
    <xsd:annotation>
        <xsd:documentation>
This element can contain all activities including the activities compensate and compensateScope.
        </xsd:documentation>
    </xsd:annotation>
</xsd:element>

实际上就是一个tActivityContainer

element：terminationHandler

<xsd:element name="terminationHandler" type="tActivityContainer">
    <xsd:annotation>
        <xsd:documentation>
This element can contain all activities including the activities compensate and compensateScope.
        </xsd:documentation>
    </xsd:annotation>
</xsd:element>

实际上就是一个tActivityContainer

element：sequence

<xsd:element name="sequence" type="tSequence"/>

<xsd:complexType name="tSequence">
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:sequence>
                <xsd:group ref="activity" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

扩展自tActivity，但是里边还可以装很多的activity的group的序列

element：throw

<xsd:element name="throw" type="tThrow"/>

<xsd:complexType name="tThrow">
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:attribute name="faultName" type="xsd:QName" use="required"/>
            <xsd:attribute name="faultVariable" type="BPELVariableName"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

扩展自tActivity，增加了两个属性

faultName
faultVariable

element：validate

<xsd:element name="validate" type="tValidate"/>

<xsd:complexType name="tValidate">
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:attribute name="variables" use="required" type="BPELVariableNames"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

扩展自tActivity，增加了1个属性

variables：BPELVariableNames

simpleType：BPELVariableNames

<xsd:simpleType name="BPELVariableNames">
    <xsd:restriction>
        <xsd:simpleType>
            <xsd:list itemType="BPELVariableName"/>
        </xsd:simpleType>
        <xsd:minLength value="1"/>
    </xsd:restriction>
</xsd:simpleType>

一个BPELVariableName的list，默认空格分割，最短一个

element：wait

<xsd:element name="wait" type="tWait"/>

<xsd:complexType name="tWait">
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:choice>
                <xsd:element ref="for" minOccurs="1"/>
                <xsd:element ref="until" minOccurs="1"/>
            </xsd:choice>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

扩展自tActivity，增加了元素，从for和until中二选一

element：while

<xsd:element name="while" type="tWhile"/>

<xsd:complexType name="tWhile">
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:sequence>
                <xsd:element ref="condition" minOccurs="1"/>
                <xsd:group ref="activity" minOccurs="1"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

扩展自tActivity，增加了一个sequence，里边有

condition
activity

complexType：tExpression

<xsd:complexType name="tExpression" mixed="true">
    <xsd:sequence>
        <xsd:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
    </xsd:sequence>
    <xsd:attribute name="expressionLanguage" type="xsd:anyURI"/>
    <xsd:anyAttribute namespace="##other" processContents="lax"/>
</xsd:complexType>

tExpression的内容基本就是随便写

属性有一个expressionLanguage，然后还可以再增加其他属性

看起来是any，实际上要看expressionLanguage的

complexType：tCondition

<xsd:complexType name="tCondition">
    <xsd:complexContent mixed="true">
        <xsd:extension base="tExpression"/>
    </xsd:complexContent>
</xsd:complexType>

tCondition就是在tExpression的基础上随便写

element：condition

<xsd:element name="condition" type="tBoolean-expr"/>

<xsd:complexType name="tBoolean-expr">
    <xsd:complexContent mixed="true">
        <xsd:extension base="tExpression"/>
    </xsd:complexContent>
</xsd:complexType>

condition也是在tExpression的基础上随便写

complexType：tDuration-expr

<xsd:complexType name="tDuration-expr">
    <xsd:complexContent mixed="true">
        <xsd:extension base="tExpression"/>
    </xsd:complexContent>
</xsd:complexType>

在tExpression的基础上随便写

complexType：tDeadline-expr

<xsd:complexType name="tDeadline-expr">
    <xsd:complexContent mixed="true">
        <xsd:extension base="tExpression"/>
    </xsd:complexContent>
</xsd:complexType>

在tExpression的基础上随便写

simpleType：tBoolean

<xsd:simpleType name="tBoolean">
    <xsd:restriction base="xsd:string">
        <xsd:enumeration value="yes"/>
        <xsd:enumeration value="no"/>
    </xsd:restriction>
</xsd:simpleType>

yes or no，二选一

WS-BPEL 2.0 xml schema 详解(二)

Posted on 2019-03-22 Edited on 2020-01-04 Valine:

element：eventHandlers

<xsd:element name="eventHandlers" type="tEventHandlers"/>

<xsd:complexType name="tEventHandlers">
    <xsd:annotation>
        <xsd:documentation>
XSD Authors: The child element onAlarm needs to be a Local Element Declaration, because there is another onAlarm element defined for the pick activity.
        </xsd:documentation>
    </xsd:annotation>
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="onEvent" minOccurs="0" maxOccurs="unbounded"/>
                <xsd:element name="onAlarm" type="tOnAlarmEvent" minOccurs="0" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

eventHandlers基于tExtensibleElements扩展，由2种元素的sequence组成：

onEvent：见element：onEvent
onAlarm：见complexType：tOnAlarmEvent

element：onEvent

<xsd:element name="onEvent" type="tOnEvent"/>

<xsd:complexType name="tOnEvent">
    <xsd:complexContent>
        <xsd:extension base="tOnMsgCommon">
            <xsd:sequence>
                <xsd:element ref="scope" minOccurs="1"/>
            </xsd:sequence>
            <xsd:attribute name="messageType" type="xsd:QName" use="optional"/>
            <xsd:attribute name="element" type="xsd:QName" use="optional"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

onEvent元素基于tOnMsgCommon进行扩展，包含一个element sequence：

scope：用于表明作用范围

2个attribute：

messageType
element

complexType：tOnMsgCommon

<xsd:complexType name="tOnMsgCommon">
    <xsd:annotation>
        <xsd:documentation>
XSD Authors: The child element correlations needs to be a Local Element Declaration, because there is another correlations element defined for the invoke activity.
        </xsd:documentation>
    </xsd:annotation>
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element name="correlations" type="tCorrelations" minOccurs="0"/>
                <xsd:element ref="fromParts" minOccurs="0"/>
            </xsd:sequence>
            <xsd:attribute name="partnerLink" type="xsd:NCName" use="required"/>
            <xsd:attribute name="portType" type="xsd:QName" use="optional"/>
            <xsd:attribute name="operation" type="xsd:NCName" use="required"/>
            <xsd:attribute name="messageExchange" type="xsd:NCName" use="optional"/>
            <xsd:attribute name="variable" type="BPELVariableName" use="optional"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

tOnMsgCommon这个complexType同样支持tExtensibleElements扩展，包含由两类element组成的sequence：

correlations：type为tCorrelations
fromParts

同时还引入了5种属性：

partnerLink：必填的链接名
portType：选填的端口类型
operation：必填的操作
messageExchange：选填的操作信息
variable：选填的变量

complexType：tCorrelations

<xsd:complexType name="tCorrelations">
    <xsd:annotation>
        <xsd:documentation>
XSD Authors: The child element correlation needs to be a Local Element Declaration, because there is another correlation element defined for the invoke activity.
        </xsd:documentation>
    </xsd:annotation>
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element name="correlation" type="tCorrelation" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:complexType name="tCorrelation">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:attribute name="set" type="xsd:NCName" use="required"/>
            <xsd:attribute name="initiate" type="tInitiate" default="no"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:simpleType name="tInitiate">
    <xsd:restriction base="xsd:string">
        <xsd:enumeration value="yes"/>
        <xsd:enumeration value="join"/>
        <xsd:enumeration value="no"/>
    </xsd:restriction>
</xsd:simpleType>

tCorrelations基于tExtensibleElements扩展，由1至多个correlation的sequence组成。

tCorrelation同样基于tExtensibleElements扩展，在此之上还定义了两个属性：

set
initiate：yes | join | no

complexType：tOnAlarmEvent

<xsd:complexType name="tOnAlarmEvent">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:choice>
                    <xsd:sequence>
                        <xsd:group ref="forOrUntilGroup" minOccurs="1"/>
                        <xsd:element ref="repeatEvery" minOccurs="0"/>
                    </xsd:sequence>
                    <xsd:element ref="repeatEvery" minOccurs="1"/>
                </xsd:choice>
                <xsd:element ref="scope" minOccurs="1"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

tOnAlarmEvent基于tExtensibleElements扩展，由1个group：forOrUntilGroup 和 0或1个element：repeatEvery组成的sequence，或者1个element：repeatEvery，再加上一个scope组成的sequence组成。

三个元素都通过ref引用，可以继续往后看定义。

group：forOrUntilGroup

<xsd:group name="forOrUntilGroup">
    <xsd:choice>
        <xsd:element ref="for" minOccurs="1"/>
        <xsd:element ref="until" minOccurs="1"/>
    </xsd:choice>
</xsd:group>

<xsd:element name="for" type="tDuration-expr"/>

<xsd:element name="until" type="tDeadline-expr"/>

<xsd:element name="repeatEvery" type="tDuration-expr"/>

可以看到，forOrUntilGroup还真就是for或者until两个元素中选一个。这两个东西又分别通过tDuration-expr，tDeadline-expr来定义。

刚好element：repeatEvery也在这后边，一起讲了吧，同样通过tDuration-expr来定义。

complexType：tActivity

<xsd:complexType name="tActivity">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="targets" minOccurs="0"/>
                <xsd:element ref="sources" minOccurs="0"/>
            </xsd:sequence>
            <xsd:attribute name="name" type="xsd:NCName"/>
            <xsd:attribute name="suppressJoinFailure" type="tBoolean" use="optional"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

一看是activity的type，感觉应该出现过，其实并没有，大概是后边会用到吧。

同样基于tExtensibleElements扩展（啥都要tExtensibleElements扩展一下，这兼容性也太强了吧），包含两个元素组成的sequence

targets：出现0或1次
sources：出现0或1次

另外还有俩属性：

name
suppressJoinFailure：有一种故障叫joinFailure，在连接条件求值为 false 时抛出。通过将流程或活动属性 suppressJoinFailure 设置为 yes，可以禁止此故障。

element：targets

<xsd:element name="targets" type="tTargets"/>

<xsd:complexType name="tTargets">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="joinCondition" minOccurs="0"/>
                <xsd:element ref="target" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

targets基于tExtensibleElements进行扩展，包含两个元素组成的sequence：

joinCondition：0或1个
target：1到多个

element：joinCondition

1	<xsd:element name="joinCondition" type="tCondition"/>

这玩意儿的定义在tCondition里边，其实装的就是几乎啥都可以写的混合内容。

element：target

<xsd:element name="target" type="tTarget"/>

<xsd:complexType name="tTarget">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:attribute name="linkName" type="xsd:NCName" use="required"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

tTarget这个东西是一个机遇tExtensibleElements扩展的元素，就增加了一个元素

linkName：NCName，必填，写上你的目标

element：sources

<xsd:element name="sources" type="tSources"/>

<xsd:complexType name="tSources">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="source" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:element name="source" type="tSource"/>

<xsd:complexType name="tSource">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="transitionCondition" minOccurs="0"/>
            </xsd:sequence>
            <xsd:attribute name="linkName" type="xsd:NCName" use="required"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:element name="transitionCondition" type="tCondition"/>

sources：tExtensibleElements，以及1到多个source

source：tExtensibleElements扩展，还有一个元素的sequence

transitionCondition：转移条件，可以不出现，也可以出现一次

还有一个属性

linkName：NCName，必填，写上你的来源

element：assign

<xsd:element name="assign" type="tAssign"/>

<xsd:complexType name="tAssign">
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:sequence>
                <xsd:choice maxOccurs="unbounded">
                    <xsd:element ref="copy" minOccurs="1"/>
                    <xsd:element ref="extensionAssignOperation" minOccurs="1"/>
                </xsd:choice>
            </xsd:sequence>
            <xsd:attribute name="validate" type="tBoolean" use="optional" default="no"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

Assign，基于tActivity扩展，增加了两个属性，二选一只猴构成sequence

copy：出现1至多次
extensionAssignOperation：出现1至多次

还增加了一个属性

validate：bool值，默认是no，可选

element：copy

<xsd:element name="copy" type="tCopy"/>

<xsd:complexType name="tCopy">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="from" minOccurs="1"/>
                <xsd:element ref="to" minOccurs="1"/>
            </xsd:sequence>
            <xsd:attribute name="keepSrcElementName" type="tBoolean" use="optional" default="no"/>
            <xsd:attribute name="ignoreMissingFromData" type="tBoolean" use="optional" default="no"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

copy，基于tExtensibleElements扩展，两个元素比较好理解

from：从哪里copy
to：copy到哪里

还有两个属性：

keepSrcElementName：bool值，可选，默认no，是否保存源元素的属性名
ignoreMissingFromData：bool值，可选，默认no，是否忽略数据中的遗失部分

element：from

<xsd:element name="from" type="tFrom"/>

<xsd:complexType name="tFrom" mixed="true">
    <xsd:sequence>
        <xsd:element ref="documentation" minOccurs="0" maxOccurs="unbounded"/>
        <xsd:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
        <xsd:choice minOccurs="0">
            <xsd:element ref="literal" minOccurs="1"/>
            <xsd:element ref="query" minOccurs="1"/>
        </xsd:choice>
    </xsd:sequence>
    <xsd:attribute name="expressionLanguage" type="xsd:anyURI"/>
    <xsd:attribute name="variable" type="BPELVariableName"/>
    <xsd:attribute name="part" type="xsd:NCName"/>
    <xsd:attribute name="property" type="xsd:QName"/>
    <xsd:attribute name="partnerLink" type="xsd:NCName"/>
    <xsd:attribute name="endpointReference" type="tRoles"/>
    <xsd:anyAttribute namespace="##other" processContents="lax"/>
</xsd:complexType>

然而这个from并不简单，我们先看看这个sequence里边装了什么

documentation：element，0至多个，前边定义过了，基本上就是一个mixed的啥都可以写的东西，属性里边指明source和language就可以了
any：0至多个来自其他命名空间的任意元素
literal/query：这俩二选一，具体是啥看后边定义

还有几个属性

expressionLanguage：表达语言
variable：BPELVariableName
part：来自哪一部分
property：属性是什么
partnerLink
endpointReference：通过tRoles定义
anyAttribute：还可以随便加其他属性

element：literal

<xsd:element name="literal" type="tLiteral"/>

<xsd:complexType name="tLiteral" mixed="true">
    <xsd:sequence>
        <xsd:any namespace="##any" processContents="lax" minOccurs="0" maxOccurs="1"/>
    </xsd:sequence>
</xsd:complexType>

literal就是一个mixed描述段落，里边可以有一个任意元素。

element：query

<xsd:element name="query" type="tQuery"/>

<xsd:complexType name="tQuery" mixed="true">
    <xsd:sequence>
        <xsd:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
    </xsd:sequence>
    <xsd:attribute name="queryLanguage" type="xsd:anyURI"/>
    <xsd:anyAttribute namespace="##other" processContents="lax"/>
</xsd:complexType>

Query和literal相似，是一个mixed描述段落，里边可以有任意个任意元素。同时它还有属性

queryLanguage：表明查询语言
anyAttribute：看似随便加属性，实际上根据查询语言不通增加其他属性

simpleType：tRoles

<xsd:simpleType name="tRoles">
    <xsd:restriction base="xsd:string">
        <xsd:enumeration value="myRole"/>
        <xsd:enumeration value="partnerRole"/>
    </xsd:restriction>
</xsd:simpleType>

myRole和partnerRole两个值二选一

element：to

<xsd:element name="to" type="tTo"/>

<xsd:complexType name="tTo" mixed="true">
    <xsd:sequence>
        <xsd:element ref="documentation" minOccurs="0" maxOccurs="unbounded"/>
        <xsd:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
        <xsd:element ref="query" minOccurs="0"/>
    </xsd:sequence>
    <xsd:attribute name="expressionLanguage" type="xsd:anyURI"/>
    <xsd:attribute name="variable" type="BPELVariableName"/>
    <xsd:attribute name="part" type="xsd:NCName"/>
    <xsd:attribute name="property" type="xsd:QName"/>
    <xsd:attribute name="partnerLink" type="xsd:NCName"/>
    <xsd:anyAttribute namespace="##other" processContents="lax"/>
</xsd:complexType>

这个to也不简单，我们看看这个sequence里边装了什么

documentation：element，0至多个，前边定义过了，基本上就是一个mixed的啥都可以写的东西，属性里边指明source和language就可以了
any：0至多个来自其他命名空间的任意元素
query：查询到对应写入的部分

还有几个属性

expressionLanguage：表达语言
variable：BPELVariableName
part：去哪一部分
property：属性是什么
partnerLink
anyAttribute：还可以根据表达语言随便加其他属性

element：extensionAssignOperation

<xsd:element name="extensionAssignOperation" type="tExtensionAssignOperation"/>

<xsd:complexType name="tExtensionAssignOperation">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements"/>
    </xsd:complexContent>
</xsd:complexType>

这个东西是assign中的一个element，怪不得assign没有基于tExtensibleElements扩展，放在里边了。

element：compensate

<xsd:element name="compensate" type="tCompensate"/>

<xsd:complexType name="tCompensate">
    <xsd:complexContent>
        <xsd:extension base="tActivity"/>
    </xsd:complexContent>
</xsd:complexType>

就是tActivity的一个元素化，可以看作是一个最原始，最纯粹的activity。

element：compensateScope

<xsd:element name="compensateScope" type="tCompensateScope"/>

<xsd:complexType name="tCompensateScope">
    <xsd:complexContent>
        <xsd:extension base="tActivity">
            <xsd:attribute name="target" type="xsd:NCName" use="required"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

在compensate之上增加了一个属性：

target：相当于给补偿增加了一个范围

element：empty

<xsd:element name="empty" type="tEmpty"/>

<xsd:complexType name="tEmpty">
    <xsd:complexContent>
        <xsd:extension base="tActivity"/>
    </xsd:complexContent>
</xsd:complexType>

就是tActivity的一个元素化，可以看作是一个最原始，最纯粹的activity。

和compensate是一样的，在语义上和用法上不一样。

WS-BPEL 2.0 xml schema 详解(一)

Posted on 2019-03-21 Edited on 2020-01-04 Valine:

本系列文章将一行一行的解读wsbpel2.0的源码。

相关xsd语法问题，请参见XSD学习笔记完整版

wsbpel2.0 xsd源码来自：ws-bpel_executable.xsd

schema声明

<xsd:schema xmlns="http://docs.oasis-open.org/wsbpel/2.0/process/executable" 
	xmlns:xsd="http://www.w3.org/2001/XMLSchema" targetNamespace="http://docs.oasis-open.org/wsbpel/2.0/process/executable" elementFormDefault="qualified" blockDefault="#all">
	...
<\xsd>

声明命名空间http://docs.oasis-open.org/wsbpel/2.0/process/executable，没有前缀。

引入http://www.w3.org/2001/XMLSchema的语素并以xsd为前缀。

elementFormDefault="qualified"表示所有元素都必须加上前缀以表明其命名空间。

blockDefault="#all"表示默认情况下不能通过派生类代替原类型。

annotation

<xsd:annotation>
	<xsd:documentation>
Schema for Executable Process for WS-BPEL 2.0 OASIS Standard 11th April, 2007
	</xsd:documentation>
</xsd:annotation>

赠送了一个简单的文档说明。

import

1	<xsd:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="http://www.w3.org/2001/xml.xsd"/>

引入http://www.w3.org/2001/xml.xsd的xml语素，前缀默认为xml。

element：process

<xsd:element name="process" type="tProcess">
	<xsd:annotation>
		<xsd:documentation>
This is the root element for a WS-BPEL 2.0 process.
		</xsd:documentation>
	</xsd:annotation>
</xsd:element>

BPEL的根元素，此处没有定义任何内容，内部元素属性通过type=”tProcess”引入。

complexType：tProcess

<xsd:complexType name="tProcess">
	<xsd:complexContent>
		<xsd:extension base="tExtensibleElements">
			<xsd:sequence>
				<xsd:element ref="extensions" minOccurs="0"/>
				<xsd:element ref="import" minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element ref="partnerLinks" minOccurs="0"/>
				<xsd:element ref="messageExchanges" minOccurs="0"/>
				<xsd:element ref="variables" minOccurs="0"/>
				<xsd:element ref="correlationSets" minOccurs="0"/>
				<xsd:element ref="faultHandlers" minOccurs="0"/>
				<xsd:element ref="eventHandlers" minOccurs="0"/>
				<xsd:group ref="activity" minOccurs="1"/>
			</xsd:sequence>
			<xsd:attribute name="name" type="xsd:NCName" use="required"/>
			<xsd:attribute name="targetNamespace" type="xsd:anyURI" use="required"/>
			<xsd:attribute name="queryLanguage" type="xsd:anyURI" default="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"/>
			<xsd:attribute name="expressionLanguage" type="xsd:anyURI" default="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"/>
			<xsd:attribute name="suppressJoinFailure" type="tBoolean" default="no"/>
			<xsd:attribute name="exitOnStandardFault" type="tBoolean" default="no"/>
		</xsd:extension>
	</xsd:complexContent>
</xsd:complexType>

首先是一个名为tExtensibleElements的扩展，先放一下往后看。

一个sequence，包括extensions，import，partnerLinks，messageExchanges，variables，correlationSets，faultHandlers，eventHandlers，还有一个activity的group，这里全部是ref，我们知道大概有些啥就行了，后边肯定会有详细的定义，先往后看吧。

接着是一堆attribute，包括process的

名称name
目标命名空间targetNamespace
查询语言queryLanguage，默认是urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0
表达语言expressionLanguage，默认是：urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0
抑制链接失败suppressJoinFailure，默认是否
标准错误退出exitOnStandardFault，默认是否

complexType：tExtensibleElement

<xsd:complexType name="tExtensibleElements">
    <xsd:annotation>
        <xsd:documentation>
This type is extended by other component types to allow elements and attributes from other namespaces to be added at the modeled places.
        </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
        <xsd:element ref="documentation" minOccurs="0" maxOccurs="unbounded"/>
        <xsd:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
    </xsd:sequence>
    <xsd:anyAttribute namespace="##other" processContents="lax"/>
</xsd:complexType>

tExtensibleElements这个扩展马上就来了，可以看到，扩展除了0至多个documentation（后边再讲），还有

element：来自该元素的父元素的目标命名空间之外的任何命名空间的元素，且即使不能获取该命名空间架构，也不会发生任何错误。
attribute：同上

element：documentation

<xsd:element name="documentation" type="tDocumentation"/>

<xsd:complexType name="tDocumentation" mixed="true">
    <xsd:sequence>
        <xsd:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
    </xsd:sequence>
    <xsd:attribute name="source" type="xsd:anyURI"/>
    <xsd:attribute ref="xml:lang"/>
</xsd:complexType>

documentation中：

element：一个字符元素可混合出现的，元素可随意引入，不在此命名空间也没关系
attribute：
- source：通过URI表明来源
- xml:lang: 文档语言，如en、CN等

group：activity

<xsd:group name="activity">
    <xsd:annotation>
        <xsd:documentation>
All standard WS-BPEL 2.0 activities in alphabetical order. Basic activities and structured activities. Addtional constraints: - rethrow activity can be used ONLY within a fault handler (i.e. "catch" and "catchAll" element) - compensate or compensateScope activity can be used ONLY within a fault handler, a compensation handler or a termination handler
        </xsd:documentation>
    </xsd:annotation>
    <xsd:choice>
        <xsd:element ref="assign"/>
        <xsd:element ref="compensate"/>
        <xsd:element ref="compensateScope"/>
        <xsd:element ref="empty"/>
        <xsd:element ref="exit"/>
        <xsd:element ref="extensionActivity"/>
        <xsd:element ref="flow"/>
        <xsd:element ref="forEach"/>
        <xsd:element ref="if"/>
        <xsd:element ref="invoke"/>
        <xsd:element ref="pick"/>
        <xsd:element ref="receive"/>
        <xsd:element ref="repeatUntil"/>
        <xsd:element ref="reply"/>
        <xsd:element ref="rethrow"/>
        <xsd:element ref="scope"/>
        <xsd:element ref="sequence"/>
        <xsd:element ref="throw"/>
        <xsd:element ref="validate"/>
        <xsd:element ref="wait"/>
        <xsd:element ref="while"/>
    </xsd:choice>
</xsd:group>

定义了一个activity的group，用于在其他地方引用，比如说通过tProcess引用到process里边。

一个activity可以是以下元素中的一个，没写到的看后边源码解读好了：

基本活动名称	释义
assign	活动的作用是用新的数据来更新变量的值。Assign活动可以包括任意数量的基本复制操作。
compensate	通过该活动做一些补偿动作，通常需要和scope联合使用。只能从故障处理程序或另一个补偿处理活动中调用这个活动。补偿处理程序只能被调用一次。
compensateScope
empty	无所事事，比如在一个错误发生后可以不做反应来消除这个错误
exit	该活动用于立刻终止业务流程实例。所有当前运行的活动必须被立刻终止。不用引用任何终点处理、错误处理或者补偿行为。
forEach
invoke	活动允许业务流程同步或异步调用由合作伙伴提供的服务，服务实现可以是单向或请求-响应操作。Invoke活动使用“partnerLink”来引用伙伴服务。同过“portType”和“operation”指定相应的WSDL接口和操作。
pick	活动会等待一组相互排斥事件中的一个事件的发生，然后执行与发生的事件相关联的活动。它会阻塞业务流程执行，以等待某一特定的事件发生，比如接收到一个合适的消息或超时警报响起。当其中任何一个事件被触发后，业务流程就会继续执行，pick也随即完成了，不会再等待其他事件的发生。
receive	活动从流程的外部伙伴那获取数据，并将其保存到流程变量。通常一个Receive是一个流程的初始点，它会阻塞执行直到匹配的消息的到达。
reply	活动发送消息给伙伴来应答通过receive活动所接收到的消息。receive和reply的组合对应着WSDL portType上定义的一个请求-响应操作。如果receive活动对应着一个单向(one-way)操作，则不能在流程中定义对应的reply活动。
rethrow
throw	提示一个错误，一个故障处理可以处理这样的错误。假如一个错误不被处理的话它最终到达最高层后导致过程的终止
validate
wait	活动会暂停流程执行，等待一段给定的时间或等到某一时刻才继续运行。在WebSphere Process Server 6.0中，开发者可以非常灵活地指定wait中的到期条件，比如等待多少秒，等到特定的一个日期，或是使用内置的日期表现法。也可以使用Java代码来动态指定等待时间。

结构化活动名称	释义
extensionActivity
flow	可以描述更为复杂的活动执行顺序。我们可以利用flow指定一个或多个并行执行的活动。为了定义任意的控制结构，可以在并行的活动中使用链接。
if
repeatUntil
scope	使用这个结构可以将一组活动组织在一起作为一个处理单位。通过这个组织方法多个活动可以使用同一个故障处理、事故处理和补偿处理。通过补偿处理BPEL可以处理长时间的处理。
sequence	定义一组按顺序先后执行的活动。执行顺序是sequence活动中嵌套活动的先后顺序。当sequence中的最后一个活动完成后，该sequence活动也就完成了。
while	继承于传统的结构化编程思想，提供了while-do循环结构的支持。它可以包含一个或多个活动。它指定反复执行其内部活动，直到成功条件不被满足为止。在WPS中允许其使用Java代码来描述条件表达式。

element：extensions

<xsd:element name="extensions" type="tExtensions"/>

<xsd:complexType name="tExtensions">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="extension" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:element name="extension" type="tExtension"/>

<xsd:complexType name="tExtension">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:attribute name="namespace" type="xsd:anyURI" use="required"/>
            <xsd:attribute name="mustUnderstand" type="tBoolean" use="required"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

一个extensions由1到多个extension组成。

extension扩展自tExtensibleElements，增加了namespace和mustUnderstand两个属性。

element：import

<xsd:element name="import" type="tImport"/>

<xsd:complexType name="tImport">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:attribute name="namespace" type="xsd:anyURI" use="optional"/>
            <xsd:attribute name="location" type="xsd:anyURI" use="optional"/>
            <xsd:attribute name="importType" type="xsd:anyURI" use="required"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

BPEL允许import，import元素在tExtensibleElements的基础上，增加namespace、location、importType三个属性，和xsd的import类似。

element：partnerLinks

<xsd:element name="partnerLinks" type="tPartnerLinks"/>

<xsd:complexType name="tPartnerLinks">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="partnerLink" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:element name="partnerLink" type="tPartnerLink"/>

<xsd:complexType name="tPartnerLink">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:attribute name="name" type="xsd:NCName" use="required"/>
            <xsd:attribute name="partnerLinkType" type="xsd:QName" use="required"/>
            <xsd:attribute name="myRole" type="xsd:NCName"/>
            <xsd:attribute name="partnerRole" type="xsd:NCName"/>
            <xsd:attribute name="initializePartnerRole" type="tBoolean"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

和extensions相似，partnerLinks由1到多个partnerLink组成，同时支持tExtensibleElements扩展。

partnerLink在tExtensibleElements的基础上，增加了以下5个属性

name
partnerLinkType
myRole
partnerRole
initializaPartnerRole

element：messageExchanges

<xsd:element name="messageExchanges" type="tMessageExchanges"/>

<xsd:complexType name="tMessageExchanges">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="messageExchange" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:element name="messageExchange" type="tMessageExchange"/>

<xsd:complexType name="tMessageExchange">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:attribute name="name" type="xsd:NCName" use="required"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

和extensions相似，messageExchanges由1到多个messageExchange组成，同时支持tExtensibleElements扩展。

messageExchange在tExtensibleElements的基础上，增加了一个属性

name

element：variables

<xsd:element name="variables" type="tVariables"/>

<xsd:complexType name="tVariables">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="variable" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:element name="variable" type="tVariable"/>

<xsd:complexType name="tVariable">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="from" minOccurs="0"/>
            </xsd:sequence>
            <xsd:attribute name="name" type="BPELVariableName" use="required"/>
            <xsd:attribute name="messageType" type="xsd:QName" use="optional"/>
            <xsd:attribute name="type" type="xsd:QName" use="optional"/>
            <xsd:attribute name="element" type="xsd:QName" use="optional"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

和extensions相似，variables由1到多个variable组成，同时支持tExtensibleElements扩展。

variable在tExtensibleElements的基础上，增加了一个元素

from

增加了四个属性

name
messageType
type
element

simpleType：BPELVariableName

<xsd:simpleType name="BPELVariableName">
    <xsd:restriction base="xsd:NCName">
        <xsd:pattern value="[^\.]+"/>
    </xsd:restriction>
</xsd:simpleType>

bpel变量的一个限制，BPELVariableName需要满足xsd:NCName限制，不能以.开头，且长度大于等于一个字符。

element：correlationSets

<xsd:element name="correlationSets" type="tCorrelationSets"/>

<xsd:complexType name="tCorrelationSets">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="correlationSet" minOccurs="1" maxOccurs="unbounded"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

<xsd:element name="correlationSet" type="tCorrelationSet"/>

<xsd:complexType name="tCorrelationSet">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:attribute name="properties" type="QNames" use="required"/>
            <xsd:attribute name="name" type="xsd:NCName" use="required"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

和extensions相似，correlationSets由1到多个correlationSet组成，同时支持tExtensibleElements扩展。

correlationSet在tExtensibleElements的基础上，增加了2个属性

properties
name

simpleType：QNames

<xsd:simpleType name="QNames">
    <xsd:restriction>
        <xsd:simpleType>
            <xsd:list itemType="xsd:QName"/>
        </xsd:simpleType>
        <xsd:minLength value="1"/>
    </xsd:restriction>
</xsd:simpleType>

QNames就是一个QName的list，最少1个，默认空格分割。

element：faultHandlers

<xsd:element name="faultHandlers" type="tFaultHandlers"/>

<xsd:complexType name="tFaultHandlers">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:element ref="catch" minOccurs="0" maxOccurs="unbounded"/>
                <xsd:element ref="catchAll" minOccurs="0"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

faultHandlers，听名字就知道是干啥的了，同样支持tExtensibleElements扩展，由2种元素的sequence组成：

catch
catchAll

element：catch

<xsd:element name="catch" type="tCatch">
    <xsd:annotation>
        <xsd:documentation>
This element can contain all activities including the activities compensate, compensateScope and rethrow.
        </xsd:documentation>
    </xsd:annotation>
</xsd:element>

<xsd:complexType name="tCatch">
    <xsd:complexContent>
        <xsd:extension base="tActivityContainer">
            <xsd:attribute name="faultName" type="xsd:QName"/>
            <xsd:attribute name="faultVariable" type="BPELVariableName"/>
            <xsd:attribute name="faultMessageType" type="xsd:QName"/>
            <xsd:attribute name="faultElement" type="xsd:QName"/>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

catch扩展自tActivityContainer，包含4个属性，对catch做了限定：

faultName
faultVariable
faultMessageType
faultElement

element：catchAll

<xsd:element name="catchAll" type="tActivityContainer">
    <xsd:annotation>
        <xsd:documentation>
This element can contain all activities including the activities compensate, compensateScope and rethrow.
        </xsd:documentation>
    </xsd:annotation>
</xsd:element>

<xsd:complexType name="tActivityContainer">
    <xsd:complexContent>
        <xsd:extension base="tExtensibleElements">
            <xsd:sequence>
                <xsd:group ref="activity" minOccurs="1"/>
            </xsd:sequence>
        </xsd:extension>
    </xsd:complexContent>
</xsd:complexType>

不同于catch，catchAll没有那么多属性（我全都要），就是tActivityContainer本尊，扩展自tExtensibleElements，同时包含一个activity的sequence。

OWL本体语言学习笔记

Posted on 2019-03-18 Edited on 2020-01-04 Valine:

OWL简介

OWL(Web Ontology Language)是W3C开发的一种网络本体语言，用于对本体进行语义描述。OWL是针对各方面的需求在DAML+OIL的基础上进行改进而开发的，它一方面保持了对DAML+oIL／RDFs的兼容性，另一方面又保证了更加强大的语义表达能力，同时还要保证描述逻辑(DL，Description Logic)的可判定推理。W3C的设计人员针对各类特征的需求制定了三种相应的OWL的子语言，即OWL Lite、OWL DL和OWL Full，三种子语言的表达能力递增。

OWL Lite是表达能力最弱的子语言。它是傩乙DL的一个子集，但是通过降低OWL DL中的公理约束，保证了迅速高效的推理。它支持基数约束，但基数值只能为O或l。因为0WL Lite表达能力较弱，为其开发支持工具要比其他两个子语言容易一些。OWL Lite用于提供给那些仅需要一个分类层次和简单约束的用户。
OWL DL(Description Logic，描述逻辑)将可判定推理能力和较强表达能力作为首要目标，而忽略了对RDFS的兼容性。0WL DL包括了OWL语言的所有语言成分，但使用时必须符合一定的约束，受到一定的限制。OWL DL提供了描述逻辑的推理功能，描述逻辑是OWL的形式化基础。
OWL Full包含OWL的全部语言成分并取消了OWL DL中的限制，它将RDFS扩展为一个完备的本体语言，支持那些不需要可计算性保证(no computational guarantees)但需要最强表达能力和完全自由的RDFS用户。在OWL Full中，一个类可以看成是个体的集合，也可以看成是一个个体。由于OWL Full取消了基数限制中对可传递性质的约束，因此不能保证可判定推理。

OWL本体的组成

个体（individual）

个体代表领域中我们感兴趣的对象，OWL不使用唯一命名假设，即两个不同的名称可以对应一个个体（例如：“伊丽莎白女王”和“伊丽莎白温莎”是指同一个人）。在OWL中，必须明确表示个体之间是否相同，否则它们的关系是不明确的。

个体（individual）有时也被称作实例（Instance）。

属性（Property）

属性是个体之间的二元关系。在描述逻辑中，它们就是角色（Role）的概念。

按照属性的表意及性质可以分为以下四类属性：

函数属性(Functional Property)——通过这个属性只能连接一个个体，如hasBirthMother
反函数属性(Inverse Functional Property)——即这个属性的反属性是函数属性，也就是对于一个给定的个体，只有最多一个个体能通过该属性连接那个个体，如isBirthMotherOf
传递属性(Transitive Property)——这个属性是可以传递的，如你的祖先的祖先也是你的祖先，hasAncestor
对称属性(Symmetric Property)——即这个属性是对称的，一个属性是对称的那么它就不能是函数属性。如你是你的兄弟的兄弟，hasSibling

按照属性的链接对象不同可以分为以下三类：

对象属性(Object Property)——连接两个个体。
数据类型属性(Datatype Property)——连接个体和XML Schema数据类型值或rdf literal,该属性不能为传递的，对称的，反函数的。
标注属性 (Annotation Property)——用来对类，属性，个体和本体添加信息(元数据)。OWL-DL对标注属性作出了如下限制：(1)标注属性的filler只能为,literal或URI或个体。(2)标注属性没有子属性，也不能为其它属性的子属性，而且不能使用domain和range。

类（class）

表示一些个体的集合，它使用数学的方法描述出该类中成员必须具有的条件。概念（concept）这个词有时被用来代替类，实际上，类是概念的一个具体表现。

OWL中本体的结构

命名空间

在使用一组术语之前，需要精确地指出哪些具体的词汇表将会用到。一个典型的OWL本体以命名空间声明开始，这些命名空间写到rdf:RDF\标签中。

属性值是不具有命名空间的，在OWL里可以写出它们的完整URI。完整的URI中可以利用实体定义来简略。
如：

1
2
3

<!DOCTYPE rdf:RDF [
     <!ENTITY vin  "http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#" >
     <!ENTITY food "http://www.w3.org/TR/2004/REC-owl-guide-20040210/food#" > ]>

在声明这些实体后，我们可以将“&vin;merlot”作为http://www.w3.org/TR/2004/REC -owl-guide-20040210/wine#merlot的简写。

本体头部

在owl：Ontology标签中给出本体的声明。这些标签支持一些重要的常务工作比如注释、版本控制以及其他本体的嵌入等。

owl:Ontology元素是用来收集关于当前文档的OWL元数据的。

rdf:about属性为本体提供一个名称或引用。

rdfs:comment提供了显然必须的为本体添加注解的能力。

owl:priorVersion是一个为用于本体的版本控制系统提供相关信息（hook）的标准标签。本体的版本控制将在后面作进一步讨论。

owl:imports提供了一种嵌入机制。owl:imports接受一个用rdf:resource属性标识的参数。

数据集成与隐私

不同的个体成员可能表示同一个体，owl：sameAs表达等价的能力。

基本元素

简单的个体和类

外延：我们称由属于某个类的个体所构成的集合为该类的外延（extension）。

本体：为了进行相关个体的推理。

简单的具名类

一个领域中最基本的概念对应各个分类层次树的根。

。。。。国际化资源标识符（IRI）。。。。。统一资源标识符（URI）。。。。

rdf:ID=”Region” 被用于引入一个名称（作为定义的一部分）
在这一文档中，我们现在可以用#Region来引用Region类，例如 rdf:resource=”#Region”

rdfs:subClassOf是用于类的基本分类构造符，次关系是可传递的
一个类的定义由两部分组成：引入或引用一个名称，以及一个限制表。

个体

<owl:Thing rdf:ID="CentralCoastRegion" /> 
<owl:Thing rdf:about="#CentralCoastRegion"> 
<rdf:type rdf:resource="#Region"/> 
/*表示个体，type是一个rdf属性，用于关联一个个体和它所属的类*/
  	
</owl:Thing>

或者使用<Region rdf:ID="CentralCoastRegion" /> 语句来表示个体

Web本体被设计成为分布式的，我们可以通过导入和补充已有的本体来创建衍生的本体。

使用方面的考虑

一个类仅是一个名称和一些描述某集合内个体的属性；而个体是该集合的成员。因此，类应自然地对应于与某论域中的事物的出现集合，而个体应对应于可被归入这些类的实际的实体。

子类：类的子集合

实例：表示一个单一的个体

一个本体的开发应坚定地由它的预定用途所驱动。这些问题也存在于OWL Full和OWL DL之间的一个重要区别。OWL Full允许将类（class）用作实例（instance），而OWL DL不允许。

简单属性

一个属性是一个二元关系，有两种类型的属性：

数据类型属性（datatype properties）：类实例与RDF文字或XML Schema数据类型间的关系。

对象属性（object properties）：两个类的实例间的关系。

定义属性

<owl:ObjectProperty rdf:ID="madeFromGrape"> 
    <rdfs:domain rdf:resource="#Wine"/> /*表示定义域*/
    <rdfs:range rdf:resource="#WineGrape"/> /*表示值域*/
</owl:ObjectProperty>

在OWL中，一个值域可被用来推断一个类型

1
2
3

<owl:Thing rdf:ID="LindemansBin65Chardonnay">
    <madeFromGrape rdf:resource="#ChardonnayGrape" />
</owl:Thing>

可以推断出，LindemansBin65Chardonnay为一种葡萄酒，因为其定义域为wine

可以定义子属性，属性是传递的，例如X为Y的子属性，如果具有属性X，则必然同时具有属性Y。

属性和数据类型

数据类型属性：将个体关联到数据（值域为：RDF文字或XML Schema数据类型）

<owl:Class rdf:ID="VintageYear" />
<owl:DatatypeProperty rdf:ID="yearValue">
<rdfs:domain rdf:resource="#VintageYear" />
    <rdfs:range  rdf:resource="&xsd;positiveInteger"/>
</owl:DatatypeProperty>

yearValue属性将VintageYears与一个整数值相关联。

个体的属性

<Region rdf:ID="SantaCruzMountainsRegion">
    <locatedIn rdf:resource="#CaliforniaRegion" />
</Region>
<Winery rdf:ID="SantaCruzMountainVineyard" />
<CabernetSauvignon   rdf:ID="SantaCruzMountainVineyardCabernetSauvignon" >
    <locatedIn   rdf:resource="#SantaCruzMountainsRegion"/>  
    <hasMaker    rdf:resource="#SantaCruzMountainVineyard" />   
</CabernetSauvignon>

属性的特性

传递属性： P(x，y)，P(y，z) P(x，z)
对称属性： p(x，y)当且仅当P(y, x)【注意是同一个关系】
函数属性： P(x,y) 与P(x,z) 蕴含 y = z，即对应值的唯一性
逆属性（inverseOf）：P1(x,y) 当且仅当P2(y,x)【注意是不同关系】
反函数属性（InverseFunctional）：P(y,x) 与 P(z,x) 蕴含 y = z；

InverseFunctional意味着属性的值域中的元素为定义域中的每个元素提供了一个唯一的标识。

属性限制

两个属性限制机制

allValuesFrom
someValuesFrom

它们都是是局部的（local），仅仅在包含它们的类的定义中起作用。

owl:allValuesFrom属性限制要求：对于每一个有指定属性实例的类实例，该属性的值必须是由owl:allValuesFrom从句指定的类的成员。

owl:someValuesFrom限制与之相似。

例子：Wine的制造商必须是Winery。allValuesFrom限制仅仅应用在Wine的hasMaker 属性上。Cheese的制造商并不受这一局部限制的约束。（代码如下）

关系	含意
allValuesFrom	对于所有的葡萄酒，如果它们有制造商，那么所有的制造商都是酿酒厂
someValuesFrom	对于所有的葡萄酒，它们中至少有一个的制造商是酿酒厂

基数限制

owl:cardinality：这一约束允许对一个关系中的元素数目作出精确的限制。

例如，我们可以将Vintage标识为恰好含有一个VintageYear的类。

值域限制在0和1的基数表达式(Cardinality expressions)是OWL Lite的一部分。这使得用户能够表示“至少一个”，“不超过一个”，和“恰好一个”这几种意思。OWL DL中还允许使用除0与1以外的正整数值。owl:maxCardinality能够用来指定一个上界。owl:minCardinality能够用来指定一个下界。使用二者的组合就能够将一个属性的基数限制为一个数值区间。

hasValue

hasValue 使得我们能够根据“特定的”属性值的存在来标识类。因此，一个个体只要至少有“一个”属性值等于hasValue的资源，这一个体就是该类的成员。

如果是Burgundy酒，那就都是干(dry)的酒。也即，它们的hasSugar属性必须至少有一个是值等于Dry（干的）。
【我的理解是，每个Burgundy都要有一个干的（Dry）属性，以此来标识该酒是干酒】

本体映射

用于实现本体的共享。

类和属性之间的等价关系（equivalentClass，equivalentProperty）

属性owl:equivalentClass被用来表示两个类有着完全相同的实例。但我们要注意，在OWL DL中，类仅仅代表着个体的集合而不是个体本身。然而在OWL FULL中，我们能够使用owl:sameAs来表示两个类在各方面均完全一致。

类似的，我们可以通过使用owl:equivalentProperty属性声明表达属性的等同。

个体间的同一性

SameAs：描述个体之间相同的机制与描述类之间的相同机制类似，仅仅只要两个个体的声明形成一致的就可以了。

假如hasMaker是一个函数型属性，那么下面的例子就不一定会产生冲突。

<owl:Thing rdf:about="#BancroftChardonnay">
    <hasMaker rdf:resource="#Bancroft" />
    <hasMaker rdf:resource="#Beringer" />
</owl:Thing>

除非和我们本体中的其他信息发生冲突，不然的话这样的描述是没有冲突的，他说明Bancroft和Beringer是相同的个体。

要清楚，修饰（或引用）两个类用sameAs还是用equivalentClass效果是不同的。用sameAs的时候，把一个类解释为一个个体，就像在OWL Full中一样，这有利于对本体进行分类。在OWL Full中，sameAs可以用来引用两个东西，如一个类和一个个体、一个类和一个属性等等，无论什么情况，都将被解释为个体。

不同的个体

这一机制提供了与sameAs相反的效果。

说明了三个值互不相同。如果我们没有用 differentFrom元素来申明既干又甜的葡萄酒，这意味着“干葡萄酒”和“甜葡萄酒”是相同的。但是我们从上面申明的元素来推断，这又是矛盾的。还有一种更便利的定义相互不同个体的机制，如下

要注意，owl:distinctMembers属性声明只能和owl:AllDifferent属性声明一起结合使用。

复杂类

用于创建类的表达式。OWL支持基本的集合操作，即并，交和补运算。它们分别被命名为owl:unionOf,owl:intersectionOf,和owl:complementOf.此外，类还可以是枚举的。类的外延可以使用oneOf构造子来显示的声明。同时，我们也可以声明类的外延必须是互不相交的。

注意：OWL类外延是由个体组成的集合，二这些个体都是类的成员。

集合运算符

交运算

<owl:Class rdf:ID="WhiteWine">
   <owl:intersectionOf rdf:parseType="Collection"> /*这是必须的，因为必须对集合操作*/
     <owl:Class rdf:about="#Wine" />
     <owl:Restriction>
       <owl:onProperty rdf:resource="#hasColor" />
       <owl:hasValue rdf:resource="#White" />
     </owl:Restriction>
   </owl:intersectionOf>
</owl:Class>

这个例子表示，白葡萄酒就是葡萄酒和白色物体的相交的集合。如果不这么表示，计算机只知道，白葡萄酒有白色的属性；却不知道，所有白色的葡萄酒是白葡萄酒

WhiteBurgundy类恰好是白葡萄酒和Burgundies的交集。依次，Burgundies生产在法国一个叫做Bourgogne的地方并且它是干葡萄酒（dry wine）。因此，所有满足这些标准的葡萄酒个体都是WhiteBurgundy类的外延的一部分。

并运算

表示两个集合的∪。使用方法同上，将intersectionOf改成unionOf。

补运算

就是表示差集，complementOf典型的用法是与其它集合运算符联合使用，如下

上面的例子定义了一个NonFrenchWine类，它是Wine类与所有不位于法国的事物的集合的交集。

枚举类（one of）

以直接枚举的方式描述类的成员。特别的，这个定义完整的描述了类的外延（类的范围？），因此任何其他个体都不能声明为属于这个类。如下：

这段代码说明，WineColor只包含三种，white rose和red，任何其他的颜色都不是winecolor类的实例

oneOf结构的每一个元素都必须是一个有效声明的个体。一个个体必须属于某个类。在上面的例子中，每一个个体都是通过名字来引用的。我们使用owl:Thing简单地进行引用，尽管这有点多余（因为每个个体都属于owl:Thing）。另外，我们也可以根据具体类型WineColor来引用集合中的元素：

另外，较复杂的个体描述同样也可以是oneOf结构的有效元素，例如:

不相交类（disjointWith）

使用owl:disjointWith构造子可以表达一组类是不相交的。它保证了属于某一个类的个体不能同时又是另一个指定类的实例。

Pasta例子声明了多个不相交类。注意它只声明了Pasta与其它所有类是不相交的。例如，它并没有保证Meat和Fruit是不相交的。为了声明一组类是互不相交的，我们必须对每两个类都使用owl:disjointWith来声明。

在下面的例子中，我们定义了Fruit是SweetFruit和NonSweetFruit的并集。而且我们知道这些子类恰好将Fruit划分成了连个截然不同的子类，因为它们是互不相交的。随着互不相交的类的增加，不相交的声明的数目也会相应的增加到n的2次方。然而，在我们已知的用例中，n通常比较小。

本体版本控制

本体和软件一样需要维护，因此它们将随着时间的推移而改变。在一个owl:Ontology元素（如上面讨论的http://www.w3.org/TR/2004/REC-owl-guide-20040210/#OntologyHeaders）内，链接到一个以前定义的本体版本是可能的。属性owl:priorVersion被用来提供这种链接，并能用它跟踪一个本体的版本历史。

本体版本可能彼此互不兼容，例如，一个本体以前的版本可能包含与现在版本中的陈述相矛盾的陈述。在一个owl:Ontology元素中，我们使用owl:backwardCompatibleWith和owl:incompatibleWith这些属性来指出本体版本是兼容还是不兼容以前的版本。如果没有进行owl:backwardCompatibleWith声明，那么我们假定就不存在兼容性。除了上面讲到的两个属性，还有一个属性owl:versionInfo适用与版本控制系统，它提供了一些相关信息（hook）。和前面三个属性相反的是，owl:versionInfo的客体是一个文字值（literal），这一属性除了可以用来注释本体之外还可以用来注释类和属性。

Reference

XSD/XML Schema 学习笔记完整版

Posted on 2019-03-15 Edited on 2020-01-04 Valine:

注：本文摘自W3school Schema 教程

schema声明

属性大全

属性	说明	取值
id	标识该元素的唯一ID
attributeFormDefault	指定XML文档使用schema中定义的局部属性时是否必须使用命名空间限定	qualified:必须通过命名空间前缀限定、unqualified：（默认值）无须通过命名空间前缀限定
elementFormDefault	指定XML文档使用schema中定义的局部元素时是否必须使用命名空间限定	取值和含义同attributeFormDefault
blockDefault	设定schema中element和complexType上的block属性的默认值、block属性用来阻止以指定的派生类型代替原类型	#all或者extension、restriction和substitution的自由组合、例如extension表示防止通过扩展派生的复杂类型替代该复杂类型
finalDefault	设定schema中element、simpleType和complexType上的final的默认值、final属性用来阻止以指定的派生类型来派生新类型	对于element和complexType：值可以是#all或extension和restriction的自由组合、对于simpleType：值可以是#all或restriction、list和union的自由组合
targetNamespace	设定schema的命名空间的URI引用
version	设定schema的版本
xmlns	设定schema使用的一个或多个命名空间的URI引用
any attributes	设定带有non-schema命名空间的任何其他属性

<schema> 声明

<schema> 元素是每一个 XML Schema 的根元素：
<?xml version=”1.0”?>

<xs:schema>

...
...

</xs:schema>

<schema> 元素可包含属性。一个 schema 声明往往看上去类似这样：

<?xml version="1.0"?>
 
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3school.com.cn"
xmlns="http://www.w3school.com.cn"
elementFormDefault="qualified">

...
...
</xs:schema>

代码解释

1	xmlns:xs="http://www.w3.org/2001/XMLSchema"

显示 schema 中用到的元素和数据类型来自命名空间 http://www.w3.org/2001/XMLSchema。

同时它还规定了来自命名空间 http://www.w3.org/2001/XMLSchema的元素和数据类型应该使用前缀 xs。

1	targetNamespace="http://www.w3school.com.cn"

显示被此 schema 定义的元素 (note, to, from, heading, body) 来自命名空间： http://www.w3school.com.cn。

1	xmlns="http://www.w3school.com.cn"

指出默认的命名空间是 http://www.w3school.com.cn。

1	elementFormDefault="qualified"

指出任何 XML 实例文档所使用的且在此 schema 中声明过的元素必须被命名空间限定。

在 XSD 文档中引用其他Schema

引用方式有两种：

include
import

import与include的作用是一样的。区别在于import是导入另外一个命名空间的xsd，而inlude是包含同一个命名空间的xsd。

例子

1	<xsd:include schemaLocation="module/owl1-lite-core.xsd" />

<xsd:import namespace="http://www.w3.org/XML/1998/namespace" 
            schemaLocation="xml.xsd">
  <!-- "http://www.w3.org/2001/xml.xsd" -->
  <xsd:annotation>
    <xsd:documentation>
      Get access to the xml: attribute groups for xml:lang
      as declared on 'Label' and 'Documentation' below 
    </xsd:documentation>
  </xsd:annotation>
</xsd:import>

在 XML 文档中引用 Schema

此 XML 文档含有对 XML Schema 的引用：

<?xml version="1.0"?>

<note xmlns="http://www.w3school.com.cn"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.w3school.com.cn note.xsd">

<to>George</to>
<from>John</from>
<heading>Reminder</heading>
<body>Don't forget the meeting!</body>
</note>

代码解释

1	xmlns="http://www.w3school.com.cn"

规定了默认命名空间的声明。此声明会告知 schema 验证器，在此 XML 文档中使用的所有元素都被声明于 http://www.w3school.com.cn 这个命名空间。

一旦您拥有了可用的 XML Schema 实例命名空间：

1	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

您就可以使用 schemaLocation 属性了。此属性有两个值。第一个值是需要使用的命名空间。第二个值是供命名空间使用的 XML schema 的位置：

1	xsi:schemaLocation="http://www.w3school.com.cn note.xsd"

简单类型

元素

1	<xs:element name="xxx" type="yyy"/>

常用类型：

xs:string
xs:decimal
xs:integer
xs:boolean
xs:date
xs:time

默认值和固定值

缺省值（默认值）设置：

1	<xs:element name="color" type="xs:string" default="red"/>

固定值设置：

1	<xs:element name="color" type="xs:string" fixed="red"/>

例子

这是一些 XML 元素：

1
2
3

<lastname>Smith</lastname>
<age>28</age>
<dateborn>1980-03-27</dateborn>

这是相应的简易元素定义：

1
2
3

<xs:element name="lastname" type="xs:string"/>
<xs:element name="age" type="xs:integer"/>
<xs:element name="dateborn" type="xs:date"/>

列表

语法

<list
id=ID 
itemType=QName 
any attributes
>

(annotation?,(simpleType?))

</list>

属性	描述
id	可选。规定该元素的唯一的 ID。
itemType	在该 schema（或由指定的命名空间指示的其他 schema）中定义的内置数据类型或 simpleType 元素的名称。包含 list 元素的 simpleType 元素是从 list 值指定的简单类型派生的。list 值必须是限定名 (QName)。如果内容包含 simpleType 元素，则不允许使用该属性，否则该属性是必需的。
any attributes	可选。规定带有 non-schema 命名空间的任何其他属性。

例子

下面的例子展示了为一列整数的简单类型：

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="intvalues" type="valuelist">

<xs:simpleType name="valuelist">
  <xs:list itemType="xs:integer"/>
</xs:simpleType>

</xs:schema>

文档中的 “intvalues” 元素类似这样（注意这个列表有五个列表项）：

1	<intvalues>100 34 56 -23 1567</intvalues>

注释：空格被作为列表项的分隔符

属性

1	<xs:attribute name="xxx" type="yyy"/>

常用类型：

xs:string
xs:decimal
xs:integer
xs:boolean
xs:date
xs:time

例子

这是带有属性的 XML 元素：

1	<lastname lang="EN">Smith</lastname>

这是对应的属性定义：

1	<xs:attribute name="lang" type="xs:string"/>

默认值和固定值

缺省值（默认值）设置：

1	<xs:attribute name="lang" type="xs:string" default="EN"/>

固定值设置：

1	<xs:attribute name="lang" type="xs:string" fixed="EN"/>

可选和必选

在缺省的情况下，属性是可选的。如需规定属性为必选，请使用 “use” 属性：

1	<xs:attribute name="lang" type="xs:string" use="required"/>

对值的限定

下面的例子定义了带有一个限定且名为 “age” 的元素。age 的值不能低于 0 或者高于 120：

<xs:element name="age">

<xs:simpleType>
  <xs:restriction base="xs:integer">
    <xs:minInclusive value="0"/>
    <xs:maxInclusive value="120"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

对一组值的限定

如需把 XML 元素的内容限制为一组可接受的值，我们要使用枚举约束（enumeration constraint）。

下面的例子定义了带有一个限定的名为 “car” 的元素。可接受的值只有：Audi, Golf, BMW：

<xs:element name="car">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:enumeration value="Audi"/>
    <xs:enumeration value="Golf"/>
    <xs:enumeration value="BMW"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

上面的例子也可以被写为：

<xs:element name="car" type="carType"/>

<xs:simpleType name="carType">
  <xs:restriction base="xs:string">
    <xs:enumeration value="Audi"/>
    <xs:enumeration value="Golf"/>
    <xs:enumeration value="BMW"/>
  </xs:restriction>
</xs:simpleType>

注释：在这种情况下，类型 “carType” 可被其他元素使用，因为它不是 “car” 元素的组成部分。

对一系列值的限定

如需把 XML 元素的内容限制定义为一系列可使用的数字或字母，我们要使用模式约束（pattern constraint）。

下一个例子也定义了带有一个限定的名为 “initials” 的元素。可接受的值是大写或小写字母 a - z 其中的三个：

<xs:element name="initials">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="[a-zA-Z][a-zA-Z][a-zA-Z]"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

下一个例子定义了带有一个限定的名为 “choice 的元素。可接受的值是字母 x, y 或 z 中的一个：

<xs:element name="choice">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="[xyz]"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

对一系列值的其他限定

下面的例子定义了带有一个限定的名为 “letter” 的元素。可接受的值是 a - z 中零个或多个字母：

<xs:element name="letter">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="([a-z])*"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

下面的例子定义了带有一个限定的名为 “letter” 的元素。可接受的值是一对或多对字母，每对字母由一个小写字母后跟一个大写字母组成。举个例子，”sToP”将会通过这种模式的验证，但是 “Stop”、”STOP” 或者 “stop” 无法通过验证：

<xs:element name="letter">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="([a-z][A-Z])+"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

下面的例子定义了带有一个限定的名为 “gender” 的元素。可接受的值是 male 或者 female：

<xs:element name="gender">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="male|female"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

下面的例子定义了带有一个限定的名为 “password” 的元素。可接受的值是由 8 个字符组成的一行字符，这些字符必须是大写或小写字母 a - z 亦或数字 0 - 9：

<xs:element name="password">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="[a-zA-Z0-9]{8}"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

对空白字符的限定

如需规定对空白字符（whitespace characters）的处理方式，我们需要使用 whiteSpace 限定。

下面的例子定义了带有一个限定的名为 “address” 的元素。这个 whiteSpace 限定被设置为 “preserve”，这意味着 XML 处理器不会移除任何空白字符：

<xs:element name="address">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:whiteSpace value="preserve"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

这个例子也定义了带有一个限定的名为 “address” 的元素。这个 whiteSpace 限定被设置为 “replace”，这意味着 XML 处理器将移除所有空白字符（换行、回车、空格以及制表符）：

<xs:element name="address">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:whiteSpace value="replace"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

这个例子也定义了带有一个限定的名为 “address” 的元素。这个 whiteSpace 限定被设置为 “collapse”，这意味着 XML 处理器将移除所有空白字符（换行、回车、空格以及制表符会被替换为空格，开头和结尾的空格会被移除，而多个连续的空格会被缩减为一个单一的空格）：

<xs:element name="address">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:whiteSpace value="collapse"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

对长度的限定

如需限制元素中值的长度，我们需要使用 length、maxLength 以及 minLength 限定。

本例定义了带有一个限定且名为 “password” 的元素。其值必须精确到 8 个字符：

<xs:element name="password">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:length value="8"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

这个例子也定义了带有一个限定的名为 “password” 的元素。其值最小为 5 个字符，最大为 8 个字符：

<xs:element name="password">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:minLength value="5"/>
    <xs:maxLength value="8"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

数据类型的限定

限定	描述
enumeration	定义可接受值的一个列表
fractionDigits	定义所允许的最大的小数位数。必须大于等于0。
length	定义所允许的字符或者列表项目的精确数目。必须大于或等于0。
maxExclusive	定义数值的上限。所允许的值必须小于此值。
maxInclusive	定义数值的上限。所允许的值必须小于或等于此值。
maxLength	定义所允许的字符或者列表项目的最大数目。必须大于或等于0。
minExclusive	定义数值的下限。所允许的值必需大于此值。
minInclusive	定义数值的下限。所允许的值必需大于或等于此值。
minLength	定义所允许的字符或者列表项目的最小数目。必须大于或等于0。
pattern	定义可接受的字符的精确序列。
totalDigits	定义所允许的阿拉伯数字的精确位数。必须大于0。
whiteSpace	定义空白字符（换行、回车、空格以及制表符）的处理方式。

复杂类型

元素

四种类型的复合元素：

空元素
包含其他元素的元素
仅包含文本的元素
包含元素和文本的元素

注释：上述元素均可包含属性！

例子

<employee>
<firstname>John</firstname>
<lastname>Smith</lastname>
</employee>

的XML Schema可以写成：

<xs:element name="employee">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="firstname" type="xs:string"/>
      <xs:element name="lastname" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

或者：

<xs:element name="employee" type="personinfo"/>

<xs:complexType name="personinfo">
  <xs:sequence>
    <xs:element name="firstname" type="xs:string"/>
    <xs:element name="lastname" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

也可以在已有的复合元素之上以某个复合元素为基础，然后添加一些元素，就像这样：

<xs:element name="employee" type="fullpersoninfo"/>

<xs:complexType name="personinfo">
  <xs:sequence>
    <xs:element name="firstname" type="xs:string"/>
    <xs:element name="lastname" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

<xs:complexType name="fullpersoninfo">
  <xs:complexContent>
    <xs:extension base="personinfo">
      <xs:sequence>
        <xs:element name="address" type="xs:string"/>
        <xs:element name="city" type="xs:string"/>
        <xs:element name="country" type="xs:string"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

空元素

一个空的 XML 元素：

1	<product prodid="1345" />

上面的 “product” 元素根本没有内容。为了定义无内容的类型，我们就必须声明一个在其内容中只能包含元素的类型，但是实际上我们并不会声明任何元素，比如这样：

<xs:element name="product">
  <xs:complexType>
    <xs:complexContent>
      <xs:restriction base="xs:integer">
        <xs:attribute name="prodid" type="xs:positiveInteger"/>
      </xs:restriction>
    </xs:complexContent>
  </xs:complexType>
</xs:element>

或者：

<xs:element name="product">
  <xs:complexType>
    <xs:attribute name="prodid" type="xs:positiveInteger"/>
  </xs:complexType>
</xs:element>

or：

<xs:element name="product" type="prodtype"/>

<xs:complexType name="prodtype">
  <xs:attribute name="prodid" type="xs:positiveInteger"/>
</xs:complexType>

仅含元素

XML 元素，”person”，仅包含其他的元素：

<person>
<firstname>John</firstname>
<lastname>Smith</lastname>
</person>

可在 schema 中这样定义 “person” 元素：

<xs:element name="person">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="firstname" type="xs:string"/>
      <xs:element name="lastname" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

或者：

<xs:element name="person" type="persontype"/>

<xs:complexType name="persontype">
  <xs:sequence>
    <xs:element name="firstname" type="xs:string"/>
    <xs:element name="lastname" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

仅含文本

此类型仅包含简易的内容（文本和属性），因此我们要向此内容添加 simpleContent 元素。当使用简易内容时，我们就必须在 simpleContent 元素内定义扩展或限定，就像这样：

<xs:element name="某个名称">
  <xs:complexType>
    <xs:simpleContent>
      <xs:extension base="basetype">
        ....
        ....
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
</xs:element>

或者：

<xs:element name="某个名称">
  <xs:complexType>
    <xs:simpleContent>
      <xs:restriction base="basetype">
        ....
        ....
      </xs:restriction>
    </xs:simpleContent>
  </xs:complexType>
</xs:element>

例子

1	<shoesize country="france">35</shoesize>

下面这个例子声明了一个复合类型，其内容被定义为整数值，并且 “shoesize” 元素含有名为 “country” 的属性：

<xs:element name="shoesize">
  <xs:complexType>
    <xs:simpleContent>
      <xs:extension base="xs:integer">
        <xs:attribute name="country" type="xs:string" />
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
</xs:element>

我们也可为 complexType 元素设定一个名称，并让 “shoesize” 元素的 type 属性来引用此名称（通过使用此方法，若干元素均可引用相同的复合类型）：

<xs:element name="shoesize" type="shoetype"/>

<xs:complexType name="shoetype">
  <xs:simpleContent>
    <xs:extension base="xs:integer">
      <xs:attribute name="country" type="xs:string" />
    </xs:extension>
  </xs:simpleContent>
</xs:complexType>

混合内容

带有混合内容的复合类型
XML 元素，”letter”，含有文本以及其他元素：

<letter>
Dear Mr.<name>John Smith</name>.
Your order <orderid>1032</orderid>
will be shipped on <shipdate>2001-07-13</shipdate>.
</letter>

下面这个 schema 声明了这个 “letter” 元素：

<xs:element name="letter">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="orderid" type="xs:positiveInteger"/>
      <xs:element name="shipdate" type="xs:date"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

注释：为了使字符数据可以出现在 “letter” 的子元素之间，mixed 属性必须被设置为 “true”。xs:sequence\ 标签 (name、orderid 以及 shipdate ) 意味着被定义的元素必须依次出现在 “letter” 元素内部。

或者：

<xs:element name="letter" type="lettertype"/>

<xs:complexType name="lettertype" mixed="true">
  <xs:sequence>
    <xs:element name="name" type="xs:string"/>
    <xs:element name="orderid" type="xs:positiveInteger"/>
    <xs:element name="shipdate" type="xs:date"/>
  </xs:sequence>
</xs:complexType>

指示器

七种指示器：

Order 指示器：

All
Choice
Sequence

Occurrence 指示器：

maxOccurs
minOccurs

Group 指示器：

Group name
attributeGroup name

ALL

<all> 指示器规定子元素可以按照任意顺序出现，且每个子元素必须只出现一次.

当使用 <all> 指示器时，你可以把 <minOccurs> 设置为 0 或者 1，而只能把 <maxOccurs> 指示器设置为 1

<xs:element name="person">
  <xs:complexType>
    <xs:all>
      <xs:element name="firstname" type="xs:string"/>
      <xs:element name="lastname" type="xs:string"/>
    </xs:all>
  </xs:complexType>
</xs:element>

Choice

<choice> 指示器规定可出现某个子元素或者可出现另外一个子元素（非此即彼）,如需设置子元素出现任意次数，可将 <maxOccurs> 设置为 unbounded（无限次）：

<xs:element name="person">
  <xs:complexType>
    <xs:choice>
      <xs:element name="employee" type="employee"/>
      <xs:element name="member" type="member"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

Sequence

<sequence> 规定子元素必须按照特定的顺序出现：

<xs:element name="person">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="firstname" type="xs:string"/>
      <xs:element name="lastname" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

maxOccurs

Occurrence 指示器用于定义某个元素出现的频率。对于所有的 “Order” 和 “Group” 指示器（any、all、choice、sequence、group name 以及 group reference），其中的 maxOccurs 以及 minOccurs 的默认值均为 1。

<maxOccurs>指示器可规定某个元素可出现的最大次数,如需使某个元素的出现次数不受限制，可以使用 maxOccurs=”unbounded” 这个声明：

<xs:element name="person">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="full_name" type="xs:string"/>
      <xs:element name="child_name" type="xs:string" maxOccurs="10"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

minOccurs

<minOccurs>指示器可规定某个元素能够出现的最小次数：

<xs:element name="person">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="full_name" type="xs:string"/>
      <xs:element name="child_name" type="xs:string"
      maxOccurs="10" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

Group name

元素组通过 group 声明进行定义：

1
2
3

<xs:group name="组名称">
  ...
</xs:group>

您必须在 group 声明内部定义一个 all、choice 或者 sequence 元素。下面这个例子定义了名为 “persongroup” 的 group，它定义了必须按照精确的顺序出现的一组元素：

<xs:group name="persongroup">
  <xs:sequence>
    <xs:element name="firstname" type="xs:string"/>
    <xs:element name="lastname" type="xs:string"/>
    <xs:element name="birthday" type="xs:date"/>
  </xs:sequence>
</xs:group>

在您把 group 定义完毕以后，就可以在另一个定义中引用它了：

<xs:group name="persongroup">
  <xs:sequence>
    <xs:element name="firstname" type="xs:string"/>
    <xs:element name="lastname" type="xs:string"/>
    <xs:element name="birthday" type="xs:date"/>
  </xs:sequence>
</xs:group>

<xs:element name="person" type="personinfo"/>

<xs:complexType name="personinfo">
  <xs:sequence>
    <xs:group ref="persongroup"/>
    <xs:element name="country" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

attributeGroup name

属性组通过 attributeGroup 声明来进行定义：

1
2
3

<xs:attributeGroup name="组名称">
  ...
</xs:attributeGroup>

下面这个例子定义了名为 “personattrgroup” 的一个属性组：

<xs:attributeGroup name="personattrgroup">
  <xs:attribute name="firstname" type="xs:string"/>
  <xs:attribute name="lastname" type="xs:string"/>
  <xs:attribute name="birthday" type="xs:date"/>
</xs:attributeGroup>

在您已定义完毕属性组之后，就可以在另一个定义中引用它了，就像这样：

<xs:attributeGroup name="personattrgroup">
  <xs:attribute name="firstname" type="xs:string"/>
  <xs:attribute name="lastname" type="xs:string"/>
  <xs:attribute name="birthday" type="xs:date"/>
</xs:attributeGroup>

<xs:element name="person">
  <xs:complexType>
    <xs:attributeGroup ref="personattrgroup"/>
  </xs:complexType>
</xs:element>

<any>

<any> 元素使我们有能力通过未被 schema 规定的元素来拓展 XML 文档！
下面这个例子是从名为 “family.xsd” 的 XML schema 中引用的片段。它展示了一个针对 “person” 元素的声明。通过使用 <any> 元素，我们可以通过任何元素（在 <lastname> 之后）扩展 “person” 的内容：

<xs:element name="person">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="firstname" type="xs:string"/>
      <xs:element name="lastname" type="xs:string"/>
      <xs:any minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

<anyAttribute>

<anyAttribute> 元素使我们有能力通过未被 schema 规定的属性来扩展 XML 文档！
下面的例子是来自名为 “family.xsd” 的 XML schema 的一个片段。它为我们展示了针对 “person” 元素的一个声明。通过使用 <anyAttribute> 元素，我们就可以向 “person” 元素添加任意数量的属性：

<xs:element name="person">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="firstname" type="xs:string"/>
      <xs:element name="lastname" type="xs:string"/>
    </xs:sequence>
    <xs:anyAttribute/>
  </xs:complexType>
</xs:element>

元素替换

让我们举例说明：我们的用户来自英国和挪威。我们希望有能力让用户选择在 XML 文档中使用挪威语的元素名称还是英语的元素名称。
为了解决这个问题，我们可以在 XML schema 中定义一个 substitutionGroup。首先，我们声明主元素，然后我们会声明次元素，这些次元素可声明它们能够替换主元素。

<xs:element name="name" type="xs:string"/>
<xs:element name="navn" substitutionGroup="name"/>

<xs:complexType name="custinfo">
  <xs:sequence>
    <xs:element ref="name"/>
  </xs:sequence>
</xs:complexType>

<xs:element name="customer" type="custinfo"/>
<xs:element name="kunde" substitutionGroup="customer"/>

有效的 XML 文档类似这样（根据上面的 schema）：

1
2
3

<customer>
  <name>John Smith</name>
</customer>

或类似这样：

1
2
3

<kunde>
  <navn>John Smith</navn>
</kunde>

如果需要阻止元素替换，可使用 block 属性：

1	<xs:element name="name" type="xs:string" block="substitution"/>

请注意，substitutionGroup 中的所有元素（主元素和可替换元素）必须被声明为全局元素，否则就无法工作！

全局元素指 “schema” 元素的直接子元素！本地元素（Local elements）指嵌套在其他元素中的元素。

数据类型

字符串

字符串数据类型（String Data Type）

字符串数据类型可包含字符、换行、回车以及制表符。如果您使用字符串数据类型，XML 处理器就不会更改其中的值。

1	<xs:element name="customer" type="xs:string"/>

规格化字符串数据类型（NormalizedString Data Type）

规格化字符串数据类型同样可包含字符，但是 XML 处理器会移除折行，回车以及制表符。

下面是一个关于在某个 schema 中规格化字符串数据类型的例子：

1	<xs:element name="customer" type="xs:normalizedString"/>

文档中的元素看上去应该类似这样：

1	<customer>John Smith</customer>

或者类似这样：

1	<customer> John Smith </customer>

注释：在上面的例子中，XML 处理器会使用空格替换所有的制表符。

Token 数据类型（Token Data Type）

Token 数据类型同样可包含字符，但是 XML 处理器会移除换行符、回车、制表符、开头和结尾的空格以及（连续的）空格。

下面是在 schema 中一个有关 token 声明的例子：

1	<xs:element name="customer" type="xs:token"/>

文档中的元素看上去应该类似这样：

1	<customer>John Smith</customer>

或者类似这样：

1	<customer> John Smith </customer>

注释：在上面这个例子中，XML 解析器会移除制表符。

字符串数据类型

名称	描述
ENTITIES
ENTITY
ID	在 XML 中提交 ID 属性的字符串 (仅与 schema 属性一同使用)
IDREF	在 XML 中提交 IDREF 属性的字符串(仅与 schema 属性一同使用)
IDREFS language	包含合法的语言 id 的字符串
Name	包含合法 XML 名称的字符串
NCName	`NCName ::= (Letter
NMTOKEN	在 XML 中提交 NMTOKEN 属性的字符串 (仅与 schema 属性一同使用)
NMTOKENS
normalizedString	不包含换行符、回车或制表符的字符串
QName	`QName ::= (Prefix ':')? LocalPart` `Prefix ::= NCName` `LocalPart ::= NCName`
string	字符串
token	不包含换行符、回车或制表符、开头或结尾空格或者多个连续空格的字符串

对字符串数据类型的限定（Restriction）

可与字符串数据类型一同使用的限定：

enumeration
length
maxLength
minLength
pattern (NMTOKENS、IDREFS 以及 ENTITIES 无法使用此约束)
whiteSpace

日期

日期数据类型（Date Data Type）

日期使用此格式进行定义：”YYYY-MM-DD”

下面是一个有关 schema 中日期声明的例子：

1	<xs:element name="start" type="xs:date"/>

文档中的元素看上去应该类似这样：

1	<start>2002-09-24</start>

如需规定一个时区，您也可以通过在日期后加一个 “Z” 的方式，使用世界调整时间（UTC time）来输入一个日期 - 比如这样：

1	<start>2002-09-24Z</start>

或者也可以通过在日期后添加一个正的或负时间的方法，来规定以世界调整时间为准的偏移量 - 比如这样：

1	<start>2002-09-24-06:00</start>

或者：

1	<start>2002-09-24+06:00</start>

时间数据类型（Time Data Type）

时间使用下面的格式来定义：”hh:mm:ss”

下面是一个有关 schema 中时间声明的例子：

1	<xs:element name="start" type="xs:time"/>

时区同上

日期时间数据类型（DateTime Data Type）

日期时间使用下面的格式进行定义：”YYYY-MM-DDThh:mm:ss”

下面是一个有关 schema 中日期时间声明的例子：

1	<xs:element name="startdate" type="xs:dateTime"/>

1	<startdate>2002-05-30T09:00:00</startdate>

时区同上

持续时间数据类型（Duration Data Type）

时间间隔使用下面的格式来规定：”PnYnMnDTnHnMnS”，其中：

P 表示周期(必需)
nY 表示年数
nM 表示月数
nD 表示天数
T 表示时间部分的起始（如果您打算规定小时、分钟和秒，则此选项为必需）
nH 表示小时数
nM 表示分钟数
nS 表示秒数

如需规定一个负的持续时间，请在 P 之前输入减号：

1	<period>-P10D</period>

日期和时间数据类型

名称	描述
date	定义一个日期值
dateTime	定义一个日期和时间值
duration	定义一个时间间隔
gDay	定义日期的一个部分 - 天 (DD)
gMonth	定义日期的一个部分 - 月 (MM)
gMonthDay	定义日期的一个部分 - 月和天 (MM-DD)
gYear	定义日期的一个部分 - 年 (YYYY)
gYearMonth	定义日期的一个部分 - 年和月 (YYYY-MM)
time	定义一个时间值

对日期数据类型的限定（Restriction）

可与日期数据类型一同使用的限定：

enumeration
maxExclusive
maxInclusive
minExclusive
minInclusive
pattern
whiteSpace

数值

十进制数据类型

1	<xs:element name="prize" type="xs:decimal"/>

您可规定的十进制数字的最大位数是 18 位。

整数数据类型

1	<xs:element name="prize" type="xs:integer"/>

数值数据类型

名字	秒数
byte	有正负的 8 位整数
decimal	十进制数
int	有正负的 32 位整数
integer	整数值
long	有正负的 64 位整数
negativeInteger	仅包含负值的整数 ( .., -2, -1.)
nonNegativeInteger	仅包含非负值的整数 (0, 1, 2, ..)
nonPositiveInteger	仅包含非正值的整数 (.., -2, -1, 0)
positiveInteger	仅包含正值的整数 (1, 2, ..)
short	有正负的 16 位整数
unsignedLong	无正负的 64 位整数
unsignedInt	无正负的 32 位整数
unsignedShort	无正负的 16 位整数
unsignedByte	无正负的 8 位整数

对数值数据类型的限定（Restriction）

可与数值数据类型一同使用的限定：

enumeration
fractionDigits
maxExclusive
maxInclusive
minExclusive
minInclusive
pattern
totalDigits
whiteSpace

杂项

其他杂项数据类型包括逻辑、base64Binary、十六进制、浮点、双精度、anyURI、anyURI 以及 NOTATION。

逻辑数据类型（Boolean Data Type）

逻辑数据性用于规定 true 或 false 值。

1	<xs:attribute name="disabled" type="xs:boolean"/>

合法的布尔值是 true、false、1（表示 true）以及 0（表示 false）。

二进制数据类型（Binary Data Types）

二进制数据类型用于表达二进制形式的数据。

我们可使用两种二进制数据类型：

base64Binary (Base64 编码的二进制数据)
hexBinary (十六进制编码的二进制数据)

下面是一个关于某个 scheme 中 hexBinary 声明的例子：

1	<xs:element name="blobsrc" type="xs:hexBinary"/>

AnyURI 数据类型（AnyURI Data Type）

anyURI 数据类型用于规定 URI。

下面是一个关于某个 scheme 中 anyURI 声明的例子：

1	<xs:attribute name="src" type="xs:anyURI"/>

文档中的元素看上去应该类似这样：

1	<pic src="http://www.w3school.com.cn/images/smiley.gif" />

注释：假如某个 URI 含有空格，请用 %20 替换它们。

杂项数据类型（Miscellaneous Data Types）

anyURI
base64Binary
boolean
double
float
hexBinary
NOTATION
QName

对杂项数据类型的限定（Restriction）

可与杂项数据类型一同使用的限定：

enumeration (布尔数据类型无法使用此约束*)
length (布尔数据类型无法使用此约束)
maxLength (布尔数据类型无法使用此约束)
minLength (布尔数据类型无法使用此约束)
pattern
whiteSpace

商业模式新生代读书笔记三

Posted on 2019-03-12 Valine:

设计

商业人士不仅需要更好的了解设计，他们更需要把自己变成设计师。

————Roger Martin

客户洞察
创意构思
可视思考
原型创作
故事讲述
情景推测

客户洞察

移情图

创意构思

4类不同集中点的商业模式创新：

资源驱动
产品/服务驱动
客户驱动
财务驱动
多中心驱动（未纳入四大类之中，是上述四种的混合，更多的表现为业务的重构）

创意构思过程

团队构成：团队是否有足够的多样性，来创造新的商业模式构想
全情投入/头脑风暴：在创新之前，需要研究哪些要素
扩展：针对每个构造块，能够想到哪些创新
条件筛选：什么事商业模式创新的最重要准则
原型创作：每个入围创意的完整商业模式应该是什么样子

头脑风暴的规则

保持聚焦：从问题的精确表述开始，不能跑题太远
执行规则：暂缓判决/一次一议/争取数量/视觉化/鼓励疯狂创意
可视思考：把创意写下来，在每个人都能看得到的平面上描绘出来
做好准备：头脑风暴前要有充分的了解与思考

可视思考

将模式描绘出来，这个模式就转换成一个持久的事物，也是一个可以随时返回讨论的概念原点。

视觉化的故事讲述活动

原型制作

原型制作可以让概念变得更加形象具体，并能促进新创意的探索。

设计理念

如果过快地专注于一个创意，你就会迷上它。如果急于精雕细琢某个创意，你就会变得依附于它，很难保持不断的探索、不断寻找更好的创意。对于那些不成熟的早期模型尤其需要审慎小心。

Jin Glymph，盖里公司合伙人

具体步骤

故事讲述

为什么要讲故事

让新创意不再抽象
- 让商业模式不再抽象
  - 公司视角
  - 客户视角
- 让未来变得不再抽象
  - 激发创意
  - 证明变革
要讲的清晰易懂
调动员工的积极性

技巧

技巧有很多，要充分了解谁是你的听众，你会出席什么场合，再来选择一种匹配的技巧。

情景推测

两种情景推测：

描述不同的客户背景：客户事如何使用产品和服务的，什么类型的客户在使用它们，客户的顾虑、愿望和目的分别是什么
描述新商业模式可能会参与竞争的未来场景：这里的目的不是要去预测未来，而是要具体形象地草绘出未来的各种可能情况。

未来的情景推测和新型商业模式

商业模式新生代读书笔记二

Posted on 2019-03-11 Valine:

商业模式式样

建筑中的式样就是将原型和原形的再现抽象为建筑设计的概念

——Christopher Alexander

商业模式式样

非绑定式商业模式
长尾式商业模式
多边平台式商业模式
免费式商业模式
开放式商业模式

非绑定式商业模式

三种基础业务：

客户关系型业务
产品创新型业务
基础设施型业务

长尾式商业模式

核心：多样少量

式样

多边平台式商业模式

多边平台将两个或者更多有明显区别但有互相依赖的客户群体集合在一起。

式样

免费式商业模式

至少有一个庞大的用户细分群体可以享受持续的免费服务
免费服务可以来自多种模式

通过该商业模式的其他部分或其他客户细分群体，给分服务用户细分群体提供财务支持。

免费广告：多边平台的式样

免费式样

诱钓式样

开放式商业模式

开放式商业模式可以用哪些通过与外部伙伴系统合作，来创造和捕捉价值的企业。

由外到内：将外部创意引入到公司内部
由内到外：将企业内部闲置的创意和资产提供给外部伙伴

由外到内的式样

由内到外的式样

总览

商业模式新生代读书笔记一

Posted on 2019-03-06 Edited on 2019-03-07 Valine:

商业模式画布

商业模式定义：

商业模式描述了企业如何创造价值，传递价值和获取价值的基本原理

苹果iPod/iTunes商业模式案例

9个构造块详细说明

CS：客户细分 customer segments
VP：价值主张 value propositions
CH：渠道通路 channel
CR：客户关系 customer relationships
R$: 收入来源 revenue streams
KR：核心资源 key resources
KA：关键业务 key activities
KP：重要合作 key partnerships
C$：成本结构 cost structure

这9个商业模式构造块组成了构建商业模式边界工具的基础，这个工具我们称之为商业模式画布（Business Model Canvas）

客户细分

划分依据：

满足需求的产品服务
分销渠道
类型关系
盈利能力
客户的提供物

价值主张

例子：新颖、性能、定制化、成分削减、风险抑制、可达性等

渠道通路

客户关系

客户关系被以下几个动机所驱动：

客户获取
客户维系
提升销售额（追加销售）

例子：个人助理、自助服务、社区、共同创作等

收入来源

一个商业模式可以包含两种不同类型的收入来源：

通过客户一次性支付获得的交易收入
经常性收入来自客户为获得价值主张与售后服务而持续支付的费用

获取收入的方式：资产销售、使用收费、订阅收费、租赁收费、授权收费等

核心资源

核心资源用来描绘让商业模式有效运转所必须的最重要因素

核心资源分类：

实体资产
知识资产
人力资源
金融资源

关键业务

关键业务分类：

制造产品
问题解决
平台/网络

重要合作

合作关系可以分为以下四类：

在非竞争者之间的战略联盟关系
竟合：在竞争者之间的战略合作关系
为开发新业务而构建的合资关系
为确保可靠供应的购买方——供应商关系

以下三种动机有助于创建合作关系：

商业模式的优化和规模经济的运用
风险和不确定性的降低
特定资源和业务的获取

成本结构

两种商业模式成本结构类型：

成本驱动
价值驱动

成本结构有以下特点：

固定成本
可变成本
规模经济
范围经济

浙大邮箱第三方登录设置方法

Posted on 2019-03-05 Valine:

第三方邮箱客户端（outlook、foxmail、各种手机自带邮箱APP等）可以选择IMAP或者POP3两种协议中的任意一种进行设置，设置方法如下：

客户端使用IMAP协议设置方法：

接收邮件服务器：imap.zju.edu.cn 端口：143 使用SSL端口：993

发送邮件服务器：smtp.zju.edu.cn 端口：25 使用SSL端口：994

客户端使用POP3协议设置方法：

接收邮件服务器：pop3.zju.edu.cn 端口：110 使用SSL端口：995

发送邮件服务器：smtp.zju.edu.cn 端口：25 使用SSL端口：994

note: 如果一种不行就试一下另一种，再不行重启试试
怎么都不行的时候可能是网络问题，本人的mac用实验室的wifi可以上网却连不上邮箱，但是手机热点就可以

mac显示隐藏文件/文件夹快捷键

Posted on 2019-01-13 Valine:

Finder（访达）在最前端的时候，三个键一起按下即可

Shift + Command + .

注意：最后一个是点不是逗号

C_Meng

This site is primarily used for personal note-taking, and some content are from open access, with sources clearly indicated. If there are any copyright issues, please feel free to contact us. 本站主要用于个人笔记记录，存在部分内容引用，均已表明出处，如存在版权问题，敬请联系。

GitHub E-Mail Weibo Twitter