Announcement Announcement Module
Collapse
No announcement yet.
XSD / XML Schema for spring-beans.dtd and/or appContext.xml Page Title Module
Move Remove Collapse
X
Conversation Detail Module
Collapse
  • Filter
  • Time
  • Show
Clear All
new posts

  • XSD / XML Schema for spring-beans.dtd and/or appContext.xml

    Various IDEs have code insight capabilities when editing XML files. I'm not familiar with the details of the XML headers, but I believe if you specifiy a name space (xmlns) and the schema location this allows IDEs to enable code insight. Then, for example, when you type in a <, the list of available targets will be displayed.

    Has anyone done anything with this for Spring's applicationContext.xml files?

    I tried using a generic DTD to XSD converter tool to create an XSD from spring-beans.dtd, but I'm not sure how to hook this into a Spring applicationContext.xml file. Suggestions? Thanks, in advance.

  • #2
    You can use oXygen to convert the DTD to a schema.
    Below is just a straight conversion, without any advanced features from the spring-beans.dtd in my cvs head checkout.
    You can use it within oXygen to edit a spring beans context file, all those popup hints are available.

    Code:
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns&#58;xsi="http&#58;//www.w3.org/2001/XMLSchema-instance"
         xsi&#58;noNamespaceSchemaLocation="spring-beans.xsd">
        <description></description>
        <import resource=""/>
        <bean id="thisIsSomeBean" class="com.whatever.whereever.SomeClass">
            <property name="someProperty"><ref bean="someOtherBean"/></property>
        </bean>
    </beans>
    Code:
    <?xml version="1.0" encoding="UTF-8"?>
    <!--
      Spring XML Beans DTD
      Authors&#58; Rod Johnson, Juergen Hoeller, Alef Arendsen, Colin Sampaleanu
      
      This defines a simple and consistent way of creating a namespace
      of JavaBeans objects, managed by a Spring BeanFactory, read by
      XmlBeanDefinitionReader &#40;with DefaultXmlBeanDefinitionParser&#41;.
      
      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" &#40;shared instances&#41; or "prototypes"
      &#40;independent instances&#41;. 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
      &#40;or an ancestor factory&#41;.
      
      As alternative to bean references, "inner bean definitions" can be used.
      Singleton flags of such inner bean definitions are effectively ignored&#58;
      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&#58;
      
      <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
      	"http&#58;//www.springframework.org/dtd/spring-beans.dtd">
    -->
    <!--
      The document root. A document can contain bean definitions only,
      imports only, or a mixture of both &#40;typically with imports first&#41;.
    -->
    <xs&#58;schema xmlns&#58;xs="http&#58;//www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
        <xs&#58;element name="beans">
            <xs&#58;complexType>
                <xs&#58;sequence>
                    <xs&#58;element minOccurs="0" ref="description"/>
                    <xs&#58;choice minOccurs="0" maxOccurs="unbounded">
                        <xs&#58;element ref="import"/>
                        <xs&#58;element ref="alias"/>
                        <xs&#58;element ref="bean"/>
                    </xs&#58;choice>
                </xs&#58;sequence>
                <xs&#58;attributeGroup ref="attlist.beans"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        Default values for all bean definitions. Can be overridden at
        the "bean" level. See those attribute definitions for details.
      -->
        <xs&#58;attributeGroup name="attlist.beans">
            <xs&#58;attribute name="default-lazy-init" default="false">
                <xs&#58;simpleType>
                    <xs&#58;restriction base="xs&#58;token">
                        <xs&#58;enumeration value="true"/>
                        <xs&#58;enumeration value="false"/>
                    </xs&#58;restriction>
                </xs&#58;simpleType>
            </xs&#58;attribute>
            <xs&#58;attribute name="default-autowire" default="no">
                <xs&#58;simpleType>
                    <xs&#58;restriction base="xs&#58;token">
                        <xs&#58;enumeration value="no"/>
                        <xs&#58;enumeration value="byName"/>
                        <xs&#58;enumeration value="byType"/>
                        <xs&#58;enumeration value="constructor"/>
                        <xs&#58;enumeration value="autodetect"/>
                    </xs&#58;restriction>
                </xs&#58;simpleType>
            </xs&#58;attribute>
            <xs&#58;attribute name="default-dependency-check" default="none">
                <xs&#58;simpleType>
                    <xs&#58;restriction base="xs&#58;token">
                        <xs&#58;enumeration value="none"/>
                        <xs&#58;enumeration value="objects"/>
                        <xs&#58;enumeration value="simple"/>
                        <xs&#58;enumeration value="all"/>
                    </xs&#58;restriction>
                </xs&#58;simpleType>
            </xs&#58;attribute>
        </xs&#58;attributeGroup>
        <!--
        Element containing informative text describing the purpose of the enclosing
        element. Always optional.
        Used primarily for user documentation of XML bean definition documents.
      -->
        <xs&#58;element name="description" type="xs&#58;string"/>
        <!-- Specifies an XML bean definition resource to import. -->
        <xs&#58;element name="import">
            <xs&#58;complexType>
                <xs&#58;attributeGroup ref="attlist.import"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        The relative resource location of the XML bean definition file to import,
        for example "myImport.xml" or "includes/myImport.xml" or "../myImport.xml".
      -->
        <xs&#58;attributeGroup name="attlist.import">
            <xs&#58;attribute name="resource" use="required"/>
        </xs&#58;attributeGroup>
        <!-- Defines an alias for a bean, which can reside in a different definition file. -->
        <xs&#58;element name="alias">
            <xs&#58;complexType>
                <xs&#58;attributeGroup ref="attlist.alias"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!-- The name of the bean to define an alias for. -->
        <xs&#58;attributeGroup name="attlist.alias">
            <xs&#58;attribute name="name" use="required"/>
            <xs&#58;attribute name="alias" use="required"/>
        </xs&#58;attributeGroup>
        <!-- The alias name to define for the bean. -->
        <!--
        Defines a single &#40;usually named&#41; 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.
      -->
        <xs&#58;element name="bean">
            <xs&#58;complexType>
                <xs&#58;sequence>
                    <xs&#58;element minOccurs="0" ref="description"/>
                    <xs&#58;choice minOccurs="0" maxOccurs="unbounded">
                        <xs&#58;element ref="constructor-arg"/>
                        <xs&#58;element ref="property"/>
                        <xs&#58;element ref="lookup-method"/>
                        <xs&#58;element ref="replaced-method"/>
                    </xs&#58;choice>
                </xs&#58;sequence>
                <xs&#58;attributeGroup ref="attlist.bean"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        Beans can be identified by an id, to enable reference checking.
        
        There are constraints on a valid XML id&#58; 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
        &#40;with an appended counter like "#2" if there is already a bean with that name&#41;.
      -->
        <xs&#58;attributeGroup name="attlist.bean">
            <xs&#58;attribute name="id" type="xs&#58;ID"/>
            <xs&#58;attribute name="name"/>
            <xs&#58;attribute name="class"/>
            <xs&#58;attribute name="parent"/>
            <xs&#58;attribute name="abstract" default="false">
                <xs&#58;simpleType>
                    <xs&#58;restriction base="xs&#58;token">
                        <xs&#58;enumeration value="true"/>
                        <xs&#58;enumeration value="false"/>
                    </xs&#58;restriction>
                </xs&#58;simpleType>
            </xs&#58;attribute>
            <xs&#58;attribute name="singleton" default="true">
                <xs&#58;simpleType>
                    <xs&#58;restriction base="xs&#58;token">
                        <xs&#58;enumeration value="true"/>
                        <xs&#58;enumeration value="false"/>
                    </xs&#58;restriction>
                </xs&#58;simpleType>
            </xs&#58;attribute>
            <xs&#58;attribute name="lazy-init" default="default">
                <xs&#58;simpleType>
                    <xs&#58;restriction base="xs&#58;token">
                        <xs&#58;enumeration value="true"/>
                        <xs&#58;enumeration value="false"/>
                        <xs&#58;enumeration value="default"/>
                    </xs&#58;restriction>
                </xs&#58;simpleType>
            </xs&#58;attribute>
            <xs&#58;attribute name="autowire" default="default">
                <xs&#58;simpleType>
                    <xs&#58;restriction base="xs&#58;token">
                        <xs&#58;enumeration value="no"/>
                        <xs&#58;enumeration value="byName"/>
                        <xs&#58;enumeration value="byType"/>
                        <xs&#58;enumeration value="constructor"/>
                        <xs&#58;enumeration value="autodetect"/>
                        <xs&#58;enumeration value="default"/>
                    </xs&#58;restriction>
                </xs&#58;simpleType>
            </xs&#58;attribute>
            <xs&#58;attribute name="dependency-check" default="default">
                <xs&#58;simpleType>
                    <xs&#58;restriction base="xs&#58;token">
                        <xs&#58;enumeration value="none"/>
                        <xs&#58;enumeration value="objects"/>
                        <xs&#58;enumeration value="simple"/>
                        <xs&#58;enumeration value="all"/>
                        <xs&#58;enumeration value="default"/>
                    </xs&#58;restriction>
                </xs&#58;simpleType>
            </xs&#58;attribute>
            <xs&#58;attribute name="depends-on"/>
            <xs&#58;attribute name="init-method"/>
            <xs&#58;attribute name="destroy-method"/>
            <xs&#58;attribute name="factory-method"/>
            <xs&#58;attribute name="factory-bean"/>
        </xs&#58;attributeGroup>
        <!--
        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.
      -->
        <!--
        Each bean definition must specify the fully qualified name of the class,
        except if it pure serves as parent for child bean definitions.
      -->
        <!--
        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&#58;
        depends on, autowire mode, dependency check, singleton, lazy init.
      -->
        <!--
        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.
      -->
        <!--
        Is this bean a "singleton" &#40;one shared instance, which will
        be returned by all calls to getBean&#40;&#41; with the id&#41;,
        or a "prototype" &#40;independent instance resulting from each call to
        getBean&#40;&#41;. Default is singleton.
        
        Singletons are most commonly used, and are ideal for multi-threaded
        service objects.
      -->
        <!--
        If this bean should be lazily initialized.
        If false, it will get instantiated on startup by bean factories
        that perform eager initialization of singletons.
      -->
        <!--
        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&#58;
        
        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 behaviour can be combined with dependency
        checking, which will be performed after all autowiring has been completed.
      -->
        <!--
        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 &#40;other beans in the factory&#41;
        "all" includes both types of dependency checking
      -->
        <!--
        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 &#40;*ugh*&#41; or database preparation on startup.
      -->
        <!--
        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.
      -->
        <!--
        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&#58; Only invoked on singleton beans!
      -->
        <!--
        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.
      -->
        <!--
        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 &#40;rather than static&#41; method to be used.
      -->
        <!--
        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&#58; A single generic argument value will just be used once, rather than
        potentially matched multiple times &#40;as of Spring 1.1&#41;.
        
        constructor-arg elements are also used in conjunction with the factory-method
        element to construct beans using static or instance factory methods.
      -->
        <xs&#58;element name="constructor-arg">
            <xs&#58;complexType>
                <xs&#58;sequence>
                    <xs&#58;element minOccurs="0" ref="description"/>
                    <xs&#58;choice minOccurs="0">
                        <xs&#58;element ref="bean"/>
                        <xs&#58;element ref="ref"/>
                        <xs&#58;element ref="idref"/>
                        <xs&#58;element ref="value"/>
                        <xs&#58;element ref="null"/>
                        <xs&#58;element ref="list"/>
                        <xs&#58;element ref="set"/>
                        <xs&#58;element ref="map"/>
                        <xs&#58;element ref="props"/>
                    </xs&#58;choice>
                </xs&#58;sequence>
                <xs&#58;attributeGroup ref="attlist.constructor-arg"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        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&#58;attributeGroup name="attlist.constructor-arg">
            <xs&#58;attribute name="index"/>
            <xs&#58;attribute name="type"/>
            <xs&#58;attribute name="ref"/>
            <xs&#58;attribute name="value"/>
        </xs&#58;attributeGroup>
        <!--
        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.
      -->
        <!-- A short-cut alternative to a child element "ref bean=". -->
        <!-- A short-cut alternative to a child element "value". -->
        <!--
        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.
      -->
        <xs&#58;element name="property">
            <xs&#58;complexType>
                <xs&#58;sequence>
                    <xs&#58;element minOccurs="0" ref="description"/>
                    <xs&#58;choice minOccurs="0">
                        <xs&#58;element ref="bean"/>
                        <xs&#58;element ref="ref"/>
                        <xs&#58;element ref="idref"/>
                        <xs&#58;element ref="value"/>
                        <xs&#58;element ref="null"/>
                        <xs&#58;element ref="list"/>
                        <xs&#58;element ref="set"/>
                        <xs&#58;element ref="map"/>
                        <xs&#58;element ref="props"/>
                    </xs&#58;choice>
                </xs&#58;sequence>
                <xs&#58;attributeGroup ref="attlist.property"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        The property name attribute is the name of the JavaBean property.
        This follows JavaBean conventions&#58; a name of "age" would correspond
        to setAge&#40;&#41;/optional getAge&#40;&#41; methods.
      -->
        <xs&#58;attributeGroup name="attlist.property">
            <xs&#58;attribute name="name" use="required"/>
            <xs&#58;attribute name="ref"/>
            <xs&#58;attribute name="value"/>
        </xs&#58;attributeGroup>
        <!-- A short-cut alternative to a child element "ref bean=". -->
        <!-- A short-cut alternative to a child element "value". -->
        <!--
        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&#40;&#41; calls for non-singleton instances
        at runtime. In this case, Method Injection is a less invasive alternative.
      -->
        <xs&#58;element name="lookup-method">
            <xs&#58;complexType>
                <xs&#58;attributeGroup ref="attlist.lookup-method"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!-- Name of a lookup method. This method should take no arguments. -->
        <xs&#58;attributeGroup name="attlist.lookup-method">
            <xs&#58;attribute name="name"/>
            <xs&#58;attribute name="bean"/>
        </xs&#58;attributeGroup>
        <!--
        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.
      -->
        <!--
        Similar to the lookup method mechanism, the replaced-method element is used to control
        IoC container method overriding&#58; Method Injection. This mechanism allows the overriding
        of a method with arbitrary code. 
      -->
        <xs&#58;element name="replaced-method">
            <xs&#58;complexType>
                <xs&#58;sequence>
                    <xs&#58;element minOccurs="0" maxOccurs="unbounded" ref="arg-type"/>
                </xs&#58;sequence>
                <xs&#58;attributeGroup ref="attlist.replaced-method"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        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.
      -->
        <xs&#58;attributeGroup name="attlist.replaced-method">
            <xs&#58;attribute name="name"/>
            <xs&#58;attribute name="replacer"/>
        </xs&#58;attributeGroup>
        <!--
        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.
      -->
        <!--
        Subelement of replaced-method identifying an argument for a replaced method
        in the event of method overloading.
      -->
        <xs&#58;element name="arg-type">
            <xs&#58;complexType mixed="true">
                <xs&#58;attributeGroup ref="attlist.arg-type"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        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"&#58;
        - java.lang.String
        - String
        - Str
        
        As the number of arguments will be checked also, this convenience can often
        be used to save typing.
      -->
        <xs&#58;attributeGroup name="attlist.arg-type">
            <xs&#58;attribute name="match"/>
        </xs&#58;attributeGroup>
        <!--
        Defines a reference to another bean in this factory or an external
        factory &#40;parent or included factory&#41;.
      -->
        <xs&#58;element name="ref">
            <xs&#58;complexType>
                <xs&#58;attributeGroup ref="attlist.ref"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        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.
      -->
        <xs&#58;attributeGroup name="attlist.ref">
            <xs&#58;attribute name="bean"/>
            <xs&#58;attribute name="local" type="xs&#58;IDREF"/>
            <xs&#58;attribute name="parent"/>
        </xs&#58;attributeGroup>
        <!--
        Defines a string property value, which must also be the id of another
        bean in this factory or an external factory &#40;parent or included factory&#41;.
        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.
      -->
        <xs&#58;element name="idref">
            <xs&#58;complexType>
                <xs&#58;attributeGroup ref="attlist.idref"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        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.
      -->
        <xs&#58;attributeGroup name="attlist.idref">
            <xs&#58;attribute name="bean"/>
            <xs&#58;attribute name="local" type="xs&#58;IDREF"/>
        </xs&#58;attributeGroup>
        <!--
        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.
      -->
        <xs&#58;element name="value">
            <xs&#58;complexType mixed="true">
                <xs&#58;attributeGroup ref="attlist.value"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        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&#58; for example, in case of a collection element.
      -->
        <xs&#58;attributeGroup name="attlist.value">
            <xs&#58;attribute name="type"/>
        </xs&#58;attributeGroup>
        <!--
        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.
      -->
        <xs&#58;element name="null" type="xs&#58;string"/>
        <!--
        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.
      -->
        <xs&#58;element name="list">
            <xs&#58;complexType>
                <xs&#58;choice minOccurs="0" maxOccurs="unbounded">
                    <xs&#58;element ref="bean"/>
                    <xs&#58;element ref="ref"/>
                    <xs&#58;element ref="idref"/>
                    <xs&#58;element ref="value"/>
                    <xs&#58;element ref="null"/>
                    <xs&#58;element ref="list"/>
                    <xs&#58;element ref="set"/>
                    <xs&#58;element ref="map"/>
                    <xs&#58;element ref="props"/>
                </xs&#58;choice>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        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.
      -->
        <xs&#58;element name="set">
            <xs&#58;complexType>
                <xs&#58;choice minOccurs="0" maxOccurs="unbounded">
                    <xs&#58;element ref="bean"/>
                    <xs&#58;element ref="ref"/>
                    <xs&#58;element ref="idref"/>
                    <xs&#58;element ref="value"/>
                    <xs&#58;element ref="null"/>
                    <xs&#58;element ref="list"/>
                    <xs&#58;element ref="set"/>
                    <xs&#58;element ref="map"/>
                    <xs&#58;element ref="props"/>
                </xs&#58;choice>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        A Spring map is a mapping from a string key to object.
        Maps may be empty.
      -->
        <xs&#58;element name="map">
            <xs&#58;complexType>
                <xs&#58;sequence>
                    <xs&#58;element minOccurs="0" maxOccurs="unbounded" ref="entry"/>
                </xs&#58;sequence>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        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.
      -->
        <xs&#58;element name="entry">
            <xs&#58;complexType>
                <xs&#58;sequence>
                    <xs&#58;element minOccurs="0" ref="key"/>
                    <xs&#58;choice minOccurs="0">
                        <xs&#58;element ref="bean"/>
                        <xs&#58;element ref="ref"/>
                        <xs&#58;element ref="idref"/>
                        <xs&#58;element ref="value"/>
                        <xs&#58;element ref="null"/>
                        <xs&#58;element ref="list"/>
                        <xs&#58;element ref="set"/>
                        <xs&#58;element ref="map"/>
                        <xs&#58;element ref="props"/>
                    </xs&#58;choice>
                </xs&#58;sequence>
                <xs&#58;attributeGroup ref="attlist.entry"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        Each map element must specify its key as attribute or as child element.
        A key attribute is always a String value.
      -->
        <xs&#58;attributeGroup name="attlist.entry">
            <xs&#58;attribute name="key"/>
            <xs&#58;attribute name="key-ref"/>
            <xs&#58;attribute name="value"/>
            <xs&#58;attribute name="value-ref"/>
        </xs&#58;attributeGroup>
        <!-- A short-cut alternative to a "key" element with a "ref bean=" child element. -->
        <!-- A short-cut alternative to a child element "value". -->
        <!-- A short-cut alternative to a child element "ref bean=". -->
        <!-- A key element can contain an inner bean, ref, value, or collection. -->
        <xs&#58;element name="key">
            <xs&#58;complexType>
                <xs&#58;choice>
                    <xs&#58;element ref="bean"/>
                    <xs&#58;element ref="ref"/>
                    <xs&#58;element ref="idref"/>
                    <xs&#58;element ref="value"/>
                    <xs&#58;element ref="null"/>
                    <xs&#58;element ref="list"/>
                    <xs&#58;element ref="set"/>
                    <xs&#58;element ref="map"/>
                    <xs&#58;element ref="props"/>
                </xs&#58;choice>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        Props elements differ from map elements in that values must be strings.
        Props may be empty.
      -->
        <xs&#58;element name="props">
            <xs&#58;complexType>
                <xs&#58;sequence>
                    <xs&#58;element minOccurs="0" maxOccurs="unbounded" ref="prop"/>
                </xs&#58;sequence>
            </xs&#58;complexType>
        </xs&#58;element>
        <!--
        Element content is the string value of the property.
        Note that whitespace is trimmed off to avoid unwanted whitespace
        caused by typical XML formatting.
      -->
        <xs&#58;element name="prop">
            <xs&#58;complexType mixed="true">
                <xs&#58;attributeGroup ref="attlist.prop"/>
            </xs&#58;complexType>
        </xs&#58;element>
        <!-- Each property element must specify its key. -->
        <xs&#58;attributeGroup name="attlist.prop">
            <xs&#58;attribute name="key" use="required"/>
        </xs&#58;attributeGroup>
    </xs&#58;schema>

    Comment

    Working...
    X