Appendix C. Spring.NET's spring-objects.xsd
<?xml version="1.0" encoding="UTF-8" ?>
<xs:schema xmlns="http://www.springframework.net" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:vs="http://schemas.microsoft.com/Visual-Studio-Intellisense" targetNamespace="http://www.springframework.net" elementFormDefault="qualified" attributeFormDefault="unqualified" vs:friendlyname="Spring.NET Configuration" vs:ishtmlschema="false" vs:iscasesensitive="true" vs:requireattributequotes="true" vs:defaultnamespacequalifier="" vs:defaultnsprefix="">
<xs:annotation>
<xs:documentation>
Spring Objects XML Schema Definition
Based on Spring Beans DTD, authored by Rod Johnson & Juergen Hoeller
Author: Griffin Caprio
This defines a simple and consistent way of creating a namespace
of managed objects configured by a Spring XmlObjectFactory.
This document type is used by most Spring functionality, including
web application contexts, which are based on object factories.
Each object element in this document defines an object.
Typically the object type (System.Type is specified, along with plain vanilla
object properties.
Object instances can be "singletons" (shared instances) or "prototypes"
(independent instances).
References among objects are supported, i.e. setting an object property
to refer to another object in the same factory or an ancestor factory.
As alternative to object references, "inner object definitions" can be used.
Singleton flags and names of such "inner object" are always ignored:
Inner object are anonymous prototypes.
There is also support for lists, dictionaries, and sets.
</xs:documentation>
</xs:annotation>
<xs:annotation>
<xs:documentation>Defines a base type for any required string. Defines a string with a minimum length of 0</xs:documentation>
</xs:annotation>
<xs:simpleType name="nonNullString">
<xs:restriction base="xs:string">
<xs:minLength value="0"/>
</xs:restriction>
</xs:simpleType>
<xs:annotation>
<xs:documentation>
Element containing informative text describing the purpose of the enclosing
element. Always optional.
Used primarily for user documentation of XML object definition documents.
</xs:documentation>
</xs:annotation>
<xs:simpleType name="description">
<xs:restriction base="nonNullString"/>
</xs:simpleType>
<xs:complexType name="valueObject">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="type" type="nonNullString" use="optional"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:complexType name="expression">
<xs:sequence>
<xs:element name="property" type="property" minOccurs="0" maxOccurs="2"/>
</xs:sequence>
<xs:attribute name="value" type="nonNullString" use="required"/>
</xs:complexType>
<!--
Defines a reference to another object in this factory or an external
factory (parent or included factory).
-->
<xs:complexType name="objectReference">
<xs:attribute name="object" type="nonNullString" use="optional"/>
<xs:attribute name="local" type="xs:IDREF" use="optional"/>
<xs:attribute name="parent" type="nonNullString" use="optional"/>
<!--
References must specify a name of the target object.
The "object" attribute can reference any name from any object in the context,
to be checked at runtime.
Local references, using the "local" attribute, have to use object ids;
they can be checked by this DTD, thus should be preferred for references
within the same object factory XML file.
-->
</xs:complexType>
<!-- Defines a reference to another object or a type. -->
<xs:complexType name="objectOrClassReference">
<xs:attribute name="object" type="nonNullString" use="optional"/>
<xs:attribute name="local" type="xs:IDREF" use="optional"/>
<xs:attribute name="type" type="nonNullString" use="optional"/>
</xs:complexType>
<xs:group name="objectList">
<xs:sequence>
<xs:element name="description" type="description" minOccurs="0"/>
<xs:choice>
<xs:element name="object" type="vanillaObject"/>
<!--
Defines a reference to another object in this factory or an external
factory (parent or included factory).
-->
<xs:element name="ref" type="objectReference"/>
<!--
Defines a string property value, which must also be the id of another
object in this factory or an external factory (parent or included factory).
While a regular 'value' element could instead be used for the same effect,
using idref in this case allows validation of local object ids by the xml
parser, and name completion by helper tools.
-->
<xs:element name="idref" type="objectReference"/>
<!--
A objectList can contain multiple inner object, ref, collection, or value elements.
Lists are untyped, pending generics support, although references will be
strongly typed.
A objectList can also map to an array type. The necessary conversion
is automatically performed by AbstractObjectFactory.
-->
<xs:element name="list">
<xs:complexType>
<xs:group ref="objectList" minOccurs="0" maxOccurs="unbounded"/>
<xs:attribute name="element-type" type="nonNullString" use="optional"/>
</xs:complexType>
</xs:element>
<!--
A set can contain multiple inner object, ref, collection, or value elements.
Sets are untyped, pending generics support, although references will be
strongly typed.
-->
<xs:element name="set">
<xs:complexType>
<xs:group ref="objectList" minOccurs="0" maxOccurs="unbounded"/>
</xs:complexType>
</xs:element>
<!--
A Spring map is a mapping from a string key to object (a .NET IDictionary).
Maps may be empty.
-->
<xs:element name="dictionary" type="objectMap"/>
<!--
Name-values elements differ from map elements in that values must be strings.
Name-values may be empty.
-->
<xs:element name="name-values" type="objectNameValues"/>
<!--
Contains a string representation of a property value.
The property may be a string, or may be converted to the
required type using the System.ComponentModel.TypeConverter
machinery. This makes it possible for application developers
to write custom TypeConverter implementations that can
convert strings to objects.
Note that this is recommended for simple objects only.
Configure more complex objects by setting properties to references
to other objects.
-->
<xs:element name="value" type="valueObject"/>
<!--
Contains a string representation of an expression.
-->
<xs:element name="expression" type="expression"/>
<!--
Denotes a .NET null value. Necessary because an empty "value" tag
will resolve to an empty String, which will not be resolved to a
null value unless a special TypeConverter does so.
-->
<xs:element name="null"/>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:complexType name="objectNameValues">
<xs:sequence>
<!--
The "value" attribute is the string value of the property. The "key"
attribute is the name of the property.
-->
<xs:element name="add" minOccurs="0" maxOccurs="unbounded">
<xs:complexType mixed="true">
<xs:attribute name="key" type="nonNullString" use="required"/>
<xs:attribute name="value" use="required" type="xs:string"/>
<xs:attribute name="delimiters" use="optional" type="xs:string"/>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:complexType name="importElement">
<xs:attribute name="resource" type="nonNullString" use="required"/>
</xs:complexType>
<xs:complexType name="aliasElement">
<xs:attribute name="name" type="nonNullString" use="required"/>
<xs:attribute name="alias" type="nonNullString" use="required"/>
</xs:complexType>
<xs:complexType name="objectMap">
<xs:sequence>
<xs:element type="mapEntryElement" name="entry" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="key-type" type="nonNullString" use="optional"/>
<xs:attribute name="value-type" type="nonNullString" use="optional"/>
</xs:complexType>
<xs:complexType name="mapEntryElement">
<xs:sequence>
<xs:element type="mapKeyElement" name="key" minOccurs="0" maxOccurs="1"/>
<xs:group ref="objectList" minOccurs="0" maxOccurs="1"/>
</xs:sequence>
<xs:attribute name="key" type="nonNullString" use="optional"/>
<xs:attribute name="value" type="nonNullString" use="optional"/>
<xs:attribute name="expression" type="nonNullString" use="optional"/>
<xs:attribute name="key-ref" type="nonNullString" use="optional"/>
<xs:attribute name="value-ref" type="nonNullString" use="optional"/>
</xs:complexType>
<xs:complexType name="mapKeyElement">
<xs:group ref="objectList" minOccurs="1"/>
</xs:complexType>
<xs:annotation>
<xs:documentation>Defines constructor argument.</xs:documentation>
</xs:annotation>
<xs:complexType name="lookupMethod">
<xs:attribute name="name" type="nonNullString" use="required"/>
<xs:attribute name="object" type="nonNullString" use="required"/>
</xs:complexType>
<xs:complexType name="constructorArgument">
<xs:group ref="objectList" minOccurs="0"/>
<!--
The constructor-arg tag can have an optional named parameter attribute,
to specify a named parameter in the constructor argument list.
-->
<xs:attribute name="name" type="nonNullString" use="optional"/>
<!--
The constructor-arg tag can have an optional index attribute,
to specify the exact index in the constructor argument list. Only needed
to avoid ambiguities, e.g. in case of 2 arguments of the same type.
-->
<xs:attribute name="index" type="nonNullString" use="optional"/>
<!--
The constructor-arg tag can have an optional type attribute,
to specify the exact type of the constructor argument. Only needed
to avoid ambiguities, e.g. in case of 2 single argument constructors
that can both be converted from a String.
-->
<xs:attribute name="type" type="nonNullString" use="optional"/>
<xs:attribute name="value" type="nonNullString" use="optional"/>
<xs:attribute name="expression" type="nonNullString" use="optional"/>
<xs:attribute name="ref" type="nonNullString" use="optional"/>
</xs:complexType>
<xs:annotation>
<xs:documentation>Defines property.</xs:documentation>
</xs:annotation>
<xs:complexType name="property">
<xs:group ref="objectList" minOccurs="0"/>
<!-- The property name attribute is the name of the objects property. -->
<xs:attribute name="name" type="nonNullString" use="required"/>
<xs:attribute name="value" type="nonNullString" use="optional"/>
<xs:attribute name="expression" type="nonNullString" use="optional"/>
<xs:attribute name="ref" type="nonNullString" use="optional"/>
</xs:complexType>
<xs:annotation>
<xs:documentation>Defines a single named object.</xs:documentation>
</xs:annotation>
<xs:complexType name="vanillaObject">
<xs:sequence>
<xs:element name="description" type="description" minOccurs="0" maxOccurs="1"/>
<!--
Object definitions can specify zero or more constructor arguments.
They correspond to either a specific index of the constructor argument list
or are supposed to be matched generically by type.
This is an alternative to "autowire constructor".
-->
<xs:element name="constructor-arg" type="constructorArgument" minOccurs="0" maxOccurs="unbounded"/>
<!--
Object definitions can have zero or more properties.
Spring supports primitives, references to other objects in the same or
related factories, lists, dictionaries and properties.
-->
<xs:element name="property" type="property" minOccurs="0" maxOccurs="unbounded"/>
<!--
Object definitions can specify zero or more lookup-methods.
-->
<xs:element name="lookup-method" type="lookupMethod" minOccurs="0" maxOccurs="unbounded"/>
<!-- Object definitions can have zero or more replaced-methods. -->
<xs:element name="replaced-method" minOccurs="0" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="arg-type" minOccurs="0" maxOccurs="unbounded">
<xs:complexType>
<xs:attribute name="match" type="nonNullString" use="required"/>
</xs:complexType>
</xs:element>
</xs:sequence>
<xs:attribute name="name" type="nonNullString" use="required"/>
<xs:attribute name="replacer" type="nonNullString" use="required"/>
</xs:complexType>
</xs:element>
<!-- Object definitions can have zero or more subscriptions. -->
<xs:element name="listener" minOccurs="0" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="ref" type="objectOrClassReference" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<!-- The event(s) the object is interested in. -->
<xs:attribute name="event" type="nonNullString" use="optional"/>
<!-- The name or name pattern of the method that will handle the event(s). -->
<xs:attribute name="method" type="nonNullString" use="required"/>
</xs:complexType>
</xs:element>
</xs:sequence>
<!--
Objects can be identified by an id, to enable reference checking.
There are constraints on a valid XML id: if you want to reference your object
in .NET code using a name that's illegal as an XML id, use the optional
"name" attribute. If neither given, the object type name is used as id.
-->
<xs:attribute name="id" type="xs:ID" use="optional"/>
<!--
Optional. Can be used to create one or more aliases illegal in an id.
Multiple aliases can be separated by any number of spaces or commas.
-->
<xs:attribute name="name" type="nonNullString" use="optional"/>
<!--
Each object definition must specify the full, assembly qualified of the type,
or the name of the parent object from which the type can be worked out.
Note that a child object definition that references a parent will just
add respectively override property values and be able to change the
singleton status. It will inherit all of the parent's other parameters
like lazy initialization or autowire settings.
-->
<xs:attribute name="type" type="nonNullString" use="optional"/>
<xs:attribute name="parent" type="nonNullString" use="optional"/>
<!--
Is this object "abstract", i.e. not meant to be instantiated itself but
rather just serving as parent for concrete child object definitions?
Default is false. Specify true to tell the object factory to not try to
instantiate that particular object in any case.
-->
<xs:attribute name="abstract" type="xs:boolean" use="optional" default="false"/>
<!--
Is this object a "singleton" (one shared instance, which will
be returned by all calls to GetObject() with the id),
or a "prototype" (independent instance resulting from each call to
getObject(). Default is singleton.
Singletons are most commonly used, and are ideal for multi-threaded
service objects.
-->
<xs:attribute name="singleton" type="xs:boolean" use="optional" default="true"/>
<!--
Optional attribute controlling the scope of singleton instances. It is
only applicable to ASP.Net web applications and it has no effect on prototype
objects. Applications other than ASP.Net web applications simply ignore this attribute.
It has 3 possible values:
1. "application"
Default object scope. Objects defined with application scope will behave like
traditional singleton objects. Same instance will be returned from every call
to IApplicationContext.GetObject()
2. "session"
Objects with this scope will be stored within user's HTTP session. Session scope
is typically used for objects such as shopping cart, user profile, etc.
3. "request"
Object with this scope will be initialized for each HTTP request, but unlike with prototype
objects, same instance will be returned from all calls to IApplicationContext.GetObject()
within the same HTTP request. For example, if one ASP page forwards request to another using
Server.Transfer method, they can easily share the state by configuring dependency to the same
request-scoped object.
-->
<xs:attribute name="scope" use="optional" default="application">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="application"/>
<xs:enumeration value="session"/>
<xs:enumeration value="request"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<!--
Is this object to be lazily initialized?
If false, it will get instantiated on startup by object factories
that perform eager initialization of singletons.
-->
<xs:attribute name="lazy-init" use="optional" default="default">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="true"/>
<xs:enumeration value="false"/>
<xs:enumeration value="default"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<!--
Optional attribute controlling whether to "autowire" object properties.
This is an automagical process in which object references don't need to be coded
explicitly in the XML object definition file, but Spring works out dependencies.
There are 5 modes:
1. "no"
The traditional Spring default. No automagical wiring. Object references
must be defined in the XML file via the <ref> element. We recommend this
in most cases as it makes documentation more explicit.
2. "byName"
Autowiring by property name. If a object of class Cat exposes a dog property,
Spring will try to set this to the value of the object "dog" in the current factory.
3. "byType"
Autowiring if there is exactly one object of the property type in the object factory.
If there is more than one, a fatal error is raised, and you can't use byType
autowiring for that object. If there is none, nothing special happens - use
dependency-check="objects" to raise an error in that case.
4. "constructor"
Analogous to "byType" for constructor arguments. If there isn't exactly one object
of the constructor argument type in the object factory, a fatal error is raised.
5. "autodetect"
Chooses "constructor" or "byType" through introspection of the object class.
If a default constructor is found, "byType" gets applied.
The latter two are similar to PicoContainer and make object factories simple to
configure for small namespaces, but doesn't work as well as standard Spring
behaviour for bigger applications.
Note that explicit dependencies, i.e. "property" and "constructor-arg" elements,
always override autowiring. Autowire behaviour can be combined with dependency
checking, which will be performed after all autowiring has been completed.
-->
<xs:attribute name="autowire" use="optional" default="default">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="no"/>
<xs:enumeration value="byName"/>
<xs:enumeration value="byType"/>
<xs:enumeration value="constructor"/>
<xs:enumeration value="autodetect"/>
<xs:enumeration value="default"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<!--
Optional attribute controlling whether to check whether all this
objects dependencies, expressed in its properties, are satisfied.
Default is no dependency checking.
"simple" type dependency checking includes primitives and String
"object" includes collaborators (other objects in the factory)
"all" includes both types of dependency checking
-->
<xs:attribute name="dependency-check" use="optional" default="default">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="none"/>
<xs:enumeration value="objects"/>
<xs:enumeration value="simple"/>
<xs:enumeration value="all"/>
<xs:enumeration value="default"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<!--
The names of the objects that this object depends on being initialized.
The object factory will guarantee that these objects get initialized before.
Note that dependencies are normally expressed through object properties or
constructor arguments. This property should just be necessary for other kinds
of dependencies like statics (*ugh*) or database preparation on startup.
-->
<xs:attribute name="depends-on" type="nonNullString" use="optional"/>
<!--
Optional attribute for the name of the custom initialization method
to invoke after setting object properties. The method must have no arguments,
but may throw any exception.
-->
<xs:attribute name="init-method" type="nonNullString" use="optional"/>
<!--
Optional attribute for the name of the custom destroy method to invoke
on object factory shutdown. The method must have no arguments,
but may throw any exception. Note: Only invoked on singleton objects!
-->
<xs:attribute name="destroy-method" type="nonNullString" use="optional"/>
<xs:attribute name="factory-method" type="nonNullString" use="optional"/>
<xs:attribute name="factory-object" type="nonNullString" use="optional"/>
</xs:complexType>
<xs:annotation>
<xs:documentation>The document root. At least one object definition is required.</xs:documentation>
</xs:annotation>
<xs:element name="objects">
<xs:complexType>
<xs:sequence>
<xs:element name="description" type="description" minOccurs="0" maxOccurs="1"/>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="import" type="importElement"/>
<xs:element name="alias" type="aliasElement"/>
<xs:element name="object" type="vanillaObject"/>
<xs:any namespace="##other" processContents="strict"/>
</xs:choice>
</xs:sequence>
<!--
Default values for all object definitions. Can be overridden at
the "object" level. See those attribute definitions for details.
-->
<xs:attribute name="default-lazy-init" type="xs:boolean" use="optional" default="false"/>
<xs:attribute name="default-dependency-check" use="optional" default="none">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="none"/>
<xs:enumeration value="objects"/>
<xs:enumeration value="simple"/>
<xs:enumeration value="all"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="default-autowire" use="optional" default="no">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="no"/>
<xs:enumeration value="byName"/>
<xs:enumeration value="byType"/>
<xs:enumeration value="constructor"/>
<xs:enumeration value="autodetect"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
</xs:schema>
