SDO 2.1.0：Java服务数据对象规范详解

需积分: 10 105 浏览量更新于2024-07-27 收藏 635KB PDF 举报

SDO (Service Data Objects) 是一种在 SCA (Service Component Architecture) 面向服务架构中用于传输数据的标准，特别适用于分布式系统和服务集成环境中。SDO 2.1.0 是一个版本更新，发布于2006年11月，由多个来自知名公司如 BEA Systems、IBM、Oracle、Primeton Technologies Ltd.、RogueWave Software、SAP AG、Software AG、Sun Microsystems、Sybase Inc. 和 Xcalia 的专家共同编撰和维护。该文档详细阐述了如何在Java环境中设计和实现服务数据对象，以支持跨系统交互中的数据交换。它定义了SDO的核心概念，包括数据模型的表示、存储和访问机制，以及如何通过标准接口进行数据操作。SDO 提供了一种标准化的方式来处理复杂的数据结构，使得服务之间能够无缝地共享和处理数据，从而提高了应用的灵活性和互操作性。 SDO 2.1.0 版本包含了版权声明，强调所有内容受版权所有者（如 BEA Systems、IBM、Oracle等）保护，并且根据特定的许可证协议进行分发。用户在使用和复制这个规范时，必须遵守这些条款，确保尊重知识产权并遵循许可条件。文档的核心内容可能包括以下几个部分： 1. **数据模型设计**：介绍了如何使用 XML 或其他数据格式来定义数据对象，以便在不同服务之间保持一致性。 2. **接口和适配器**：讲解了如何创建适配器，使服务可以与不同的SDO实现（例如JDO、Hibernate、EJB Entity Beans等）进行交互。 3. **生命周期管理**：涵盖了SDO对象的创建、修改、保存和删除过程，以及如何在服务组件的生命周期中管理和同步数据。 4. **事务支持**：讨论了如何在分布式事务上下文中使用SDO，确保数据的一致性和完整性。 5. **性能优化**：提供了关于如何提高SDO在大规模系统中的性能和效率的最佳实践。 6. **安全性**：探讨了如何通过SDO实现数据的安全访问控制，比如角色基础的权限管理。 7. **示例和案例研究**：包含实际的代码片段和应用场景，帮助开发者理解和应用SDO技术。通过阅读这份SDO 2.1.0FINAL文档，IT专业人士可以深入了解如何利用这个标准来构建高度可扩展、模块化和互操作的服务架构，提升系统的灵活性和数据管理能力。

SDO 2.1.0 FINAL

Page 16

The getList(property) accessor is especially convenient for many-valued properties. If

property.many is true then set(property, value) and setList(property, value) require that

“value” be a java.util.Collection and List respectively. These methods are equivalent to

getList(property).clear() followed by getList(property).addAll(value).

For many-valued Properties, get() and getList() return a List containing the current

values. Updates through the List interface operate on the current values of the DataObject

immediately. Each access to get() or getList() returns the same List object.

3.1.5 Determining whether a Property is Set

For many-valued properties, isSet(property) returns:

• True, if the List is not empty.

• False, if the List is empty.

For single-valued properties, isSet(property) returns:

• True, if the Property has been set(), and not unset().

• False, if the Property has not been set(), or has been unset().

Any call to set() without a call to unset() will cause isSet() to return true, regardless of

the value being set. For example, after calling set(property, property.getDefault()) on a

previously unset property, isSet(property) will return true, even though the value of

get(property) will be unchanged.

The unset(property) accessors can be thought of as clearing out a single property, so that

isSet(property) returns false and get(property) returns the default. The delete() method

unsets all the DataObject’s properties except for those marked read-only. After unset(),

get(property) returns the default; which in the case of a many-valued Property is an

empty List.

Note that attempts to modify read-only properties (using set, unset or delete) cause an

exception.

3.1.6 Containment

DataObjects in a data graph are arranged in a tree structure. One DataObject forms the

root of the tree and the other DataObjects make up the nodes of the tree.

The tree structure is created using containment references which start at the root

DataObject. The root DataObject refers to other DataObjects, which can refer to further

