You are viewing a plain text version of this content. The canonical link for it is here.
Posted to jetspeed-dev@portals.apache.org by at...@apache.org on 2008/12/12 14:23:50 UTC

svn commit: r725996 - /portals/jetspeed-2/applications/j2-admin/trunk/src/webapp/WEB-INF/springmvc/dtd/spring-beans.dtd

Author: ate
Date: Fri Dec 12 05:23:49 2008
New Revision: 725996

URL: http://svn.apache.org/viewvc?rev=725996&view=rev
Log:
One more svn:eol-style property fixed for previously missed extensions: link|security|xslt|dtd|TXT

Modified:
    portals/jetspeed-2/applications/j2-admin/trunk/src/webapp/WEB-INF/springmvc/dtd/spring-beans.dtd   (contents, props changed)

Modified: portals/jetspeed-2/applications/j2-admin/trunk/src/webapp/WEB-INF/springmvc/dtd/spring-beans.dtd
URL: http://svn.apache.org/viewvc/portals/jetspeed-2/applications/j2-admin/trunk/src/webapp/WEB-INF/springmvc/dtd/spring-beans.dtd?rev=725996&r1=725995&r2=725996&view=diff
==============================================================================
--- portals/jetspeed-2/applications/j2-admin/trunk/src/webapp/WEB-INF/springmvc/dtd/spring-beans.dtd (original)
+++ portals/jetspeed-2/applications/j2-admin/trunk/src/webapp/WEB-INF/springmvc/dtd/spring-beans.dtd Fri Dec 12 05:23:49 2008
@@ -14,653 +14,653 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 -->
-<!--
-	Spring XML Beans DTD
-	Authors: Rod Johnson, Juergen Hoeller, Alef Arendsen, Colin Sampaleanu, Rob Harrop
-
-	This defines a simple and consistent way of creating a namespace
-	of JavaBeans objects, managed by a Spring BeanFactory, read by
-	XmlBeanDefinitionReader (with DefaultXmlBeanDefinitionParser).
-
-	This document type is used by most Spring functionality, including
-	web application contexts, which are based on bean factories.
-
-	Each "bean" element in this document defines a JavaBean.
-	Typically the bean class is specified, along with JavaBean properties
-	and/or constructor arguments.
-
-	Bean instances can be "singletons" (shared instances) or "prototypes"
-	(independent instances). Further scopes are supposed to be built on top
-	of the core BeanFactory infrastructure and are therefore not part of it.
-
-	References among beans are supported, i.e. setting a JavaBean property
-	or a constructor argument to refer to another bean in the same factory
-	(or an ancestor factory).
-
-	As alternative to bean references, "inner bean definitions" can be used.
-	Singleton flags of such inner bean definitions are effectively ignored:
-	Inner beans are typically anonymous prototypes.
-
-	There is also support for lists, sets, maps, and java.util.Properties
-	as bean property types or constructor argument types.
-
-	As the format is simple, a DTD is sufficient, and there's no need
-	for a schema at this point.
-
-	XML documents that conform to this DTD should declare the following doctype:
-
-	<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
-		"http://www.springframework.org/dtd/spring-beans.dtd">
--->
-
-
-<!--
-	The document root. A document can contain bean definitions only,
-	imports only, or a mixture of both (typically with imports first).
--->
-<!ELEMENT beans (
-	description?,
-	(import | alias | bean)*
-)>
-
-<!--
-	Default values for all bean definitions. Can be overridden at
-	the "bean" level. See those attribute definitions for details.
--->
-<!ATTLIST beans default-lazy-init (true | false) "false">
-<!ATTLIST beans default-autowire (no | byName | byType | constructor | autodetect) "no">
-<!ATTLIST beans default-dependency-check (none | objects | simple | all) "none">
-<!ATTLIST beans default-init-method CDATA #IMPLIED>
-<!ATTLIST beans default-destroy-method CDATA #IMPLIED>
-<!ATTLIST beans default-merge (true | false) "false">
-
-<!--
-	Element containing informative text describing the purpose of the enclosing
-	element. Always optional.
-	Used primarily for user documentation of XML bean definition documents.
--->
-<!ELEMENT description (#PCDATA)>
-
-
-<!--
-	Specifies an XML bean definition resource to import.
--->
-<!ELEMENT import EMPTY>
-
-<!--
-	The relative resource location of the XML bean definition file to import,
-	for example "myImport.xml" or "includes/myImport.xml" or "../myImport.xml".
--->
-<!ATTLIST import resource CDATA #REQUIRED>
-
-
-<!--
-	Defines an alias for a bean, which can reside in a different definition file.
--->
-<!ELEMENT alias EMPTY>
-
-<!--
-	The name of the bean to define an alias for.
--->
-<!ATTLIST alias name CDATA #REQUIRED>
-
-<!--
-	The alias name to define for the bean.
--->
-<!ATTLIST alias alias CDATA #REQUIRED>
-
-<!--
-  Allows for arbitrary metadata to be attached to a bean definition.
--->
-<!ELEMENT meta EMPTY>
-
-<!--
-  Specifies the key name of the metdata parameter being defined
--->
-<!ATTLIST meta key CDATA #REQUIRED>
-
-<!--
-  Specifies the value of the metadata parameter being defined as a String
--->
-<!ATTLIST meta value CDATA #REQUIRED>
-
-<!--
-	Defines a single (usually named) bean.
-
-	A bean definition may contain nested tags for constructor arguments,
-	property values, lookup methods, and replaced methods. Mixing constructor
-	injection and setter injection on the same bean is explicitly supported.
--->
-<!ELEMENT bean (
-	description?,
-	(meta | constructor-arg | property | lookup-method | replaced-method)*
-)>
-
-<!--
-	Beans can be identified by an id, to enable reference checking.
-
-	There are constraints on a valid XML id: if you want to reference your bean
-	in Java code using a name that's illegal as an XML id, use the optional
-	"name" attribute. If neither is given, the bean class name is used as id
-	(with an appended counter like "#2" if there is already a bean with that name).
--->
-<!ATTLIST bean id ID #IMPLIED>
-
-<!--
-	Optional. Can be used to create one or more aliases illegal in an id.
-	Multiple aliases can be separated by any number of spaces, commas, or
-	semi-colons (or indeed any mixture of the three).
--->
-<!ATTLIST bean name CDATA #IMPLIED>
-
-<!--
-	Each bean definition must specify the fully qualified name of the class,
-	except if it pure serves as parent for child bean definitions.
--->
-<!ATTLIST bean class CDATA #IMPLIED>
-
-<!--
-	Optionally specify a parent bean definition.
-
-	Will use the bean class of the parent if none specified, but can
-	also override it. In the latter case, the child bean class must be
-	compatible with the parent, i.e. accept the parent's property values
-	and constructor argument values, if any.
-
-	A child bean definition will inherit constructor argument values,
-	property values and method overrides from the parent, with the option
-	to add new values. If init method, destroy method, factory bean and/or factory
-	method are specified, they will override the corresponding parent settings.
-
-	The remaining settings will always be taken from the child definition:
-	depends on, autowire mode, dependency check, singleton, lazy init.
--->
-<!ATTLIST bean parent CDATA #IMPLIED>
-
-<!--
-	Is this bean "abstract", i.e. not meant to be instantiated itself but
-	rather just serving as parent for concrete child bean definitions.
-	Default is "false". Specify "true" to tell the bean factory to not try to
-	instantiate that particular bean in any case.
-
-	Note: This attribute will not be inherited by child bean definitions.
-	Hence, it needs to be specified per concrete bean definition.
--->
-<!ATTLIST bean abstract (true | false) "false">
-
-<!--
-	Is this bean a "singleton" (one shared instance, which will
-	be returned by all calls to getBean() with the id),
-	or a "prototype" (independent instance resulting from each call to
-	getBean(). Default is singleton.
-
-	Singletons are most commonly used, and are ideal for multi-threaded
-	service objects.
-
-	Note: This attribute will not be inherited by child bean definitions.
-	Hence, it needs to be specified per concrete bean definition.
--->
-<!ATTLIST bean singleton (true | false) "true">
-
-<!--
-	If this bean should be lazily initialized.
-	If false, it will get instantiated on startup by bean factories
-	that perform eager initialization of singletons.
-
-
-	Note: This attribute will not be inherited by child bean definitions.
-	Hence, it needs to be specified per concrete bean definition.
--->
-<!ATTLIST bean lazy-init (true | false | default) "default">
-
-<!--
-  Indicates whether or not this bean should be considered when looking
-  for candidates to satisfy another beans autowiring requirements.
--->
-<!ATTLIST bean autowire-candidate (true | false) "true">
-
-<!--
-	Optional attribute controlling whether to "autowire" bean properties.
-	This is an automagical process in which bean references don't need to be coded
-	explicitly in the XML bean definition file, but Spring works out dependencies.
-
-	There are 5 modes:
-
-	1. "no"
-	The traditional Spring default. No automagical wiring. Bean 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 bean of class Cat exposes a dog property,
-	Spring will try to set this to the value of the bean "dog" in the current factory.
-	If there is no matching bean by name, nothing special happens;
-	use dependency-check="objects" to raise an error in that case.
-
-	3. "byType"
-	Autowiring if there is exactly one bean of the property type in the bean factory.
-	If there is more than one, a fatal error is raised, and you can't use byType
-	autowiring for that bean. 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 bean
-	of the constructor argument type in the bean factory, a fatal error is raised.
-
-	5. "autodetect"
-	Chooses "constructor" or "byType" through introspection of the bean class.
-	If a default constructor is found, "byType" gets applied.
-
-	The latter two are similar to PicoContainer and make bean 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 behavior can be combined with dependency
-	checking, which will be performed after all autowiring has been completed.
-
-	Note: This attribute will not be inherited by child bean definitions.
-	Hence, it needs to be specified per concrete bean definition.
--->
-<!ATTLIST bean autowire (no | byName | byType | constructor | autodetect | default) "default">
-
-<!--
-	Optional attribute controlling whether to check whether all this
-	beans dependencies, expressed in its properties, are satisfied.
-	Default is no dependency checking.
-
-	"simple" type dependency checking includes primitives and String
-	"object" includes collaborators (other beans in the factory)
-	"all" includes both types of dependency checking
-
-	Note: This attribute will not be inherited by child bean definitions.
-	Hence, it needs to be specified per concrete bean definition.
--->
-<!ATTLIST bean dependency-check (none | objects | simple | all | default) "default">
-
-<!--
-	The names of the beans that this bean depends on being initialized.
-	The bean factory will guarantee that these beans get initialized before.
-
-	Note that dependencies are normally expressed through bean properties or
-	constructor arguments. This property should just be necessary for other kinds
-	of dependencies like statics (*ugh*) or database preparation on startup.
-
-	Note: This attribute will not be inherited by child bean definitions.
-	Hence, it needs to be specified per concrete bean definition.
--->
-<!ATTLIST bean depends-on CDATA #IMPLIED>
-
-<!--
-	Optional attribute for the name of the custom initialization method
-	to invoke after setting bean properties. The method must have no arguments,
-	but may throw any exception.
--->
-<!ATTLIST bean init-method CDATA #IMPLIED>
-
-<!--
-	Optional attribute for the name of the custom destroy method to invoke
-	on bean factory shutdown. The method must have no arguments,
-	but may throw any exception. Note: Only invoked on singleton beans!
--->
-<!ATTLIST bean destroy-method CDATA #IMPLIED>
-
-<!--
-	Optional attribute specifying the name of a factory method to use to
-	create this object. Use constructor-arg elements to specify arguments
-	to the factory method, if it takes arguments. Autowiring does not apply
-	to factory methods.
-
-	If the "class" attribute is present, the factory method will be a static
-	method on the class specified by the "class" attribute on this bean
-	definition. Often this will be the same class as that of the constructed
-	object - for example, when the factory method is used as an alternative
-	to a constructor. However, it may be on a different class. In that case,
-	the created object will *not* be of the class specified in the "class"
-	attribute. This is analogous to FactoryBean behavior.
-
-	If the "factory-bean" attribute is present, the "class" attribute is not
-	used, and the factory method will be an instance method on the object
-	returned from a getBean call with the specified bean name. The factory
-	bean may be defined as a singleton or a prototype.
-
-	The factory method can have any number of arguments. Autowiring is not
-	supported. Use indexed constructor-arg elements in conjunction with the
-	factory-method attribute.
-
-	Setter Injection can be used in conjunction with a factory method.
-	Method Injection cannot, as the factory method returns an instance,
-	which will be used when the container creates the bean.
--->
-<!ATTLIST bean factory-method CDATA #IMPLIED>
-
-<!--
-	Alternative to class attribute for factory-method usage.
-	If this is specified, no class attribute should be used.
-	This should be set to the name of a bean in the current or
-	ancestor factories that contains the relevant factory method.
-	This allows the factory itself to be configured using Dependency
-	Injection, and an instance (rather than static) method to be used.
--->
-<!ATTLIST bean factory-bean CDATA #IMPLIED>
-
-<!--
-	Bean definitions can specify zero or more constructor arguments.
-	This is an alternative to "autowire constructor".
-	Arguments correspond to either a specific index of the constructor argument
-	list or are supposed to be matched generically by type.
-
-	Note: A single generic argument value will just be used once, rather than
-	potentially matched multiple times (as of Spring 1.1).
-
-	constructor-arg elements are also used in conjunction with the factory-method
-	element to construct beans using static or instance factory methods.
--->
-<!ELEMENT constructor-arg (
-	description?,
-	(bean | ref | idref | value | null | list | set | map | props)?
-)>
-
-<!--
-	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.
--->
-<!ATTLIST constructor-arg index CDATA #IMPLIED>
-
-<!--
-	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.
--->
-<!ATTLIST constructor-arg type CDATA #IMPLIED>
-
-<!--
-  A short-cut alternative to a child element "ref bean=".
--->
-<!ATTLIST constructor-arg ref CDATA #IMPLIED>
-
-<!--
-  A short-cut alternative to a child element "value".
--->
-<!ATTLIST constructor-arg value CDATA #IMPLIED>
-
-
-<!--
-	Bean definitions can have zero or more properties.
-	Property elements correspond to JavaBean setter methods exposed
-	by the bean classes. Spring supports primitives, references to other
-	beans in the same or related factories, lists, maps and properties.
--->
-<!ELEMENT property (
-	description?, meta*,
-	(bean | ref | idref | value | null | list | set | map | props)?
-)>
-
-<!--
-	The property name attribute is the name of the JavaBean property.
-	This follows JavaBean conventions: a name of "age" would correspond
-	to setAge()/optional getAge() methods.
--->
-<!ATTLIST property name CDATA #REQUIRED>
-
-<!--
-  A short-cut alternative to a child element "ref bean=".
--->
-<!ATTLIST property ref CDATA #IMPLIED>
-
-<!--
-  A short-cut alternative to a child element "value".
--->
-<!ATTLIST property value CDATA #IMPLIED>
-
-
-<!--
-	A lookup method causes the IoC container to override the given method and return
-	the bean with the name given in the bean attribute. This is a form of Method Injection.
-	It's particularly useful as an alternative to implementing the BeanFactoryAware
-	interface, in order to be able to make getBean() calls for non-singleton instances
-	at runtime. In this case, Method Injection is a less invasive alternative.
--->
-<!ELEMENT lookup-method EMPTY>
-
-<!--
-	Name of a lookup method. This method should take no arguments.
--->
-<!ATTLIST lookup-method name CDATA #IMPLIED>
-
-<!--
-	Name of the bean in the current or ancestor factories that the lookup method
-	should resolve to. Often this bean will be a prototype, in which case the
-	lookup method will return a distinct instance on every invocation. This
-	is useful for single-threaded objects.
--->
-<!ATTLIST lookup-method bean CDATA #IMPLIED>
-
-
-<!--
-	Similar to the lookup method mechanism, the replaced-method element is used to control
-	IoC container method overriding: Method Injection. This mechanism allows the overriding
-	of a method with arbitrary code.
--->
-<!ELEMENT replaced-method (
-	(arg-type)*
-)>
-
-<!--
-	Name of the method whose implementation should be replaced by the IoC container.
-	If this method is not overloaded, there's no need to use arg-type subelements.
-	If this method is overloaded, arg-type subelements must be used for all
-	override definitions for the method.
--->
-<!ATTLIST replaced-method name CDATA #IMPLIED>
-
-<!--
-	Bean name of an implementation of the MethodReplacer interface
-	in the current or ancestor factories. This may be a singleton or prototype
-	bean. If it's a prototype, a new instance will be used for each method replacement.
-	Singleton usage is the norm.
--->
-<!ATTLIST replaced-method replacer CDATA #IMPLIED>
-
-<!--
-	Subelement of replaced-method identifying an argument for a replaced method
-	in the event of method overloading.
--->
-<!ELEMENT arg-type (#PCDATA)>
-
-<!--
-	Specification of the type of an overloaded method argument as a String.
-	For convenience, this may be a substring of the FQN. E.g. all the
-	following would match "java.lang.String":
-	- java.lang.String
-	- String
-	- Str
-
-	As the number of arguments will be checked also, this convenience can often
-	be used to save typing.
--->
-<!ATTLIST arg-type match CDATA #IMPLIED>
-
-
-<!--
-	Defines a reference to another bean in this factory or an external
-	factory (parent or included factory).
--->
-<!ELEMENT ref EMPTY>
-
-<!--
-	References must specify a name of the target bean.
-	The "bean" attribute can reference any name from any bean in the context,
-	to be checked at runtime.
-	Local references, using the "local" attribute, have to use bean ids;
-	they can be checked by this DTD, thus should be preferred for references
-	within the same bean factory XML file.
--->
-<!ATTLIST ref bean CDATA #IMPLIED>
-<!ATTLIST ref local IDREF #IMPLIED>
-<!ATTLIST ref parent CDATA #IMPLIED>
-
-
-<!--
-	Defines a string property value, which must also be the id of another
-	bean 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 bean ids by the xml
-	parser, and name completion by helper tools.
--->
-<!ELEMENT idref EMPTY>
-
-<!--
-	ID refs must specify a name of the target bean.
-	The "bean" attribute can reference any name from any bean in the context,
-	potentially to be checked at runtime by bean factory implementations.
-	Local references, using the "local" attribute, have to use bean ids;
-	they can be checked by this DTD, thus should be preferred for references
-	within the same bean factory XML file.
--->
-<!ATTLIST idref bean CDATA #IMPLIED>
-<!ATTLIST idref local IDREF #IMPLIED>
-
-
-<!--
-	Contains a string representation of a property value.
-	The property may be a string, or may be converted to the
-	required type using the JavaBeans PropertyEditor
-	machinery. This makes it possible for application developers
-	to write custom PropertyEditor implementations that can
-	convert strings to objects.
-
-	Note that this is recommended for simple objects only.
-	Configure more complex objects by populating JavaBean
-	properties with references to other beans.
--->
-<!ELEMENT value (#PCDATA)>
-
-<!--
-	The value tag can have an optional type attribute, to specify the
-	exact type that the value should be converted to. Only needed
-	if the type of the target property or constructor argument is
-	too generic: for example, in case of a collection element.
--->
-<!ATTLIST value type CDATA #IMPLIED>
-
-<!--
-	Denotes a Java 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 PropertyEditor does so.
--->
-<!ELEMENT null (#PCDATA)>
-
-
-<!--
-	A list can contain multiple inner bean, ref, collection, or value elements.
-	Java lists are untyped, pending generics support in Java 1.5,
-	although references will be strongly typed.
-	A list can also map to an array type. The necessary conversion
-	is automatically performed by the BeanFactory.
--->
-<!ELEMENT list (
-	(bean | ref | idref | value | null | list | set | map | props)*
-)>
-
-<!-- Enable/disable merging for collections when using parent/child beans -->
-<!ATTLIST list merge (true | false | default) "default">
-
-<!-- Specify the default Java type for nested values -->
-<!ATTLIST list value-type CDATA #IMPLIED>
-
-<!--
-	A set can contain multiple inner bean, ref, collection, or value elements.
-	Java sets are untyped, pending generics support in Java 1.5,
-	although references will be strongly typed.
--->
-<!ELEMENT set (
-	(bean | ref | idref | value | null | list | set | map | props)*
-)>
-
-<!-- Enable/disable merging for collections when using parent/child beans -->
-<!ATTLIST set merge (true | false | default) "default">
-
-<!-- Specify the default Java type for nested values -->
-<!ATTLIST set value-type CDATA #IMPLIED>
-
-<!--
-	A Spring map is a mapping from a string key to object.
-	Maps may be empty.
--->
-<!ELEMENT map (
-	(entry)*
-)>
-
-<!-- Enable/disable merging for collections when using parent/child beans -->
-<!ATTLIST map merge (true | false | default) "default">
-
-<!-- Specify the default Java type for nested entry keys -->
-<!ATTLIST map key-type CDATA #IMPLIED>
-
-<!-- Specify the default Java type for nested entry values -->
-<!ATTLIST map value-type CDATA #IMPLIED>
-
-<!--
-	A map entry can be an inner bean, ref, value, or collection.
-	The key of the entry is given by the "key" attribute or child element.
--->
-<!ELEMENT entry (
-  key?,
-	(bean | ref | idref | value | null | list | set | map | props)?
-)>
-
-<!--
-	Each map element must specify its key as attribute or as child element.
-	A key attribute is always a String value.
--->
-<!ATTLIST entry key CDATA #IMPLIED>
-
-<!--
-  A short-cut alternative to a "key" element with a "ref bean=" child element.
--->
-<!ATTLIST entry key-ref CDATA #IMPLIED>
-
-<!--
-  A short-cut alternative to a child element "value".
--->
-<!ATTLIST entry value CDATA #IMPLIED>
-
-<!--
-  A short-cut alternative to a child element "ref bean=".
--->
-<!ATTLIST entry value-ref CDATA #IMPLIED>
-
-<!--
-	A key element can contain an inner bean, ref, value, or collection.
--->
-<!ELEMENT key (
-	(bean | ref | idref | value | null | list | set | map | props)
-)>
-
-
-<!--
-	Props elements differ from map elements in that values must be strings.
-	Props may be empty.
--->
-<!ELEMENT props (
-	(prop)*
-)>
-
-<!-- Enable/disable merging for collections when using parent/child beans -->
-<!ATTLIST props merge (true | false | default) "default">
-
-<!--
-	Element content is the string value of the property.
-	Note that whitespace is trimmed off to avoid unwanted whitespace
-	caused by typical XML formatting.
--->
-<!ELEMENT prop (#PCDATA)>
-
-<!--
-	Each property element must specify its key.
--->
-<!ATTLIST prop key CDATA #REQUIRED>
-
+<!--
+	Spring XML Beans DTD
+	Authors: Rod Johnson, Juergen Hoeller, Alef Arendsen, Colin Sampaleanu, Rob Harrop
+
+	This defines a simple and consistent way of creating a namespace
+	of JavaBeans objects, managed by a Spring BeanFactory, read by
+	XmlBeanDefinitionReader (with DefaultXmlBeanDefinitionParser).
+
+	This document type is used by most Spring functionality, including
+	web application contexts, which are based on bean factories.
+
+	Each "bean" element in this document defines a JavaBean.
+	Typically the bean class is specified, along with JavaBean properties
+	and/or constructor arguments.
+
+	Bean instances can be "singletons" (shared instances) or "prototypes"
+	(independent instances). Further scopes are supposed to be built on top
+	of the core BeanFactory infrastructure and are therefore not part of it.
+
+	References among beans are supported, i.e. setting a JavaBean property
+	or a constructor argument to refer to another bean in the same factory
+	(or an ancestor factory).
+
+	As alternative to bean references, "inner bean definitions" can be used.
+	Singleton flags of such inner bean definitions are effectively ignored:
+	Inner beans are typically anonymous prototypes.
+
+	There is also support for lists, sets, maps, and java.util.Properties
+	as bean property types or constructor argument types.
+
+	As the format is simple, a DTD is sufficient, and there's no need
+	for a schema at this point.
+
+	XML documents that conform to this DTD should declare the following doctype:
+
+	<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
+		"http://www.springframework.org/dtd/spring-beans.dtd">
+-->
+
+
+<!--
+	The document root. A document can contain bean definitions only,
+	imports only, or a mixture of both (typically with imports first).
+-->
+<!ELEMENT beans (
+	description?,
+	(import | alias | bean)*
+)>
+
+<!--
+	Default values for all bean definitions. Can be overridden at
+	the "bean" level. See those attribute definitions for details.
+-->
+<!ATTLIST beans default-lazy-init (true | false) "false">
+<!ATTLIST beans default-autowire (no | byName | byType | constructor | autodetect) "no">
+<!ATTLIST beans default-dependency-check (none | objects | simple | all) "none">
+<!ATTLIST beans default-init-method CDATA #IMPLIED>
+<!ATTLIST beans default-destroy-method CDATA #IMPLIED>
+<!ATTLIST beans default-merge (true | false) "false">
+
+<!--
+	Element containing informative text describing the purpose of the enclosing
+	element. Always optional.
+	Used primarily for user documentation of XML bean definition documents.
+-->
+<!ELEMENT description (#PCDATA)>
+
+
+<!--
+	Specifies an XML bean definition resource to import.
+-->
+<!ELEMENT import EMPTY>
+
+<!--
+	The relative resource location of the XML bean definition file to import,
+	for example "myImport.xml" or "includes/myImport.xml" or "../myImport.xml".
+-->
+<!ATTLIST import resource CDATA #REQUIRED>
+
+
+<!--
+	Defines an alias for a bean, which can reside in a different definition file.
+-->
+<!ELEMENT alias EMPTY>
+
+<!--
+	The name of the bean to define an alias for.
+-->
+<!ATTLIST alias name CDATA #REQUIRED>
+
+<!--
+	The alias name to define for the bean.
+-->
+<!ATTLIST alias alias CDATA #REQUIRED>
+
+<!--
+  Allows for arbitrary metadata to be attached to a bean definition.
+-->
+<!ELEMENT meta EMPTY>
+
+<!--
+  Specifies the key name of the metdata parameter being defined
+-->
+<!ATTLIST meta key CDATA #REQUIRED>
+
+<!--
+  Specifies the value of the metadata parameter being defined as a String
+-->
+<!ATTLIST meta value CDATA #REQUIRED>
+
+<!--
+	Defines a single (usually named) bean.
+
+	A bean definition may contain nested tags for constructor arguments,
+	property values, lookup methods, and replaced methods. Mixing constructor
+	injection and setter injection on the same bean is explicitly supported.
+-->
+<!ELEMENT bean (
+	description?,
+	(meta | constructor-arg | property | lookup-method | replaced-method)*
+)>
+
+<!--
+	Beans can be identified by an id, to enable reference checking.
+
+	There are constraints on a valid XML id: if you want to reference your bean
+	in Java code using a name that's illegal as an XML id, use the optional
+	"name" attribute. If neither is given, the bean class name is used as id
+	(with an appended counter like "#2" if there is already a bean with that name).
+-->
+<!ATTLIST bean id ID #IMPLIED>
+
+<!--
+	Optional. Can be used to create one or more aliases illegal in an id.
+	Multiple aliases can be separated by any number of spaces, commas, or
+	semi-colons (or indeed any mixture of the three).
+-->
+<!ATTLIST bean name CDATA #IMPLIED>
+
+<!--
+	Each bean definition must specify the fully qualified name of the class,
+	except if it pure serves as parent for child bean definitions.
+-->
+<!ATTLIST bean class CDATA #IMPLIED>
+
+<!--
+	Optionally specify a parent bean definition.
+
+	Will use the bean class of the parent if none specified, but can
+	also override it. In the latter case, the child bean class must be
+	compatible with the parent, i.e. accept the parent's property values
+	and constructor argument values, if any.
+
+	A child bean definition will inherit constructor argument values,
+	property values and method overrides from the parent, with the option
+	to add new values. If init method, destroy method, factory bean and/or factory
+	method are specified, they will override the corresponding parent settings.
+
+	The remaining settings will always be taken from the child definition:
+	depends on, autowire mode, dependency check, singleton, lazy init.
+-->
+<!ATTLIST bean parent CDATA #IMPLIED>
+
+<!--
+	Is this bean "abstract", i.e. not meant to be instantiated itself but
+	rather just serving as parent for concrete child bean definitions.
+	Default is "false". Specify "true" to tell the bean factory to not try to
+	instantiate that particular bean in any case.
+
+	Note: This attribute will not be inherited by child bean definitions.
+	Hence, it needs to be specified per concrete bean definition.
+-->
+<!ATTLIST bean abstract (true | false) "false">
+
+<!--
+	Is this bean a "singleton" (one shared instance, which will
+	be returned by all calls to getBean() with the id),
+	or a "prototype" (independent instance resulting from each call to
+	getBean(). Default is singleton.
+
+	Singletons are most commonly used, and are ideal for multi-threaded
+	service objects.
+
+	Note: This attribute will not be inherited by child bean definitions.
+	Hence, it needs to be specified per concrete bean definition.
+-->
+<!ATTLIST bean singleton (true | false) "true">
+
+<!--
+	If this bean should be lazily initialized.
+	If false, it will get instantiated on startup by bean factories
+	that perform eager initialization of singletons.
+
+
+	Note: This attribute will not be inherited by child bean definitions.
+	Hence, it needs to be specified per concrete bean definition.
+-->
+<!ATTLIST bean lazy-init (true | false | default) "default">
+
+<!--
+  Indicates whether or not this bean should be considered when looking
+  for candidates to satisfy another beans autowiring requirements.
+-->
+<!ATTLIST bean autowire-candidate (true | false) "true">
+
+<!--
+	Optional attribute controlling whether to "autowire" bean properties.
+	This is an automagical process in which bean references don't need to be coded
+	explicitly in the XML bean definition file, but Spring works out dependencies.
+
+	There are 5 modes:
+
+	1. "no"
+	The traditional Spring default. No automagical wiring. Bean 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 bean of class Cat exposes a dog property,
+	Spring will try to set this to the value of the bean "dog" in the current factory.
+	If there is no matching bean by name, nothing special happens;
+	use dependency-check="objects" to raise an error in that case.
+
+	3. "byType"
+	Autowiring if there is exactly one bean of the property type in the bean factory.
+	If there is more than one, a fatal error is raised, and you can't use byType
+	autowiring for that bean. 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 bean
+	of the constructor argument type in the bean factory, a fatal error is raised.
+
+	5. "autodetect"
+	Chooses "constructor" or "byType" through introspection of the bean class.
+	If a default constructor is found, "byType" gets applied.
+
+	The latter two are similar to PicoContainer and make bean 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 behavior can be combined with dependency
+	checking, which will be performed after all autowiring has been completed.
+
+	Note: This attribute will not be inherited by child bean definitions.
+	Hence, it needs to be specified per concrete bean definition.
+-->
+<!ATTLIST bean autowire (no | byName | byType | constructor | autodetect | default) "default">
+
+<!--
+	Optional attribute controlling whether to check whether all this
+	beans dependencies, expressed in its properties, are satisfied.
+	Default is no dependency checking.
+
+	"simple" type dependency checking includes primitives and String
+	"object" includes collaborators (other beans in the factory)
+	"all" includes both types of dependency checking
+
+	Note: This attribute will not be inherited by child bean definitions.
+	Hence, it needs to be specified per concrete bean definition.
+-->
+<!ATTLIST bean dependency-check (none | objects | simple | all | default) "default">
+
+<!--
+	The names of the beans that this bean depends on being initialized.
+	The bean factory will guarantee that these beans get initialized before.
+
+	Note that dependencies are normally expressed through bean properties or
+	constructor arguments. This property should just be necessary for other kinds
+	of dependencies like statics (*ugh*) or database preparation on startup.
+
+	Note: This attribute will not be inherited by child bean definitions.
+	Hence, it needs to be specified per concrete bean definition.
+-->
+<!ATTLIST bean depends-on CDATA #IMPLIED>
+
+<!--
+	Optional attribute for the name of the custom initialization method
+	to invoke after setting bean properties. The method must have no arguments,
+	but may throw any exception.
+-->
+<!ATTLIST bean init-method CDATA #IMPLIED>
+
+<!--
+	Optional attribute for the name of the custom destroy method to invoke
+	on bean factory shutdown. The method must have no arguments,
+	but may throw any exception. Note: Only invoked on singleton beans!
+-->
+<!ATTLIST bean destroy-method CDATA #IMPLIED>
+
+<!--
+	Optional attribute specifying the name of a factory method to use to
+	create this object. Use constructor-arg elements to specify arguments
+	to the factory method, if it takes arguments. Autowiring does not apply
+	to factory methods.
+
+	If the "class" attribute is present, the factory method will be a static
+	method on the class specified by the "class" attribute on this bean
+	definition. Often this will be the same class as that of the constructed
+	object - for example, when the factory method is used as an alternative
+	to a constructor. However, it may be on a different class. In that case,
+	the created object will *not* be of the class specified in the "class"
+	attribute. This is analogous to FactoryBean behavior.
+
+	If the "factory-bean" attribute is present, the "class" attribute is not
+	used, and the factory method will be an instance method on the object
+	returned from a getBean call with the specified bean name. The factory
+	bean may be defined as a singleton or a prototype.
+
+	The factory method can have any number of arguments. Autowiring is not
+	supported. Use indexed constructor-arg elements in conjunction with the
+	factory-method attribute.
+
+	Setter Injection can be used in conjunction with a factory method.
+	Method Injection cannot, as the factory method returns an instance,
+	which will be used when the container creates the bean.
+-->
+<!ATTLIST bean factory-method CDATA #IMPLIED>
+
+<!--
+	Alternative to class attribute for factory-method usage.
+	If this is specified, no class attribute should be used.
+	This should be set to the name of a bean in the current or
+	ancestor factories that contains the relevant factory method.
+	This allows the factory itself to be configured using Dependency
+	Injection, and an instance (rather than static) method to be used.
+-->
+<!ATTLIST bean factory-bean CDATA #IMPLIED>
+
+<!--
+	Bean definitions can specify zero or more constructor arguments.
+	This is an alternative to "autowire constructor".
+	Arguments correspond to either a specific index of the constructor argument
+	list or are supposed to be matched generically by type.
+
+	Note: A single generic argument value will just be used once, rather than
+	potentially matched multiple times (as of Spring 1.1).
+
+	constructor-arg elements are also used in conjunction with the factory-method
+	element to construct beans using static or instance factory methods.
+-->
+<!ELEMENT constructor-arg (
+	description?,
+	(bean | ref | idref | value | null | list | set | map | props)?
+)>
+
+<!--
+	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.
+-->
+<!ATTLIST constructor-arg index CDATA #IMPLIED>
+
+<!--
+	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.
+-->
+<!ATTLIST constructor-arg type CDATA #IMPLIED>
+
+<!--
+  A short-cut alternative to a child element "ref bean=".
+-->
+<!ATTLIST constructor-arg ref CDATA #IMPLIED>
+
+<!--
+  A short-cut alternative to a child element "value".
+-->
+<!ATTLIST constructor-arg value CDATA #IMPLIED>
+
+
+<!--
+	Bean definitions can have zero or more properties.
+	Property elements correspond to JavaBean setter methods exposed
+	by the bean classes. Spring supports primitives, references to other
+	beans in the same or related factories, lists, maps and properties.
+-->
+<!ELEMENT property (
+	description?, meta*,
+	(bean | ref | idref | value | null | list | set | map | props)?
+)>
+
+<!--
+	The property name attribute is the name of the JavaBean property.
+	This follows JavaBean conventions: a name of "age" would correspond
+	to setAge()/optional getAge() methods.
+-->
+<!ATTLIST property name CDATA #REQUIRED>
+
+<!--
+  A short-cut alternative to a child element "ref bean=".
+-->
+<!ATTLIST property ref CDATA #IMPLIED>
+
+<!--
+  A short-cut alternative to a child element "value".
+-->
+<!ATTLIST property value CDATA #IMPLIED>
+
+
+<!--
+	A lookup method causes the IoC container to override the given method and return
+	the bean with the name given in the bean attribute. This is a form of Method Injection.
+	It's particularly useful as an alternative to implementing the BeanFactoryAware
+	interface, in order to be able to make getBean() calls for non-singleton instances
+	at runtime. In this case, Method Injection is a less invasive alternative.
+-->
+<!ELEMENT lookup-method EMPTY>
+
+<!--
+	Name of a lookup method. This method should take no arguments.
+-->
+<!ATTLIST lookup-method name CDATA #IMPLIED>
+
+<!--
+	Name of the bean in the current or ancestor factories that the lookup method
+	should resolve to. Often this bean will be a prototype, in which case the
+	lookup method will return a distinct instance on every invocation. This
+	is useful for single-threaded objects.
+-->
+<!ATTLIST lookup-method bean CDATA #IMPLIED>
+
+
+<!--
+	Similar to the lookup method mechanism, the replaced-method element is used to control
+	IoC container method overriding: Method Injection. This mechanism allows the overriding
+	of a method with arbitrary code.
+-->
+<!ELEMENT replaced-method (
+	(arg-type)*
+)>
+
+<!--
+	Name of the method whose implementation should be replaced by the IoC container.
+	If this method is not overloaded, there's no need to use arg-type subelements.
+	If this method is overloaded, arg-type subelements must be used for all
+	override definitions for the method.
+-->
+<!ATTLIST replaced-method name CDATA #IMPLIED>
+
+<!--
+	Bean name of an implementation of the MethodReplacer interface
+	in the current or ancestor factories. This may be a singleton or prototype
+	bean. If it's a prototype, a new instance will be used for each method replacement.
+	Singleton usage is the norm.
+-->
+<!ATTLIST replaced-method replacer CDATA #IMPLIED>
+
+<!--
+	Subelement of replaced-method identifying an argument for a replaced method
+	in the event of method overloading.
+-->
+<!ELEMENT arg-type (#PCDATA)>
+
+<!--
+	Specification of the type of an overloaded method argument as a String.
+	For convenience, this may be a substring of the FQN. E.g. all the
+	following would match "java.lang.String":
+	- java.lang.String
+	- String
+	- Str
+
+	As the number of arguments will be checked also, this convenience can often
+	be used to save typing.
+-->
+<!ATTLIST arg-type match CDATA #IMPLIED>
+
+
+<!--
+	Defines a reference to another bean in this factory or an external
+	factory (parent or included factory).
+-->
+<!ELEMENT ref EMPTY>
+
+<!--
+	References must specify a name of the target bean.
+	The "bean" attribute can reference any name from any bean in the context,
+	to be checked at runtime.
+	Local references, using the "local" attribute, have to use bean ids;
+	they can be checked by this DTD, thus should be preferred for references
+	within the same bean factory XML file.
+-->
+<!ATTLIST ref bean CDATA #IMPLIED>
+<!ATTLIST ref local IDREF #IMPLIED>
+<!ATTLIST ref parent CDATA #IMPLIED>
+
+
+<!--
+	Defines a string property value, which must also be the id of another
+	bean 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 bean ids by the xml
+	parser, and name completion by helper tools.
+-->
+<!ELEMENT idref EMPTY>
+
+<!--
+	ID refs must specify a name of the target bean.
+	The "bean" attribute can reference any name from any bean in the context,
+	potentially to be checked at runtime by bean factory implementations.
+	Local references, using the "local" attribute, have to use bean ids;
+	they can be checked by this DTD, thus should be preferred for references
+	within the same bean factory XML file.
+-->
+<!ATTLIST idref bean CDATA #IMPLIED>
+<!ATTLIST idref local IDREF #IMPLIED>
+
+
+<!--
+	Contains a string representation of a property value.
+	The property may be a string, or may be converted to the
+	required type using the JavaBeans PropertyEditor
+	machinery. This makes it possible for application developers
+	to write custom PropertyEditor implementations that can
+	convert strings to objects.
+
+	Note that this is recommended for simple objects only.
+	Configure more complex objects by populating JavaBean
+	properties with references to other beans.
+-->
+<!ELEMENT value (#PCDATA)>
+
+<!--
+	The value tag can have an optional type attribute, to specify the
+	exact type that the value should be converted to. Only needed
+	if the type of the target property or constructor argument is
+	too generic: for example, in case of a collection element.
+-->
+<!ATTLIST value type CDATA #IMPLIED>
+
+<!--
+	Denotes a Java 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 PropertyEditor does so.
+-->
+<!ELEMENT null (#PCDATA)>
+
+
+<!--
+	A list can contain multiple inner bean, ref, collection, or value elements.
+	Java lists are untyped, pending generics support in Java 1.5,
+	although references will be strongly typed.
+	A list can also map to an array type. The necessary conversion
+	is automatically performed by the BeanFactory.
+-->
+<!ELEMENT list (
+	(bean | ref | idref | value | null | list | set | map | props)*
+)>
+
+<!-- Enable/disable merging for collections when using parent/child beans -->
+<!ATTLIST list merge (true | false | default) "default">
+
+<!-- Specify the default Java type for nested values -->
+<!ATTLIST list value-type CDATA #IMPLIED>
+
+<!--
+	A set can contain multiple inner bean, ref, collection, or value elements.
+	Java sets are untyped, pending generics support in Java 1.5,
+	although references will be strongly typed.
+-->
+<!ELEMENT set (
+	(bean | ref | idref | value | null | list | set | map | props)*
+)>
+
+<!-- Enable/disable merging for collections when using parent/child beans -->
+<!ATTLIST set merge (true | false | default) "default">
+
+<!-- Specify the default Java type for nested values -->
+<!ATTLIST set value-type CDATA #IMPLIED>
+
+<!--
+	A Spring map is a mapping from a string key to object.
+	Maps may be empty.
+-->
+<!ELEMENT map (
+	(entry)*
+)>
+
+<!-- Enable/disable merging for collections when using parent/child beans -->
+<!ATTLIST map merge (true | false | default) "default">
+
+<!-- Specify the default Java type for nested entry keys -->
+<!ATTLIST map key-type CDATA #IMPLIED>
+
+<!-- Specify the default Java type for nested entry values -->
+<!ATTLIST map value-type CDATA #IMPLIED>
+
+<!--
+	A map entry can be an inner bean, ref, value, or collection.
+	The key of the entry is given by the "key" attribute or child element.
+-->
+<!ELEMENT entry (
+  key?,
+	(bean | ref | idref | value | null | list | set | map | props)?
+)>
+
+<!--
+	Each map element must specify its key as attribute or as child element.
+	A key attribute is always a String value.
+-->
+<!ATTLIST entry key CDATA #IMPLIED>
+
+<!--
+  A short-cut alternative to a "key" element with a "ref bean=" child element.
+-->
+<!ATTLIST entry key-ref CDATA #IMPLIED>
+
+<!--
+  A short-cut alternative to a child element "value".
+-->
+<!ATTLIST entry value CDATA #IMPLIED>
+
+<!--
+  A short-cut alternative to a child element "ref bean=".
+-->
+<!ATTLIST entry value-ref CDATA #IMPLIED>
+
+<!--
+	A key element can contain an inner bean, ref, value, or collection.
+-->
+<!ELEMENT key (
+	(bean | ref | idref | value | null | list | set | map | props)
+)>
+
+
+<!--
+	Props elements differ from map elements in that values must be strings.
+	Props may be empty.
+-->
+<!ELEMENT props (
+	(prop)*
+)>
+
+<!-- Enable/disable merging for collections when using parent/child beans -->
+<!ATTLIST props merge (true | false | default) "default">
+
+<!--
+	Element content is the string value of the property.
+	Note that whitespace is trimmed off to avoid unwanted whitespace
+	caused by typical XML formatting.
+-->
+<!ELEMENT prop (#PCDATA)>
+
+<!--
+	Each property element must specify its key.
+-->
+<!ATTLIST prop key CDATA #REQUIRED>
+

Propchange: portals/jetspeed-2/applications/j2-admin/trunk/src/webapp/WEB-INF/springmvc/dtd/spring-beans.dtd
------------------------------------------------------------------------------
    svn:eol-style = native



---------------------------------------------------------------------
To unsubscribe, e-mail: jetspeed-dev-unsubscribe@portals.apache.org
For additional commands, e-mail: jetspeed-dev-help@portals.apache.org