XSD语法

一直对校验XML合规性的XSD感兴趣。奈何这个行业需要学习的东西太多了，所以总是没有分配出时间。正好赶上最近给公司的一个快速开发框架的XML配置文件编写XSD，其中借鉴了Springde的XSD编写格式。正好也乘机对XSD做一次贴合实际的认知。

1. 概述

本次我们以 spring-beans-4.3.xsd为例，进行相应的讲解。 以下这份名为的 spring-beans-4.3.xsd的文档位于spring-beans-4.3.12.RELEASE.jar中的org/springframework/beans/factory/xml/下（该位置是被配置在Spring规定的META-INF/spring.schemas 中的）。

2. 详解

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!--schema 元素定义 schema 的根元素-->
<xsd:schema xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.springframework.org/schema/beans">

    <!-- import 元素用于向一个文档添加带有不同目标命名空间的多个 schema -->
    <!-- http://www.w3school.com.cn/schema/el_import.asp -->
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace"/>

    <!-- annotation: 规定 schema 的注释 -->
    <!-- http://www.w3school.com.cn/schema/el_annotation.asp -->
    <xsd:annotation>
        <!-- documentation: 定义 schema 中的文本注释; 该元素必须位于 annotation 元素内-->
        <!-- http://www.w3school.com.cn/schema/el_documentation.asp -->
        <xsd:documentation><![CDATA[
    Spring XML Beans Schema, version 4.3
    Authors: Juergen Hoeller, Rob Harrop, Mark Fisher, Chris Beams

    This defines a simple and consistent way of creating a namespace
    of JavaBeans objects, managed by a Spring BeanFactory, read by
    XmlBeanDefinitionReader (with DefaultBeanDefinitionDocumentReader).

    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.

    A bean instance can be a "singleton" (shared instance) or a "prototype"
    (independent instance). Further scopes can be provided by extended
    bean factories, for example in a web environment.

    References among beans are supported, that is, 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.
    Such inner beans do not have an independent lifecycle; they are typically
    anonymous nested objects that share the scope of their containing bean.

    There is also support for lists, sets, maps, and java.util.Properties
    as bean property types or constructor argument types.
        ]]></xsd:documentation>
    </xsd:annotation>

    <!-- 类似OOP里的抽象基类, 抽取了公用的代码: id属性 -->
    <!-- 最大的好处是建立了与外界的隔离层, 预留出了缓冲带来应对需求变更。-->
    <!-- complexType:定义复杂类型。复杂类型的元素是包含其他元素和/或属性的 XML 元素。 -->
    <!-- base types -->
    <xsd:complexType name="identifiedType" abstract="true">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    The unique identifier for a bean. The scope of the identifier
    is the enclosing bean factory.
            ]]></xsd:documentation>
        </xsd:annotation>
        <!-- attribute : 定义一个属性 -->
        <!-- http://www.w3school.com.cn/schema/el_attribute.asp -->
        <xsd:attribute name="id" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    The unique identifier for a bean. A bean id may not be used more than once
    within the same <beans> element.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
    </xsd:complexType>

    <!-- 顶层的根节点 <beans> -->
    <!-- Top-level <beans> tag -->
    <!-- element 元素定义一个XML元素 -->
    <!-- http://www.w3school.com.cn/schema/el_element.asp -->
    <xsd:element name="beans">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    Container for <bean> and other elements, typically the root element in the document.
    Allows the definition of default values for all nested bean definitions. May itself
    be nested for the purpose of defining a subset of beans with certain default values or
    to be registered only when certain profile(s) are active. Any such nested <beans> element
    must be declared as the last element in the document.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <!-- sequence 元素要求组中的元素以指定的顺序出现在包含元素中。每个子元素可出现 0 次到任意次数。 -->
            <!-- http://www.w3school.com.cn/schema/el_sequence.asp -->
            <xsd:sequence>
                <xsd:element ref="description" minOccurs="0"/>
                <!-- 可能出现的元素, 出现的最小次数为0 -->
                <!--  choice 元素: 仅允许包含在 <choice> 声明中的元素之一出现在包含元素中。 -->
                <!-- 即<beans>所包含的子节点只允许有import,alias,bean,any(都有这个了...) -->
                <xsd:choice minOccurs="0" maxOccurs="unbounded">
                    <xsd:element ref="import"/>
                    <xsd:element ref="alias"/>
                    <xsd:element ref="bean"/>
                    <!--对于出现在其他命名空间下的xml元素, 执行严格的xml校验语法; 这些xml元素允许最少出现0次-->
                    <xsd:any namespace="##other" processContents="strict" minOccurs="0" maxOccurs="unbounded"/>
                </xsd:choice>
                <!-- ref属性: 对另一个元素的引用。ref 属性可包含一个命名空间前缀。-->
                <xsd:element ref="beans" minOccurs="0" maxOccurs="unbounded"/>
            </xsd:sequence>
            <!-- <beans>拥有的属性profile, 可选的配置, 该属性为String类型的 -->
            <xsd:attribute name="profile" use="optional" type="xsd:string">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    The set of profiles for which this <beans> element should be parsed. Multiple profiles
    can be separated by spaces, commas, or semi-colons.

    If one or more of the specified profiles are active at time of parsing, the <beans>
    element will be parsed, and all of its <bean> elements registered, &lt;import&gt;
    elements followed, etc.  If none of the specified profiles are active at time of
    parsing, then the entire element and its contents will be ignored.

    If a profile is prefixed with the NOT operator '!', e.g.

        <beans profile="p1,!p2">

    indicates that the <beans> element should be parsed if profile "p1" is active or
    if profile "p2" is not active.

    Profiles are activated in one of two ways:
        Programmatic:
            ConfigurableEnvironment#setActiveProfiles(String...)
            ConfigurableEnvironment#setDefaultProfiles(String...)

        Properties (typically through -D system properties, environment variables, or
        servlet context init params):
            spring.profiles.active=p1,p2
            spring.profiles.default=p1,p2
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
            <!-- <beans>拥有的属性default-lazy-init -->
            <xsd:attribute name="default-lazy-init" default="default" type="defaultable-boolean">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    The default 'lazy-init' value; see the documentation for the
    'lazy-init' attribute of the 'bean' element. The default is "default",
    indicating inheritance from outer 'beans' sections in case of nesting,
    otherwise falling back to "false".
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
            <!-- <beans>拥有的属性default-merge -->
            <xsd:attribute name="default-merge" default="default" type="defaultable-boolean">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    The default 'merge' value; see the documentation for the 'merge'
    attribute of the various collection elements. The default is "default",
    indicating inheritance from outer 'beans' sections in case of nesting,
    otherwise falling back to "false".
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
            <!-- <beans>拥有的属性default-autowire -->
            <xsd:attribute name="default-autowire" default="default">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    The default 'autowire' value; see the documentation for the
    'autowire' attribute of the 'bean' element. The default is "default",
    indicating inheritance from outer 'beans' sections in case of nesting,
    otherwise falling back to "no" (i.e. no externally driven autowiring).
                    ]]></xsd:documentation>
                </xsd:annotation>
                <!--属性default-autowire 的可选枚举值-->
                <!-- simpleType 元素定义一个简单类型，规定与具有纯文本内容的元素或属性的值有关的信息以及对它们的约束。 -->
                <xsd:simpleType>
                    <!-- restriction 元素定义对 simpleType、simpleContent 或 complexContent 定义的约束。-->
                    <xsd:restriction base="xsd:NMTOKEN">
                        <!-- enumeration : 定义可接受值的一个列表 -->
                        <xsd:enumeration value="default"/>
                        <xsd:enumeration value="no"/>
                        <xsd:enumeration value="byName"/>
                        <xsd:enumeration value="byType"/>
                        <xsd:enumeration value="constructor"/>
                    </xsd:restriction>
                </xsd:simpleType>
            </xsd:attribute>
            <!-- <beans>拥有的属性default-autowire-candidates -->
            <xsd:attribute name="default-autowire-candidates" type="xsd:string">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    A default bean name pattern for identifying autowire candidates:
    e.g. "*Service", "data*", "*Service*", "data*Service".
    Also accepts a comma-separated list of patterns: e.g. "*Service,*Dao".
    See the documentation for the 'autowire-candidate' attribute of the
    'bean' element for the semantic details of autowire candidate beans.
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
            <xsd:attribute name="default-init-method" type="xsd:string">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    The default 'init-method' value; see the documentation for the
    'init-method' attribute of the 'bean' element.
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
            <!-- <beans>拥有的属性default-destroy-method -->
            <xsd:attribute name="default-destroy-method" type="xsd:string">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    The default 'destroy-method' value; see the documentation for the
    'destroy-method' attribute of the 'bean' element.
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
            <!-- 其他属性; <anyAttribute>元素使我们有能力通过未被 schema 规定的属性来扩展 XML 文档！ 这样我们就可以向<bean>中扩展自定义属性了, 而不会被XSD验证为非法-->
            <!-- http://www.w3school.com.cn/schema/schema_complex_anyattribute.asp -->
            <xsd:anyAttribute namespace="##other" processContents="lax"/>
        </xsd:complexType>
    </xsd:element>

    <!-- 名为description的xml节点 -->
    <xsd:element name="description">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    Contains informative text describing the purpose of the enclosing element.
    Used primarily for user documentation of XML bean definition documents.
            ]]></xsd:documentation>
        </xsd:annotation>
        <!-- mixed规定是否允许字符数据出现在该复杂类型的子元素之间。 默认值为 false。 -->
        <!-- 这里被设置为true, 所以可以声明为这样: <description>==LQ ==</description> -->
        <xsd:complexType mixed="true">
            <xsd:choice minOccurs="0" maxOccurs="unbounded"/>
        </xsd:complexType>
    </xsd:element>

    <!-- 名为import的xml节点 -->
    <xsd:element name="import">
        <xsd:annotation>
            <xsd:documentation source="java:org.springframework.core.io.Resource"><![CDATA[
    Specifies an XML bean definition resource to import.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <!-- complexContent 元素定义对复杂类型（包含混合内容或仅包含元素）的扩展或限制。 -->
            <xsd:complexContent>
                <!-- restriction 元素定义对 simpleType、simpleContent 或 complexContent 定义的约束。 -->
                <!-- base : 必需。规定在该 schema（或由指定的命名空间指示的其他 schema）中定义的内建数据类型、simpleType 或 complexType 元素的名称。-->
                <xsd:restriction base="xsd:anyType">
                    <!-- 一个必要的属性resource, 该属性为字符串类型 -->
                    <xsd:attribute name="resource" type="xsd:string" use="required">
                        <!--这里的注释内容可以在我们编写相应的xml时进行提示性展示, 参见下面的图1-->
                        <xsd:annotation>
                            <xsd:documentation><![CDATA[
    The relative resource location of the XML (bean definition) file to import,
    for example "myImport.xml" or "includes/myImport.xml" or "../myImport.xml".
                            ]]></xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>
                </xsd:restriction>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="alias">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    Defines an alias for a bean (which can reside in a different definition
    resource).
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:restriction base="xsd:anyType">
                    <xsd:attribute name="name" type="xsd:string" use="required">
                        <xsd:annotation>
                            <xsd:documentation><![CDATA[
    The name of the bean to define an alias for.
                            ]]></xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>
                    <xsd:attribute name="alias" type="xsd:string" use="required">
                        <xsd:annotation>
                            <xsd:documentation><![CDATA[
    The alias name to define for the bean.
                            ]]></xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>
                </xsd:restriction>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>

    <!--<bean>元素下所能拥有的xml元素-->
    <!-- group 元素用于定义在复杂类型定义中使用的元素组。 -->
    <xsd:group name="beanElements">
        <xsd:sequence>
            <xsd:element ref="description" minOccurs="0"/>
            <!--  choice 元素: 仅允许包含在 <choice> 声明中的元素之一出现在包含元素中。 -->
            <!-- 即<bean>所包含的子节点只允许有meta,constructor-arg,property等 -->           
            <xsd:choice minOccurs="0" maxOccurs="unbounded">
                <xsd:element ref="meta"/>
                <xsd:element ref="constructor-arg"/>
                <xsd:element ref="property"/>
                <xsd:element ref="qualifier"/>
                <xsd:element ref="lookup-method"/>
                <xsd:element ref="replaced-method"/>
                <!-- namespace : 规定包含可以使用的元素的命名空间 这里的##any指代来自任何命名空间的元素都可以出现（默认） -->
                <!-- processContents : 一个指示符，指示应用程序或 XML 处理器应如何根据由该 any 元素指定的元素处理 XML 文档的验证。 这里的属性值strict 指明的是:  XML 处理器必须获得所需命名空间的架构，并且必须验证来自这些命名空间的所有元素。（默认）-->
                <xsd:any namespace="##other" processContents="strict" minOccurs="0" maxOccurs="unbounded"/>
            </xsd:choice>
        </xsd:sequence>
    </xsd:group>

    <!--<bean>元素中允许出现的属性; 将被别处引用 -->
    <!-- attributeGroup 元素用于对属性声明进行组合，这样这些声明就能够以组合的形式合并到复杂类型中。 -->
    <xsd:attributeGroup name="beanAttributes">
        <xsd:attribute name="name" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    Can be used to create one or more aliases illegal in an (XML) id.
    Multiple aliases can be separated by any number of spaces, commas,
    or semi-colons (or indeed any mixture of the three).
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="class" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation source="java:java.lang.Class"><![CDATA[
    The fully qualified name of the bean's class, except if it serves only
    as a parent definition for child bean definitions.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="parent" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    The name of the parent bean definition.

    Will use the bean class of the parent if none is 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, scope, lazy init.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="scope" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    The scope of this bean: typically "singleton" (one shared instance,
    which will be returned by all calls to getBean with the given id), or
    "prototype" (independent instance resulting from each call to getBean).

    By default, a bean will be a singleton, unless the bean has a parent
    bean definition in which case it will inherit the parent's scope.

    Singletons are most commonly used, and are ideal for multi-threaded
    service objects. Further scopes, such as "request" or "session", might
    be supported by extended bean factories (e.g. in a web environment).

    Inner bean definitions inherit the scope of their containing bean
    definition, unless explicitly specified: The inner bean will be a
    singleton if the containing bean is a singleton, and a prototype if
    the containing bean is a prototype, etc.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="abstract" type="xsd:boolean">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    Is this bean "abstract", that is, not meant to be instantiated itself
    but rather just serving as parent for concrete child bean definitions?
    The 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 abstract bean definition.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="lazy-init" default="default" type="defaultable-boolean">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    Indicates whether this bean is to be lazily initialized. If "false",
    it will be instantiated on startup by bean factories that perform eager
    initialization of singletons. The effective default is "false".

    Note: This attribute will not be inherited by child bean definitions.
    Hence, it needs to be specified per concrete bean definition. It can be
    shared through the 'default-lazy-init' attribute at the 'beans' level
    and potentially inherited from outer 'beans' defaults in case of nested
    'beans' sections (e.g. with different profiles).
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="autowire" default="default">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    Controls whether bean properties are "autowired".
    This is an automagical process in which bean references don't need
    to be coded explicitly in the XML bean definition file, but rather the
    Spring container works out dependencies. The effective default is "no".

    There are 4 modes:

    1. "no"
    The traditional Spring default. No automagical wiring. Bean references
    must be defined in the XML file via the <ref/> element (or "ref"
    attribute). We recommend this in most cases as it makes documentation
    more explicit.

    Note that this default mode also allows for annotation-driven autowiring,
    if activated. "no" refers to externally driven autowiring only, not
    affecting any autowiring demands that the bean class itself expresses.

    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 container. If there is no matching bean by name, nothing
    special happens.

    3. "byType"
    Autowiring if there is exactly one bean of the property type in the
    container. If there is more than one, a fatal error is raised, and
    you cannot use byType autowiring for that bean. If there is none,
    nothing special happens.

    4. "constructor"
    Analogous to "byType" for constructor arguments. If there is not exactly
    one bean of the constructor argument type in the bean factory, a fatal
    error is raised.

    Note that explicit dependencies, i.e. "property" and "constructor-arg"
    elements, always override autowiring.

    Note: This attribute will not be inherited by child bean definitions.
    Hence, it needs to be specified per concrete bean definition. It can be
    shared through the 'default-autowire' attribute at the 'beans' level
    and potentially inherited from outer 'beans' defaults in case of nested
    'beans' sections (e.g. with different profiles).
                ]]></xsd:documentation>
            </xsd:annotation>
            <!-- 属性autowire的可选值 -->
            <xsd:simpleType>
                <xsd:restriction base="xsd:NMTOKEN">
                    <xsd:enumeration value="default"/>
                    <xsd:enumeration value="no"/>
                    <xsd:enumeration value="byName"/>
                    <xsd:enumeration value="byType"/>
                    <xsd:enumeration value="constructor"/>
                </xsd:restriction>
            </xsd:simpleType>
        </xsd:attribute>
        <xsd:attribute name="depends-on" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    The names of the beans that this bean depends on being initialized.
    The bean factory will guarantee that these beans get initialized
    before this bean.

    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.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="autowire-candidate" default="default" type="defaultable-boolean">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    Indicates whether or not this bean should be considered when looking
    for matching candidates to satisfy another bean's autowiring requirements.
    Note that this does not affect explicit references by name, which will get
    resolved even if the specified bean is not marked as an autowire candidate.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="primary" type="xsd:boolean">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    Specifies that this bean should be given preference when multiple
    candidates are qualified to autowire a single-valued dependency.
    If exactly one 'primary' bean exists among the candidates, it
    will be the autowired value.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="init-method" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    The name of the custom initialization method to invoke after setting
    bean properties. The method must have no arguments, but may throw any
    exception.

    This is an alternative to implementing Spring's InitializingBean
    interface or marking a method with the PostConstruct annotation.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="destroy-method" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    The name of the custom destroy method to invoke on bean factory shutdown.
    The method must have no arguments, but may throw any exception.

    This is an alternative to implementing Spring's DisposableBean
    interface or the standard Java Closeable/AutoCloseable interface,
    or marking a method with the PreDestroy annotation.

    Note: Only invoked on beans whose lifecycle is under the full
    control of the factory - which is always the case for singletons,
    but not guaranteed for any other scope.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="factory-method" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    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.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="factory-bean" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    Alternative to class attribute for factory-method usage.
    If this is specified, no class attribute should be used.
    This must 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.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <!-- anyAttribute 元素使创作者可以通过未被 schema 规定的属性来扩展 XML 文档。 -->
        <xsd:anyAttribute namespace="##other" processContents="lax"/>
    </xsd:attributeGroup>

    <!--类型为自定义metaType-->
    <xsd:element name="meta" type="metaType">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    Arbitrary metadata attached to a bean definition.
            ]]></xsd:documentation>
        </xsd:annotation>
    </xsd:element>

    <xsd:complexType name="metaType">
        <xsd:attribute name="key" type="xsd:string" use="required">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    The key name of the metadata attribute being defined.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="value" type="xsd:string" use="required">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    The value of the metadata attribute being defined (as a simple String).
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
    </xsd:complexType>

    <!--我们极其熟悉的<bean>-->
    <xsd:element name="bean">
        <!-- 注释-->
        <xsd:annotation>
            <xsd:documentation source="java:org.springframework.beans.factory.config.BeanDefinition"><![CDATA[
    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.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <!-- complexContent: 定义对复杂类型（包含混合内容或仅包含元素）的扩展或限制。 -->
            <xsd:complexContent>
                <!-- 继承自identifiedType -->
                <!-- extension 元素对 simpleType 或 complexType 的元素进行扩展。 -->
                <xsd:extension base="identifiedType">
                    <!--<bean>包含这些xml子节点-->
                    <!-- group 元素用于定义在复杂类型定义中使用的元素组。 -->
                    <!-- ref: 引用另一个组的名称。ref 值必须是 QName。 ref 可以包含命名空间前缀。name 属性和 ref 属性不能同时出现。 -->
                    <xsd:group ref="beanElements"/>
                    <!--<bean>包含这些xml属性, 以ref引用其他位置定义的属性 -->
                    <xsd:attributeGroup ref="beanAttributes"/>
                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="constructor-arg">
        <xsd:annotation>
            <xsd:documentation source="java:org.springframework.beans.factory.config.ConstructorArgumentValues">
                <![CDATA[
    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.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <xsd:sequence>
                <xsd:element ref="description" minOccurs="0"/>
                <!--<constructor-arg>节点下只运行出现如下子节点; 参见下面的图2 -->
                <xsd:choice minOccurs="0" maxOccurs="1">
                    <xsd:element ref="bean"/>
                    <xsd:element ref="ref"/>
                    <xsd:element ref="idref"/>
                    <xsd:element ref="value"/>
                    <xsd:element ref="null"/>
                    <xsd:element ref="array"/>
                    <xsd:element ref="list"/>
                    <xsd:element ref="set"/>
                    <xsd:element ref="map"/>
                    <xsd:element ref="props"/>
                    <xsd:any namespace="##other" processContents="strict"/>
                </xsd:choice>
            </xsd:sequence>
            <!--以下是<constructor-arg>节点的可配置属性, 参见下面的图3 -->
            <xsd:attribute name="index" type="xsd:string">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    The exact index of the argument in the constructor argument list.
    Only needed to avoid ambiguities, e.g. in case of 2 arguments of
    the exact same type.
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
            <xsd:attribute name="type" type="xsd:string">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    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.
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
            <xsd:attribute name="name" type="xsd:string">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    The exact name of the argument in the constructor argument list.
    Only needed to avoid ambiguities, e.g. in case of 2 arguments of
    the exact same type. Note: This requires debug symbols to be
    stored in the class file in order to introspect argument names!
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
            <xsd:attribute name="ref" type="xsd:string">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    A short-cut alternative to a nested "<ref bean='...'/>" element.
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
            <xsd:attribute name="value" type="xsd:string">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    A short-cut alternative to a nested "<value>...<value/>" element.
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="property" type="propertyType">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    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.
            ]]></xsd:documentation>
        </xsd:annotation>
    </xsd:element>

    <xsd:element name="qualifier">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    Bean definitions can provide qualifiers to match against annotations
    on a field or parameter for fine-grained autowire candidate resolution.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <!-- sequence 元素要求组中的元素以指定的顺序出现在包含元素中。每个子元素可出现 0 次到任意次数。 -->
            <xsd:sequence>
                <xsd:element ref="attribute" minOccurs="0" maxOccurs="unbounded"/>
            </xsd:sequence>
            <xsd:attribute name="type" type="xsd:string" default="org.springframework.beans.factory.annotation.Qualifier"/>
            <xsd:attribute name="value" type="xsd:string"/>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="attribute" type="metaType">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    A qualifier element may contain attribute child elements as key-value
    pairs. These will be available for matching against attributes of a
    qualifier annotation on an autowired field or parameter if present.
            ]]></xsd:documentation>
        </xsd:annotation>
    </xsd:element>

    <!--<bean>的子节点<lookup-method/>-->
    <xsd:element name="lookup-method">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    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 is 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.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:restriction base="xsd:anyType">
                    <xsd:attribute name="name" type="xsd:string">
                        <xsd:annotation>
                            <xsd:documentation><![CDATA[
    The name of the lookup method. This method may have arguments which
    will be passed on to the target constructor or factory method. Note
    that for backwards compatibility reasons, in a scenario with overloaded
    non-abstract methods of the given name, only the no-arg variant of a
    method will be turned into a container-driven lookup method.
    Consider using the @Lookup annotation for more specific demarcation.
                            ]]></xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>
                    <xsd:attribute name="bean" type="xsd:string">
                        <xsd:annotation>
                            <xsd:documentation><![CDATA[
    The name of the bean in the current or ancestor factories that
    the lookup method should resolve to. Usually this bean will be a
    prototype, in which case the lookup method will return a distinct
    instance on every invocation. If not specified, the lookup method's
    return type will be used for a type-based lookup.
                            ]]></xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>
                </xsd:restriction>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>

    <!--<bean>的子节点<replaced-method/>-->
    <xsd:element name="replaced-method">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    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.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <xsd:sequence>
                <xsd:choice minOccurs="0" maxOccurs="unbounded">
                    <xsd:element ref="arg-type"/>
                </xsd:choice>
            </xsd:sequence>
            <xsd:attribute name="name" type="xsd:string">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    The name of the method whose implementation must be replaced by the
    IoC container. If this method is not overloaded, there is 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.
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
            <xsd:attribute name="replacer" type="xsd:string">
                <xsd:annotation>
                    <xsd:documentation source="java:org.springframework.beans.factory.support.MethodReplacer"><![CDATA[
    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 is a prototype, a new instance will be used for each
    method replacement. Singleton usage is the norm.
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="arg-type">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    Identifies an argument for a replaced method in the event of
    method overloading.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType mixed="true">
            <xsd:choice minOccurs="0" maxOccurs="unbounded"/>
            <xsd:attribute name="match" type="xsd:string">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    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.
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="ref">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    Defines a reference to another bean in this factory or an external
    factory (parent or included factory).
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:restriction base="xsd:anyType">
                    <xsd:attribute name="bean" type="xsd:string">
                        <xsd:annotation>
                            <xsd:documentation><![CDATA[
    The name of the referenced bean.
                            ]]></xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>
                    <xsd:attribute name="parent" type="xsd:string">
                        <xsd:annotation>
                            <xsd:documentation><![CDATA[
    The name of the referenced bean in a parent factory.
                        ]]></xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>
                </xsd:restriction>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="idref">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    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 indicates that the Spring container
    should check that the value actually corresponds to a bean id.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:restriction base="xsd:anyType">
                    <xsd:attribute name="bean" type="xsd:string">
                        <xsd:annotation>
                            <xsd:documentation><![CDATA[
    The name of the referenced bean.
                            ]]></xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>
                </xsd:restriction>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="value">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    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 arbitrary target objects.

    Note that this is recommended for simple objects only. Configure
    more complex objects by populating JavaBean properties with
    references to other beans.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType mixed="true">
            <xsd:choice minOccurs="0" maxOccurs="unbounded"/>
            <xsd:attribute name="type" type="xsd:string">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    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.
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="null">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    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.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType mixed="true">
            <xsd:choice minOccurs="0" maxOccurs="unbounded"/>
        </xsd:complexType>
    </xsd:element>

    <!-- Collection Elements -->
    <xsd:group name="collectionElements">
        <xsd:sequence>
            <xsd:element ref="description" minOccurs="0"/>
            <xsd:choice minOccurs="0" maxOccurs="unbounded">
                <xsd:element ref="bean"/>
                <xsd:element ref="ref"/>
                <xsd:element ref="idref"/>
                <xsd:element ref="value"/>
                <xsd:element ref="null"/>
                <xsd:element ref="array"/>
                <xsd:element ref="list"/>
                <xsd:element ref="set"/>
                <xsd:element ref="map"/>
                <xsd:element ref="props"/>
                <xsd:any namespace="##other" processContents="strict" minOccurs="0" maxOccurs="unbounded"/>
            </xsd:choice>
        </xsd:sequence>
    </xsd:group>

    <xsd:element name="array">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    An array can contain multiple inner bean, ref, collection, or value elements.
    This configuration element will always result in an array, even when being
    defined e.g. as a value for a map with value type Object.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:extension base="listOrSetType">
                    <xsd:attribute name="merge" default="default" type="defaultable-boolean">
                        <xsd:annotation>
                            <xsd:documentation><![CDATA[
    Enables/disables merging for collections when using parent/child beans.
                            ]]></xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>
                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="list">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    A list can contain multiple inner bean, ref, collection, or value elements.
    A list can also map to an array type; the necessary conversion is performed
    automatically.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:extension base="listOrSetType">
                    <xsd:attribute name="merge" default="default" type="defaultable-boolean">
                        <xsd:annotation>
                            <xsd:documentation><![CDATA[
    Enables/disables merging for collections when using parent/child beans.
                            ]]></xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>
                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="set">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    A set can contain multiple inner bean, ref, collection, or value elements.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:extension base="listOrSetType">
                    <xsd:attribute name="merge" default="default" type="defaultable-boolean">
                        <xsd:annotation>
                            <xsd:documentation><![CDATA[
    Enables/disables merging for collections when using parent/child beans.
                            ]]></xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>
                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="map">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    A mapping from a key to an object. Maps may be empty.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:extension base="mapType">
                    <xsd:attribute name="merge" default="default" type="defaultable-boolean">
                        <xsd:annotation>
                            <xsd:documentation><![CDATA[
    Enables/disables merging for collections when using parent/child beans.
                            ]]></xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>
                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="entry" type="entryType">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    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.
            ]]></xsd:documentation>
        </xsd:annotation>
    </xsd:element>

    <xsd:element name="props">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    Props elements differ from map elements in that values must be strings.
    Props may be empty.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:extension base="propsType">
                    <xsd:attribute name="merge" default="default" type="defaultable-boolean">
                        <xsd:annotation>
                            <xsd:documentation><![CDATA[
    Enables/disables merging for collections when using parent/child beans.
                            ]]></xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>
                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="key">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    A key element can contain an inner bean, ref, value, or collection.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType>
            <xsd:group ref="collectionElements"/>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="prop">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    The string value of the property. Note that whitespace is trimmed
    off to avoid unwanted whitespace caused by typical XML formatting.
            ]]></xsd:documentation>
        </xsd:annotation>
        <xsd:complexType mixed="true">
            <xsd:choice minOccurs="0" maxOccurs="unbounded"/>
            <xsd:attribute name="key" type="xsd:string" use="required">
                <xsd:annotation>
                    <xsd:documentation><![CDATA[
    The key of the property entry.
                    ]]></xsd:documentation>
                </xsd:annotation>
            </xsd:attribute>
        </xsd:complexType>
    </xsd:element>

    <xsd:complexType name="propertyType">
        <xsd:sequence>
            <xsd:element ref="description" minOccurs="0"/>
            <!--参见下面的图4-->
            <xsd:choice minOccurs="0" maxOccurs="1">
                <xsd:element ref="meta"/>
                <xsd:element ref="bean"/>
                <xsd:element ref="ref"/>
                <xsd:element ref="idref"/>
                <xsd:element ref="value"/>
                <xsd:element ref="null"/>
                <xsd:element ref="array"/>
                <xsd:element ref="list"/>
                <xsd:element ref="set"/>
                <xsd:element ref="map"/>
                <xsd:element ref="props"/>
                <xsd:any namespace="##other" processContents="strict"/>
            </xsd:choice>
        </xsd:sequence>
        <xsd:attribute name="name" type="xsd:string" use="required">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    The name of the property, following JavaBean naming conventions.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="ref" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    A short-cut alternative to a nested "<ref bean='...'/>".
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="value" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    A short-cut alternative to a nested "<value>...</value>" element.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
    </xsd:complexType>

    <!-- Collection Types -->

    <!-- base type for collections that have (possibly) typed nested values -->
    <xsd:complexType name="collectionType">
        <xsd:attribute name="value-type" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation source="java:java.lang.Class"><![CDATA[
    The default Java type for nested values. Must be a fully qualified
    class name.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
    </xsd:complexType>

    <!-- 'list' and 'set' collection type -->
    <xsd:complexType name="listOrSetType">
        <xsd:complexContent>
            <xsd:extension base="collectionType">
                <xsd:group ref="collectionElements"/>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <!-- 'map' element type -->
    <xsd:complexType name="mapType">
        <xsd:complexContent>
            <xsd:extension base="collectionType">
                <xsd:sequence>
                    <xsd:element ref="description" minOccurs="0"/>
                    <xsd:choice minOccurs="0" maxOccurs="unbounded">
                        <xsd:element ref="entry"/>
                    </xsd:choice>
                </xsd:sequence>
                <xsd:attribute name="key-type" type="xsd:string">
                    <xsd:annotation>
                        <xsd:documentation source="java:java.lang.Class"><![CDATA[
    The default Java type for nested entry keys. Must be a fully qualified
    class name.
                        ]]></xsd:documentation>
                    </xsd:annotation>
                </xsd:attribute>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <!-- 'entry' element type -->
    <xsd:complexType name="entryType">
        <xsd:sequence>
            <xsd:element ref="key" minOccurs="0"/>
            <xsd:group ref="collectionElements"/>
        </xsd:sequence>
        <xsd:attribute name="key" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    Each map element must specify its key as attribute or as child element.
    A key attribute is always a String value.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="key-ref" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    A short-cut alternative to a to a "key" element with a nested
    "<ref bean='...'/>".
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="value" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    A short-cut alternative to a nested "<value>...</value>"
    element.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="value-ref" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    A short-cut alternative to a nested "<ref bean='...'/>".
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
        <xsd:attribute name="value-type" type="xsd:string">
            <xsd:annotation>
                <xsd:documentation><![CDATA[
    A short-cut alternative to a 'type' attribute on a nested
    "<value type='...' >...</value>" element.
                ]]></xsd:documentation>
            </xsd:annotation>
        </xsd:attribute>
    </xsd:complexType>

    <!-- 'props' collection type -->
    <xsd:complexType name="propsType">
        <xsd:complexContent>
            <xsd:extension base="collectionType">
                <xsd:sequence>
                    <xsd:choice minOccurs="0" maxOccurs="unbounded">
                        <xsd:element ref="prop"/>
                    </xsd:choice>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <!-- simple internal types -->
    <xsd:simpleType name="defaultable-boolean">
        <xsd:restriction base="xsd:NMTOKEN">
            <xsd:enumeration value="default"/>
            <xsd:enumeration value="true"/>
            <xsd:enumeration value="false"/>
        </xsd:restriction>
    </xsd:simpleType>

</xsd:schema>

图1 ：<import/>节点的注释

图2 ：<constructor-arg/>节点的可配置子节点

图3 ：<constructor-arg/>节点的可配置属性

图4 ：<property/>节点下的子节点

3. 导入XSD文件（两种方式）

3.1 引用本地无命名空间的XML模式

就是要设定xsi:noNamespaceSchemaLocation属性，它的值为本地XML模式文档所在的路径（可以是绝对路径，也可以是相对路径）

<service-config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="./com/kanq/qd/core/builder/xml/service-config.xsd">
    ...
</service-config>

3.2 在eclipse添加本地xsd

1. Window -> Preferences -> XML -> XML Catalog-> User Specified Entries窗口中,选择Add 按纽。

2. 在Add XML Catalog Entry 对话框中选择或输入以下内容: (注意这里的 .m2 会导致无法保存， 将 . 去掉即可。)

   

然后就可以使用如下方式了

<service-config xmlns="http://www.zzz.com/schema/zz/service">
    ...
</service-config>

4. 问题

发现在Eclipse中缓存特别严重，成功一次之后，你再做的修改就没法展示了。甚至你取消第三部的操作都可以看到提示。。。。不知道哪位大佬有解决办法？

5. Links

1. xsd文件规则和语法
2. Schema 教程
3. eclipse导入本地xsd文件
4. XML和Schema命名空间详解—实例篇
5. spring-beans-3.2.xsd