DataObjects. Each DataObject in the data graph, except for the root DataObject, must

have a containment reference from another node in the tree. Each DataObject in the graph

keeps track of the location of its containment reference.

It is possible for a data graph to have non-containment references. These are references to

DataObjects which are part of the same data graph, (the referenced DataObjects must be

SDO 2.1.0 FINAL

Page 17

part of the same tree), but these references do not affect the tree structure of the data

graph.

Both containment and non-containment references are Properties of a DataObject. The

Type of the Properties is any DataObject Type.

Whether a particular DataObject reference Property is a containment reference or a non-

containment reference is defined by the data model for the data graph, for example the

XSD which defines the data types for an XML document. This cannot be changed once

the data model has been defined. You can query whether a particular reference is a

containment reference accessing property.containment.

A container DataObject is one that contains other DataObjects. A DataObject can have a

maximum of one container DataObject. If a DataObject has no container, it is considered

to be a root DataObject.

Simple navigation, up and down the DataObject containment tree, is provided by

getContainer() and getContainmentProperty(). The getContainer() method returns the

parent DataObject and the getContainmentProperty() method returns the Property of the

container that contains this object. A DataObject can be removed from its container,

without making any other changes, using the detach() method.

Containment is managed. When a DataObject is set or added to a containment Property, it

is removed from any previous containment Property. Containment cannot have cycles. If

a set or add would produce a containment cycle, an exception is thrown.

3.1.7 Creating and Deleting DataObjects

The create methods create a DataObject of the Type of the Property, or the Type

specified in the arguments, and add the created object to the Property specified. If the

DataObject's Type is a sequenced type (that is, if getType().isSequenced() is true) then

the created DataObject is put at the end of the Sequence. If the Property is single-valued,

the Property is set to the created object. If the Property is multi-valued, the created object

is added as the last object. Only containment properties may be specified for creation. A

created object begins with all its properties unset.

The delete() method unsets all the DataObject’s non-readonly properties. The delete()

method will also remove the DataObject from its containing DataObject if the

containment Property is not read-only. All DataObjects recursively contained by

containment properties will also be deleted.

If other DataObjects have one-way, non-containment properties that refer to deleted

DataObjects, then these references are not modified. However, these properties can need

changing to other values, in order to restore closure to the data graph. A deleted

DataObject can be used again, have its values set, and be added into the data graph again.

SDO 2.1.0 FINAL

Page 18

3.1.8 Sequenced DataObjects

A DataObject can be of a sequenced or unsequenced type (see Sequence). The

getType().isSequenced() method tells you whether the DataObject's Type is sequenced or

not.

If a DataObject's Type is sequenced then getSequence() returns that Sequence, otherwise

getSequence() returns null.

The Sequence of a DataObject corresponds to the XML elements representing the values

of its properties. Updates through DataObject, and the Lists or Sequences returned from

DataObject, operate on the same data. Returned Sequences actively represent any

changes to the DataObject's values.

3.1.9 Open Content DataObject Properties

DataObjects can have two kinds of Properties:

1. Those specified by their Type (see Type)

2. Those not specified by their Type. These additional properties are called open

content.

Properties which are specific to a DataObject’s Type are returned in a List by

getType().getProperties().

DataObjects can have Properties beyond those specified by their Type when either:

1. Handling XML open content.

2. Encountering new Properties dynamically.

Open content Properties are allowed only when Type.open is true. Some Types set open

to false so they do not have to accept additional Properties.

A Property of a DataObject can be identified as open content if Property.isOpenContent()

returns true. Open content properties only appear in getInstanceProperties() but not in

getType().getProperties(). If a Property is from open content then isSet(property) must be

true.

All Properties currently used in a DataObject are returned, in a read-only List, when you

invoke getInstanceProperties(). This includes properties that are open content. The order

of the Properties begins with all the getType().getProperties() whether set or not; the

order of the remaining Properties is determined by the implementation. Each invocation

of getInstanceProperties() will return the same List object, unless the DataObject is

updated so that the contents of the List change.

The property name can be used to find the corresponding Property active on the

DataObject within the instance properties by calling getInstanceProperty(String name).

SDO 2.1.0 FINAL

Page 19

In order to set an open content value when that Property is not set (it does not appear in

getInstanceProperties()), a set or create accessor on DataObject, or add on List or

Sequence, with a Property parameter can be used, typically found by accessing the

TypeHelper or XSDHelper. An example of creating open content this way is found in the

Creating open content XML documents.

Open content properties can also be created automatically (on-demand) by setting an

undefined property on a DataObject of a Type that isOpen. For example, when a client

calls:

openTypeDataObject.set("someProperty", value);

or:

sequencedOpenTypeDataObject.getSequence().add("someProperty", value);

If the specified property name does not already exist in the type - that is,

openTypeDataObject.getInstanceProperty("someProperty") returns null - an open content

property named "someProperty" will be defined on-the-fly and added as an instance

property by the implementation. The demand-created property is equivalent to an open

content property explicitly created by calling

TypeHelper.defineOpenContentProperty(null, property) where property is initialized as

follows:

• The property name is the name passed to the DataObject.set() or

Sequence.add() method.

• The property type is derived from the Java class of the value, or List of values,

being set. Specifically it is the same type as would be returned by calling

TypeHelper.getType(value.getClass()).

• If the value is a DataObject that is not contained, the new property will have

isContainment set to true, false otherwise.

• The property's isMany value will be true for DataObject.set(List) or

Sequence.add(), false otherwise.

• The created property's containing type (Property.getContainingType()) is not

specified by SDO.

Clients do not need to pass metadata for this kind of open-content property when

serializing instances. An implementation will automatically serialize sufficient metadata

along with the instance.

SDO 2.1.0 FINAL

Page 20

3.1.10 Property Indexes

When a DataObject has multiple Properties, each of the Properties can be referenced by

an index number, starting at 0 for the first Property.

The Property index used in get(int property), is the position in the List returned by

getInstanceProperties().

Using index parameter accessors for open content is not recommended if the data is

being modified, unless the index is used in coordination with getInstanceProperties().

This is because the index of properties for open content in getInstanceProperties() can

change, if the values of several open content properties are set and unset repeatedly.

The following example is acceptable because the index is used in coordination with

getInstanceProperties(). Note that DataObjects are not synchronized so the user should

not have updates going on at the same time as reads. This example shows a common

pattern, looping through all instance properties and printing the property name and value:

for (int i=0; i<myDo.getInstanceProperties().size(); i++)

{

Property p = (Property) myDo.getInstanceProperties().get(i);

System.out.println(p.getName()+"="+myDo.getString(i));

}

Names and alias names for Properties earlier in getInstanceProperties() take precedence

over those with a higher index, meaning that open content Properties can have their name

hidden by names defined in the Type's Properties since those Properties are at the

beginning of the list. The order of precedence is the order in getInstanceProperties().

In the event of a duplicate name, the open content Property can be accessed through its

alias name if that does not conflict with any names, or alias names, in the previous

Properties.

3.1.11 Current State for a DataObject

The current state for a DataObject are all the values that distinguish it from a newly

created object from the DataFactory, since newly created objects from a DataFactory

have no properties set and no container. The current state for a DataObject are all the

properties in getInstanceProperties() where isSet() returns true. The container and

containment property are part of the state of the containing DataObject. This program

prints the current state of the DataObject myDO.

for (int i=0; i<myDo.getInstanceProperties().size(); i++)

{

Property p = (Property) myDo.getInstanceProperties().get(i);

if (myDo.isSet(p))

{

System.out.println(p.getName()+"="+myDo.getString(i));

}

剩余139页未读，继续阅读

hoaringtiger

粉丝: 2
资源: 38

SDO 2.1.0：Java服务数据对象规范详解

SDO 规范标准说明书

Service Data Objects (SDO) Programmer Guide

CANopen SDO C函数

ethercat发送sdo的报文分析

SDO_GEOM.SDO_BUFFER函数

一个支持canopen的电机设备，使用python，先初始化连接到设备，向其发送SDO,并读取其返回的SDO

C语言实现CANopen SDO

CANopen SDO C代码

twincat3 sdo

canopen sdo 代码

最新资源