Workspace/3dparty_src/spring/schema/spring-beans-2.5.xsd

   1 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
   2
   3 <xsd:schema xmlns="http://www.springframework.org/schema/beans"
   4                 xmlns:xsd="http://www.w3.org/2001/XMLSchema"
   5                 targetNamespace="http://www.springframework.org/schema/beans">
   6
   7         <xsd:import namespace="http://www.w3.org/XML/1998/namespace"/>
   8
   9         <xsd:annotation>
  10                 <xsd:documentation><![CDATA[
  11         Spring XML Beans Schema, version 2.5
  12         Authors: Rob Harrop, Juergen Hoeller, Mark Fisher
  13
  14         This defines a simple and consistent way of creating a namespace
  15         of JavaBeans objects, managed by a Spring BeanFactory, read by
  16         XmlBeanDefinitionReader (with DefaultBeanDefinitionDocumentReader).
  17
  18         This document type is used by most Spring functionality, including
  19         web application contexts, which are based on bean factories.
  20
  21         Each "bean" element in this document defines a JavaBean.
  22         Typically the bean class is specified, along with JavaBean properties
  23         and/or constructor arguments.
  24
  25         A bean instance can be a "singleton" (shared instance) or a "prototype"
  26         (independent instance). Further scopes can be provided by extended
  27         bean factories, for example in a web environment.
  28
  29         References among beans are supported, that is, setting a JavaBean property
  30         or a constructor argument to refer to another bean in the same factory
  31         (or an ancestor factory).
  32
  33         As alternative to bean references, "inner bean definitions" can be used.
  34         Singleton flags of such inner bean definitions are effectively ignored:
  35         inner beans are typically anonymous prototypes.
  36
  37         There is also support for lists, sets, maps, and java.util.Properties
  38         as bean property types or constructor argument types.
  39                 ]]></xsd:documentation>
  40         </xsd:annotation>
  41
  42         <!-- base types -->
  43         <xsd:complexType name="identifiedType" abstract="true">
  44                 <xsd:annotation>
  45                         <xsd:documentation><![CDATA[
  46         The unique identifier for a bean. The scope of the identifier
  47         is the enclosing bean factory.
  48                         ]]></xsd:documentation>
  49                 </xsd:annotation>
  50                 <xsd:attribute name="id" type="xsd:ID">
  51                         <xsd:annotation>
  52                                 <xsd:documentation><![CDATA[
  53         The unique identifier for a bean.
  54                                 ]]></xsd:documentation>
  55                         </xsd:annotation>
  56                 </xsd:attribute>
  57         </xsd:complexType>
  58
  59         <!-- Top-level <beans> tag -->
  60         <xsd:element name="beans">
  61                 <xsd:annotation>
  62                         <xsd:documentation><![CDATA[
  63         The top level (typically root) element. Allows the definition
  64         of default values for all nested bean definitions.
  65                         ]]></xsd:documentation>
  66                 </xsd:annotation>
  67                 <xsd:complexType>
  68                         <xsd:sequence>
  69                                 <xsd:element ref="description" minOccurs="0"/>
  70                                 <xsd:choice minOccurs="0" maxOccurs="unbounded">
  71                                         <xsd:element ref="import"/>
  72                                         <xsd:element ref="alias"/>
  73                                         <xsd:element ref="bean"/>
  74                                         <xsd:any namespace="##other" processContents="strict" minOccurs="0" maxOccurs="unbounded"/>
  75                                 </xsd:choice>
  76                         </xsd:sequence>
  77                         <xsd:attribute name="default-lazy-init" default="false" type="xsd:boolean">
  78                                 <xsd:annotation>
  79                                         <xsd:documentation><![CDATA[
  80         The default 'lazy-init' value; see the documentation for the
  81         'lazy-init' attribute of the '<bean>' element.
  82                                         ]]></xsd:documentation>
  83                                 </xsd:annotation>
  84                         </xsd:attribute>
  85                         <xsd:attribute name="default-merge" default="false" type="xsd:boolean">
  86                                 <xsd:annotation>
  87                                         <xsd:documentation><![CDATA[
  88         The default 'merge' value; see the documentation for the
  89         'merge' attribute of the various collection elements.
  90                                         ]]></xsd:documentation>
  91                                 </xsd:annotation>
  92                         </xsd:attribute>
  93                         <xsd:attribute name="default-autowire" default="no">
  94                                 <xsd:annotation>
  95                                         <xsd:documentation><![CDATA[
  96         The default 'autowire' value; see the documentation for the
  97         'autowire' attribute of the '<bean>' element.
  98                                         ]]></xsd:documentation>
  99                                 </xsd:annotation>
 100                                 <xsd:simpleType>
 101                                         <xsd:restriction base="xsd:NMTOKEN">
 102                                                 <xsd:enumeration value="no"/>
 103                                                 <xsd:enumeration value="byName"/>
 104                                                 <xsd:enumeration value="byType"/>
 105                                                 <xsd:enumeration value="constructor"/>
 106                                                 <xsd:enumeration value="autodetect"/>
 107                                         </xsd:restriction>
 108                                 </xsd:simpleType>
 109                         </xsd:attribute>
 110                         <xsd:attribute name="default-dependency-check" default="none">
 111                                 <xsd:annotation>
 112                                         <xsd:documentation><![CDATA[
 113         The default 'dependency-check' value; see the documentation for the
 114         'dependency-check' attribute of the '<bean>' element.
 115                                         ]]></xsd:documentation>
 116                                 </xsd:annotation>
 117                                 <xsd:simpleType>
 118                                         <xsd:restriction base="xsd:NMTOKEN">
 119                                                 <xsd:enumeration value="none"/>
 120                                                 <xsd:enumeration value="simple"/>
 121                                                 <xsd:enumeration value="objects"/>
 122                                                 <xsd:enumeration value="all"/>
 123                                         </xsd:restriction>
 124                                 </xsd:simpleType>
 125                         </xsd:attribute>
 126                         <xsd:attribute name="default-autowire-candidates" type="xsd:string">
 127                                 <xsd:annotation>
 128                                         <xsd:documentation><![CDATA[
 129         A default bean name pattern for identifying autowire candidates:
 130         e.g. "*Service", "data*", "*Service*", "data*Service".
 131         Also accepts a comma-separated list of patterns: e.g. "*Service,*Dao".
 132         See the documentation for the 'autowire-candidate' attribute of the
 133         '<bean/>' element for the semantic details of autowire candidate beans.
 134                                         ]]></xsd:documentation>
 135                                 </xsd:annotation>
 136                         </xsd:attribute>
 137                         <xsd:attribute name="default-init-method" type="xsd:string">
 138                                 <xsd:annotation>
 139                                         <xsd:documentation><![CDATA[
 140         The default 'init-method' value; see the documentation for the
 141         'init-method' attribute of the '<bean>' element.
 142                                         ]]></xsd:documentation>
 143                                 </xsd:annotation>
 144                         </xsd:attribute>
 145                         <xsd:attribute name="default-destroy-method" type="xsd:string">
 146                                 <xsd:annotation>
 147                                         <xsd:documentation><![CDATA[
 148         The default 'destroy-method' value; see the documentation for the
 149         'destroy-method' attribute of the '<bean>' element.
 150                                         ]]></xsd:documentation>
 151                                 </xsd:annotation>
 152                         </xsd:attribute>
 153                         <xsd:anyAttribute namespace="##other" processContents="lax"/>
 154                 </xsd:complexType>
 155         </xsd:element>
 156
 157         <xsd:element name="description">
 158                 <xsd:annotation>
 159                         <xsd:documentation><![CDATA[
 160         Contains informative text describing the purpose of the enclosing element.
 161         Used primarily for user documentation of XML bean definition documents.
 162                         ]]></xsd:documentation>
 163                 </xsd:annotation>
 164                 <xsd:complexType mixed="true">
 165                         <xsd:choice minOccurs="0" maxOccurs="unbounded"/>
 166                 </xsd:complexType>
 167         </xsd:element>
 168
 169         <xsd:element name="import">
 170                 <xsd:annotation>
 171                         <xsd:documentation source="java:org.springframework.core.io.Resource"><![CDATA[
 172         Specifies an XML bean definition resource to import.
 173                         ]]></xsd:documentation>
 174                 </xsd:annotation>
 175                 <xsd:complexType>
 176                         <xsd:complexContent>
 177                                 <xsd:restriction base="xsd:anyType">
 178                                         <xsd:attribute name="resource" type="xsd:string" use="required">
 179                                                 <xsd:annotation>
 180                                                         <xsd:documentation><![CDATA[
 181         The relative resource location of the XML (bean definition) file to import,
 182         for example "myImport.xml" or "includes/myImport.xml" or "../myImport.xml".
 183                                                         ]]></xsd:documentation>
 184                                                 </xsd:annotation>
 185                                         </xsd:attribute>
 186                                 </xsd:restriction>
 187                         </xsd:complexContent>
 188                 </xsd:complexType>
 189         </xsd:element>
 190
 191         <xsd:element name="alias">
 192                 <xsd:annotation>
 193                         <xsd:documentation><![CDATA[
 194         Defines an alias for a bean (which can reside in a different definition
 195         resource).
 196                         ]]></xsd:documentation>
 197                 </xsd:annotation>
 198                 <xsd:complexType>
 199                         <xsd:complexContent>
 200                                 <xsd:restriction base="xsd:anyType">
 201                                         <xsd:attribute name="name" type="xsd:string" use="required">
 202                                                 <xsd:annotation>
 203                                                         <xsd:documentation><![CDATA[
 204         The name of the bean to define an alias for.
 205                                                         ]]></xsd:documentation>
 206                                                 </xsd:annotation>
 207                                         </xsd:attribute>
 208                                         <xsd:attribute name="alias" type="xsd:string" use="required">
 209                                                 <xsd:annotation>
 210                                                         <xsd:documentation><![CDATA[
 211         The alias name to define for the bean.
 212                                                         ]]></xsd:documentation>
 213                                                 </xsd:annotation>
 214                                         </xsd:attribute>
 215                                 </xsd:restriction>
 216                         </xsd:complexContent>
 217                 </xsd:complexType>
 218         </xsd:element>
 219
 220         <xsd:group name="beanElements">
 221                 <xsd:sequence>
 222                         <xsd:element ref="description" minOccurs="0"/>
 223                         <xsd:choice minOccurs="0" maxOccurs="unbounded">
 224                                 <xsd:element ref="meta"/>
 225                                 <xsd:element ref="constructor-arg"/>
 226                                 <xsd:element ref="property"/>
 227                                 <xsd:element ref="qualifier"/>
 228                                 <xsd:element ref="lookup-method"/>
 229                                 <xsd:element ref="replaced-method"/>
 230                                 <xsd:any namespace="##other" processContents="strict" minOccurs="0" maxOccurs="unbounded"/>
 231                         </xsd:choice>
 232                 </xsd:sequence>
 233         </xsd:group>
 234
 235         <xsd:attributeGroup name="beanAttributes">
 236                 <xsd:attribute name="name" type="xsd:string">
 237                         <xsd:annotation>
 238                                 <xsd:documentation><![CDATA[
 239         Can be used to create one or more aliases illegal in an (XML) id.
 240         Multiple aliases can be separated by any number of spaces, commas,
 241         or semi-colons (or indeed any mixture of the three).
 242                                 ]]></xsd:documentation>
 243                         </xsd:annotation>
 244                 </xsd:attribute>
 245                 <xsd:attribute name="class" type="xsd:string">
 246                         <xsd:annotation>
 247                                 <xsd:documentation source="java:java.lang.Class"><![CDATA[
 248         The fully qualified name of the bean's class, except if it serves only
 249         as a parent definition for child bean definitions.
 250                                 ]]></xsd:documentation>
 251                         </xsd:annotation>
 252                 </xsd:attribute>
 253                 <xsd:attribute name="parent" type="xsd:string">
 254                         <xsd:annotation>
 255                                 <xsd:documentation><![CDATA[
 256         The name of the parent bean definition.
 257
 258         Will use the bean class of the parent if none is specified, but can
 259         also override it. In the latter case, the child bean class must be
 260         compatible with the parent, i.e. accept the parent's property values
 261         and constructor argument values, if any.
 262
 263         A child bean definition will inherit constructor argument values,
 264         property values and method overrides from the parent, with the option
 265         to add new values. If init method, destroy method, factory bean and/or
 266         factory method are specified, they will override the corresponding
 267         parent settings.
 268
 269         The remaining settings will always be taken from the child definition:
 270         depends on, autowire mode, dependency check, scope, lazy init.
 271                                 ]]></xsd:documentation>
 272                         </xsd:annotation>
 273                 </xsd:attribute>
 274                 <xsd:attribute name="scope" type="xsd:string">
 275                         <xsd:annotation>
 276                                 <xsd:documentation><![CDATA[
 277         The scope of this bean: typically "singleton" (one shared instance,
 278         which will be returned by all calls to getBean with the given id), or
 279         "prototype" (independent instance resulting from each call to getBean).
 280         Default is "singleton".
 281
 282         Singletons are most commonly used, and are ideal for multi-threaded
 283         service objects. Further scopes, such as "request" or "session", might
 284         be supported by extended bean factories (e.g. in a web environment).
 285
 286         Note: This attribute will not be inherited by child bean definitions.
 287         Hence, it needs to be specified per concrete bean definition.
 288
 289         Inner bean definitions inherit the singleton status of their containing
 290         bean definition, unless explicitly specified: The inner bean will be a
 291         singleton if the containing bean is a singleton, and a prototype if
 292         the containing bean has any other scope.
 293                                 ]]></xsd:documentation>
 294                         </xsd:annotation>
 295                 </xsd:attribute>
 296                 <xsd:attribute name="abstract" type="xsd:boolean">
 297                         <xsd:annotation>
 298                                 <xsd:documentation><![CDATA[
 299         Is this bean "abstract", that is, not meant to be instantiated itself
 300         but rather just serving as parent for concrete child bean definitions?
 301         The default is "false". Specify "true" to tell the bean factory to not
 302         try to instantiate that particular bean in any case.
 303
 304         Note: This attribute will not be inherited by child bean definitions.
 305         Hence, it needs to be specified per abstract bean definition.
 306                                 ]]></xsd:documentation>
 307                         </xsd:annotation>
 308                 </xsd:attribute>
 309                 <xsd:attribute name="lazy-init" default="default" type="defaultable-boolean">
 310                         <xsd:annotation>
 311                                 <xsd:documentation><![CDATA[
 312         Indicates whether or not this bean is to be lazily initialized.
 313         If false, it will be instantiated on startup by bean factories
 314         that perform eager initialization of singletons. The default is
 315         "false".
 316
 317         Note: This attribute will not be inherited by child bean definitions.
 318         Hence, it needs to be specified per concrete bean definition.
 319                                 ]]></xsd:documentation>
 320                         </xsd:annotation>
 321                 </xsd:attribute>
 322                 <xsd:attribute name="autowire" default="default">
 323                         <xsd:annotation>
 324                                 <xsd:documentation><![CDATA[
 325         Controls whether bean properties are "autowired".
 326         This is an automagical process in which bean references don't need
 327         to be coded explicitly in the XML bean definition file, but rather the
 328         Spring container works out dependencies.
 329
 330         There are 5 modes:
 331
 332         1. "no"
 333         The traditional Spring default. No automagical wiring. Bean references
 334         must be defined in the XML file via the <ref/> element (or "ref"
 335         attribute). We recommend this in most cases as it makes documentation
 336         more explicit.
 337
 338         2. "byName"
 339         Autowiring by property name. If a bean of class Cat exposes a "dog"
 340         property, Spring will try to set this to the value of the bean "dog"
 341         in the current container. If there is no matching bean by name, nothing
 342         special happens; use dependency-check="objects" to raise an error in
 343         that case.
 344
 345         3. "byType"
 346         Autowiring if there is exactly one bean of the property type in the
 347         container. If there is more than one, a fatal error is raised, and
 348         you cannot use byType autowiring for that bean. If there is none,
 349         nothing special happens; use dependency-check="objects" to raise an
 350         error in that case.
 351
 352         4. "constructor"
 353         Analogous to "byType" for constructor arguments. If there is not exactly
 354         one bean of the constructor argument type in the bean factory, a fatal
 355         error is raised.
 356
 357         5. "autodetect"
 358         Chooses "constructor" or "byType" through introspection of the bean
 359         class. If a default constructor is found, "byType" gets applied.
 360
 361         Note that explicit dependencies, i.e. "property" and "constructor-arg"
 362         elements, always override autowiring. Autowire behavior can be combined
 363         with dependency checking, which will be performed after all autowiring
 364         has been completed.
 365
 366         Note: This attribute will not be inherited by child bean definitions.
 367         Hence, it needs to be specified per concrete bean definition.
 368                                 ]]></xsd:documentation>
 369                         </xsd:annotation>
 370                         <xsd:simpleType>
 371                                 <xsd:restriction base="xsd:NMTOKEN">
 372                                         <xsd:enumeration value="default"/>
 373                                         <xsd:enumeration value="no"/>
 374                                         <xsd:enumeration value="byName"/>
 375                                         <xsd:enumeration value="byType"/>
 376                                         <xsd:enumeration value="constructor"/>
 377                                         <xsd:enumeration value="autodetect"/>
 378                                 </xsd:restriction>
 379                         </xsd:simpleType>
 380                 </xsd:attribute>
 381                 <xsd:attribute name="dependency-check" default="default">
 382                         <xsd:annotation>
 383                                 <xsd:documentation><![CDATA[
 384         Controls whether or not to check whether all of this
 385         bean's dependencies, expressed in its properties, are satisfied.
 386         The default is to perform no dependency checking.
 387
 388         "simple" type dependency checking includes primitives and String;
 389         "objects" includes collaborators (other beans in the factory);
 390         "all" includes both types of dependency checking.
 391
 392         Note: This attribute will not be inherited by child bean definitions.
 393         Hence, it needs to be specified per concrete bean definition.
 394                                 ]]></xsd:documentation>
 395                         </xsd:annotation>
 396                         <xsd:simpleType>
 397                                 <xsd:restriction base="xsd:NMTOKEN">
 398                                         <xsd:enumeration value="default"/>
 399                                         <xsd:enumeration value="none"/>
 400                                         <xsd:enumeration value="simple"/>
 401                                         <xsd:enumeration value="objects"/>
 402                                         <xsd:enumeration value="all"/>
 403                                 </xsd:restriction>
 404                         </xsd:simpleType>
 405                 </xsd:attribute>
 406                 <xsd:attribute name="depends-on" type="xsd:string">
 407                         <xsd:annotation>
 408                                 <xsd:documentation><![CDATA[
 409         The names of the beans that this bean depends on being initialized.
 410         The bean factory will guarantee that these beans get initialized
 411         before this bean.
 412
 413         Note that dependencies are normally expressed through bean properties
 414         or constructor arguments. This property should just be necessary for
 415         other kinds of dependencies like statics (*ugh*) or database preparation
 416         on startup.
 417
 418         Note: This attribute will not be inherited by child bean definitions.
 419         Hence, it needs to be specified per concrete bean definition.
 420                                 ]]></xsd:documentation>
 421                         </xsd:annotation>
 422                 </xsd:attribute>
 423                 <xsd:attribute name="autowire-candidate" default="default" type="defaultable-boolean">
 424                         <xsd:annotation>
 425                                 <xsd:documentation><![CDATA[
 426         Indicates whether or not this bean should be considered when looking
 427         for matching candidates to satisfy another bean's autowiring requirements.
 428         Note that this does not affect explicit references by name, which will get
 429         resolved even if the specified bean is not marked as an autowire candidate.
 430                                 ]]></xsd:documentation>
 431                         </xsd:annotation>
 432                 </xsd:attribute>
 433                 <xsd:attribute name="primary" type="xsd:boolean">
 434                         <xsd:annotation>
 435                                 <xsd:documentation><![CDATA[
 436         Specifies that this bean should be given preference when multiple
 437         candidates are qualified to autowire a single-valued dependency.
 438         If exactly one 'primary' bean exists among the candidates, it
 439         will be the autowired value.
 440                                 ]]></xsd:documentation>
 441                         </xsd:annotation>
 442                 </xsd:attribute>
 443                 <xsd:attribute name="init-method" type="xsd:string">
 444                         <xsd:annotation>
 445                                 <xsd:documentation><![CDATA[
 446         The name of the custom initialization method to invoke after setting
 447         bean properties. The method must have no arguments, but may throw any
 448         exception.
 449                                 ]]></xsd:documentation>
 450                         </xsd:annotation>
 451                 </xsd:attribute>
 452                 <xsd:attribute name="destroy-method" type="xsd:string">
 453                         <xsd:annotation>
 454                                 <xsd:documentation><![CDATA[
 455         The name of the custom destroy method to invoke on bean factory
 456         shutdown. The method must have no arguments, but may throw any
 457         exception.
 458
 459         Note: Only invoked on beans whose lifecycle is under the full
 460         control of the factory - which is always the case for singletons,
 461         but not guaranteed for any other scope.
 462                                 ]]></xsd:documentation>
 463                         </xsd:annotation>
 464                 </xsd:attribute>
 465                 <xsd:attribute name="factory-method" type="xsd:string">
 466                         <xsd:annotation>
 467                                 <xsd:documentation><![CDATA[
 468         The name of a factory method to use to create this object. Use
 469         constructor-arg elements to specify arguments to the factory method,
 470         if it takes arguments. Autowiring does not apply to factory methods.
 471
 472         If the "class" attribute is present, the factory method will be a static
 473         method on the class specified by the "class" attribute on this bean
 474         definition. Often this will be the same class as that of the constructed
 475         object - for example, when the factory method is used as an alternative
 476         to a constructor. However, it may be on a different class. In that case,
 477         the created object will *not* be of the class specified in the "class"
 478         attribute. This is analogous to FactoryBean behavior.
 479
 480         If the "factory-bean" attribute is present, the "class" attribute is not
 481         used, and the factory method will be an instance method on the object
 482         returned from a getBean call with the specified bean name. The factory
 483         bean may be defined as a singleton or a prototype.
 484
 485         The factory method can have any number of arguments. Autowiring is not
 486         supported. Use indexed constructor-arg elements in conjunction with the
 487         factory-method attribute.
 488
 489         Setter Injection can be used in conjunction with a factory method.
 490         Method Injection cannot, as the factory method returns an instance,
 491         which will be used when the container creates the bean.
 492                                 ]]></xsd:documentation>
 493                         </xsd:annotation>
 494                 </xsd:attribute>
 495                 <xsd:attribute name="factory-bean" type="xsd:string">
 496                         <xsd:annotation>
 497                                 <xsd:documentation><![CDATA[
 498         Alternative to class attribute for factory-method usage.
 499         If this is specified, no class attribute should be used.
 500         This must be set to the name of a bean in the current or
 501         ancestor factories that contains the relevant factory method.
 502         This allows the factory itself to be configured using Dependency
 503         Injection, and an instance (rather than static) method to be used.
 504                                 ]]></xsd:documentation>
 505                         </xsd:annotation>
 506                 </xsd:attribute>
 507                 <xsd:anyAttribute namespace="##other" processContents="lax"/>
 508         </xsd:attributeGroup>
 509
 510         <xsd:element name="meta" type="metaType">
 511                 <xsd:annotation>
 512                         <xsd:documentation><![CDATA[
 513         Arbitrary metadata attached to a bean definition.
 514                         ]]></xsd:documentation>
 515                 </xsd:annotation>
 516         </xsd:element>
 517
 518         <xsd:complexType name="metaType">
 519                 <xsd:attribute name="key" type="xsd:string" use="required">
 520                         <xsd:annotation>
 521                                 <xsd:documentation><![CDATA[
 522         The key name of the metadata attribute being defined.
 523                                 ]]></xsd:documentation>
 524                         </xsd:annotation>
 525                 </xsd:attribute>
 526                 <xsd:attribute name="value" type="xsd:string" use="required">
 527                         <xsd:annotation>
 528                                 <xsd:documentation><![CDATA[
 529         The value of the metadata attribute being defined (as a simple String).
 530                                 ]]></xsd:documentation>
 531                         </xsd:annotation>
 532                 </xsd:attribute>
 533         </xsd:complexType>
 534
 535         <xsd:element name="bean">
 536                 <xsd:annotation>
 537                         <xsd:documentation source="java:org.springframework.beans.factory.config.BeanDefinition"><![CDATA[
 538         Defines a single (usually named) bean.
 539
 540         A bean definition may contain nested tags for constructor arguments,
 541         property values, lookup methods, and replaced methods. Mixing constructor
 542         injection and setter injection on the same bean is explicitly supported.
 543                         ]]></xsd:documentation>
 544                 </xsd:annotation>
 545                 <xsd:complexType>
 546                         <xsd:complexContent>
 547                                 <xsd:extension base="identifiedType">
 548                                         <xsd:group ref="beanElements"/>
 549                                         <xsd:attributeGroup ref="beanAttributes"/>
 550                                 </xsd:extension>
 551                         </xsd:complexContent>
 552                 </xsd:complexType>
 553         </xsd:element>
 554
 555         <xsd:element name="constructor-arg">
 556                 <xsd:annotation>
 557                         <xsd:documentation source="java:org.springframework.beans.factory.config.ConstructorArgumentValues">
 558                                 <![CDATA[
 559         Bean definitions can specify zero or more constructor arguments.
 560         This is an alternative to "autowire constructor".
 561         Arguments correspond to either a specific index of the constructor
 562         argument list or are supposed to be matched generically by type.
 563
 564         Note: A single generic argument value will just be used once, rather
 565         than potentially matched multiple times (as of Spring 1.1).
 566
 567         constructor-arg elements are also used in conjunction with the
 568         factory-method element to construct beans using static or instance
 569         factory methods.
 570                         ]]></xsd:documentation>
 571                 </xsd:annotation>
 572                 <xsd:complexType>
 573                         <xsd:sequence>
 574                                 <xsd:element ref="description" minOccurs="0"/>
 575                                 <xsd:choice minOccurs="0" maxOccurs="1">
 576                                         <xsd:element ref="bean"/>
 577                                         <xsd:element ref="ref"/>
 578                                         <xsd:element ref="idref"/>
 579                                         <xsd:element ref="value"/>
 580                                         <xsd:element ref="null"/>
 581                                         <xsd:element ref="list"/>
 582                                         <xsd:element ref="set"/>
 583                                         <xsd:element ref="map"/>
 584                                         <xsd:element ref="props"/>
 585                                         <xsd:any namespace="##other" processContents="strict"/>
 586                                 </xsd:choice>
 587                         </xsd:sequence>
 588                         <xsd:attribute name="index" type="xsd:string">
 589                                 <xsd:annotation>
 590                                         <xsd:documentation><![CDATA[
 591         The exact index of the argument in the constructor argument list.
 592         Only needed to avoid ambiguities, e.g. in case of 2 arguments of
 593         the exact same type.
 594                                         ]]></xsd:documentation>
 595                                 </xsd:annotation>
 596                         </xsd:attribute>
 597                         <xsd:attribute name="type" type="xsd:string">
 598                                 <xsd:annotation>
 599                                         <xsd:documentation><![CDATA[
 600         The exact type of the constructor argument. Only needed to avoid
 601         ambiguities, e.g. in case of 2 single argument constructors
 602         that can both be converted from a String.
 603                                         ]]></xsd:documentation>
 604                                 </xsd:annotation>
 605                         </xsd:attribute>
 606                         <xsd:attribute name="ref" type="xsd:string">
 607                                 <xsd:annotation>
 608                                         <xsd:documentation><![CDATA[
 609         A short-cut alternative to a nested "<ref bean='...'/>" element.
 610                                         ]]></xsd:documentation>
 611                                 </xsd:annotation>
 612                         </xsd:attribute>
 613                         <xsd:attribute name="value" type="xsd:string">
 614                                 <xsd:annotation>
 615                                         <xsd:documentation><![CDATA[
 616         A short-cut alternative to a nested "<value>...<value/>" element.
 617                                         ]]></xsd:documentation>
 618                                 </xsd:annotation>
 619                         </xsd:attribute>
 620                 </xsd:complexType>
 621         </xsd:element>
 622
 623         <xsd:element name="property" type="propertyType">
 624                 <xsd:annotation>
 625                         <xsd:documentation><![CDATA[
 626         Bean definitions can have zero or more properties.
 627         Property elements correspond to JavaBean setter methods exposed
 628         by the bean classes. Spring supports primitives, references to other
 629         beans in the same or related factories, lists, maps and properties.
 630                         ]]></xsd:documentation>
 631                 </xsd:annotation>
 632         </xsd:element>
 633
 634         <xsd:element name="qualifier">
 635                 <xsd:annotation>
 636                         <xsd:documentation><![CDATA[
 637         Bean definitions can provide qualifiers to match against annotations
 638         on a field or parameter for fine-grained autowire candidate resolution.
 639                         ]]></xsd:documentation>
 640                 </xsd:annotation>
 641                 <xsd:complexType>
 642                         <xsd:sequence>
 643                                 <xsd:element ref="attribute" minOccurs="0" maxOccurs="unbounded"/>
 644                         </xsd:sequence>
 645                         <xsd:attribute name="type" type="xsd:string" default="org.springframework.beans.factory.annotation.Qualifier"/>
 646                         <xsd:attribute name="value" type="xsd:string"/>
 647                 </xsd:complexType>
 648         </xsd:element>
 649
 650         <xsd:element name="attribute" type="metaType">
 651                 <xsd:annotation>
 652                         <xsd:documentation><![CDATA[
 653         A qualifier element may contain attribute child elements as key-value
 654         pairs. These will be available for matching against attributes of a
 655         qualifier annotation on an autowired field or parameter if present.
 656                         ]]></xsd:documentation>
 657                 </xsd:annotation>
 658         </xsd:element>
 659
 660         <xsd:element name="lookup-method">
 661                 <xsd:annotation>
 662                         <xsd:documentation><![CDATA[
 663         A lookup method causes the IoC container to override the given method
 664         and return the bean with the name given in the bean attribute. This is
 665         a form of Method Injection. It is particularly useful as an alternative
 666         to implementing the BeanFactoryAware interface, in order to be able to
 667         make getBean() calls for non-singleton instances at runtime. In this
 668         case, Method Injection is a less invasive alternative.
 669                         ]]></xsd:documentation>
 670                 </xsd:annotation>
 671                 <xsd:complexType>
 672                         <xsd:complexContent>
 673                                 <xsd:restriction base="xsd:anyType">
 674                                         <xsd:attribute name="name" type="xsd:string">
 675                                                 <xsd:annotation>
 676                                                         <xsd:documentation><![CDATA[
 677         The name of the lookup method. This method must take no arguments.
 678                                                         ]]></xsd:documentation>
 679                                                 </xsd:annotation>
 680                                         </xsd:attribute>
 681                                         <xsd:attribute name="bean" type="xsd:string">
 682                                                 <xsd:annotation>
 683                                                         <xsd:documentation><![CDATA[
 684         The name of the bean in the current or ancestor factories that
 685         the lookup method should resolve to. Often this bean will be a
 686         prototype, in which case the lookup method will return a distinct
 687         instance on every invocation. This is useful for single-threaded objects.
 688                                                         ]]></xsd:documentation>
 689                                                 </xsd:annotation>
 690                                         </xsd:attribute>
 691                                 </xsd:restriction>
 692                         </xsd:complexContent>
 693                 </xsd:complexType>
 694         </xsd:element>
 695
 696         <xsd:element name="replaced-method">
 697                 <xsd:annotation>
 698                         <xsd:documentation><![CDATA[
 699         Similar to the lookup method mechanism, the replaced-method element
 700         is used to control IoC container method overriding: Method Injection.
 701         This mechanism allows the overriding of a method with arbitrary code.
 702                         ]]></xsd:documentation>
 703                 </xsd:annotation>
 704                 <xsd:complexType>
 705                         <xsd:sequence>
 706                                 <xsd:choice minOccurs="0" maxOccurs="unbounded">
 707                                         <xsd:element ref="arg-type"/>
 708                                 </xsd:choice>
 709                         </xsd:sequence>
 710                         <xsd:attribute name="name" type="xsd:string">
 711                                 <xsd:annotation>
 712                                         <xsd:documentation><![CDATA[
 713         The name of the method whose implementation must be replaced by the
 714         IoC container. If this method is not overloaded, there is no need
 715         to use arg-type subelements. If this method is overloaded, arg-type
 716         subelements must be used for all override definitions for the method.
 717                                         ]]></xsd:documentation>
 718                                 </xsd:annotation>
 719                         </xsd:attribute>
 720                         <xsd:attribute name="replacer" type="xsd:string">
 721                                 <xsd:annotation>
 722                                         <xsd:documentation source="java:org.springframework.beans.factory.support.MethodReplacer"><![CDATA[
 723         Bean name of an implementation of the MethodReplacer interface in the
 724         current or ancestor factories. This may be a singleton or prototype
 725         bean. If it is a prototype, a new instance will be used for each
 726         method replacement. Singleton usage is the norm.
 727                                         ]]></xsd:documentation>
 728                                 </xsd:annotation>
 729                         </xsd:attribute>
 730                 </xsd:complexType>
 731         </xsd:element>
 732
 733         <xsd:element name="arg-type">
 734                 <xsd:annotation>
 735                         <xsd:documentation><![CDATA[
 736         Identifies an argument for a replaced method in the event of
 737         method overloading.
 738                         ]]></xsd:documentation>
 739                 </xsd:annotation>
 740                 <xsd:complexType mixed="true">
 741                         <xsd:choice minOccurs="0" maxOccurs="unbounded"/>
 742                         <xsd:attribute name="match" type="xsd:string">
 743                                 <xsd:annotation>
 744                                         <xsd:documentation><![CDATA[
 745         Specification of the type of an overloaded method argument as a String.
 746         For convenience, this may be a substring of the FQN. E.g. all the
 747         following would match "java.lang.String":
 748         - java.lang.String
 749         - String
 750         - Str
 751
 752         As the number of arguments will be checked also, this convenience
 753         can often be used to save typing.
 754                                         ]]></xsd:documentation>
 755                                 </xsd:annotation>
 756                         </xsd:attribute>
 757                 </xsd:complexType>
 758         </xsd:element>
 759
 760         <xsd:element name="ref">
 761                 <xsd:annotation>
 762                         <xsd:documentation><![CDATA[
 763         Defines a reference to another bean in this factory or an external
 764         factory (parent or included factory).
 765                         ]]></xsd:documentation>
 766                 </xsd:annotation>
 767                 <xsd:complexType>
 768                         <xsd:complexContent>
 769                                 <xsd:restriction base="xsd:anyType">
 770                                         <xsd:attribute name="bean" type="xsd:string">
 771                                                 <xsd:annotation>
 772                                                         <xsd:documentation><![CDATA[
 773         The name of the referenced bean.
 774                                                         ]]></xsd:documentation>
 775                                                 </xsd:annotation>
 776                                         </xsd:attribute>
 777                                         <xsd:attribute name="local" type="xsd:IDREF">
 778                                                 <xsd:annotation>
 779                                                         <xsd:documentation><![CDATA[
 780         The name of the referenced bean. The value must be a bean ID and thus can
 781         be checked by the XML parser. This is therefore the preferred technique
 782         for referencing beans within the same bean factory XML file.
 783                                                         ]]></xsd:documentation>
 784                                                 </xsd:annotation>
 785                                         </xsd:attribute>
 786                                         <xsd:attribute name="parent" type="xsd:string">
 787                                                 <xsd:annotation>
 788                                                         <xsd:documentation><![CDATA[
 789         The name of the referenced bean in a parent factory.
 790                                                 ]]></xsd:documentation>
 791                                                 </xsd:annotation>
 792                                         </xsd:attribute>
 793                                 </xsd:restriction>
 794                         </xsd:complexContent>
 795                 </xsd:complexType>
 796         </xsd:element>
 797
 798         <xsd:element name="idref">
 799                 <xsd:annotation>
 800                         <xsd:documentation><![CDATA[
 801         The id of another bean in this factory or an external factory
 802         (parent or included factory).
 803         While a regular 'value' element could instead be used for the
 804         same effect, using idref in this case allows validation of local
 805         bean ids by the XML parser, and name completion by supporting tools.
 806                         ]]></xsd:documentation>
 807                 </xsd:annotation>
 808                 <xsd:complexType>
 809                         <xsd:complexContent>
 810                                 <xsd:restriction base="xsd:anyType">
 811                                         <xsd:attribute name="bean" type="xsd:string">
 812                                                 <xsd:annotation>
 813                                                         <xsd:documentation><![CDATA[
 814         The name of the referenced bean.
 815                                                         ]]></xsd:documentation>
 816                                                 </xsd:annotation>
 817                                         </xsd:attribute>
 818                                         <xsd:attribute name="local" type="xsd:IDREF">
 819                                                 <xsd:annotation>
 820                                                         <xsd:documentation><![CDATA[
 821         The name of the referenced bean. The value must be a bean ID and thus can
 822         be checked by the XML parser. This is therefore the preferred technique
 823         for referencing beans within the same bean factory XML file.
 824                                                         ]]></xsd:documentation>
 825                                                 </xsd:annotation>
 826                                         </xsd:attribute>
 827                                 </xsd:restriction>
 828                         </xsd:complexContent>
 829                 </xsd:complexType>
 830         </xsd:element>
 831
 832         <xsd:element name="value">
 833                 <xsd:annotation>
 834                         <xsd:documentation><![CDATA[
 835         Contains a string representation of a property value.
 836         The property may be a string, or may be converted to the required
 837         type using the JavaBeans PropertyEditor machinery. This makes it
 838         possible for application developers to write custom PropertyEditor
 839         implementations that can convert strings to arbitrary target objects.
 840
 841         Note that this is recommended for simple objects only. Configure
 842         more complex objects by populating JavaBean properties with
 843         references to other beans.
 844                         ]]></xsd:documentation>
 845                 </xsd:annotation>
 846                 <xsd:complexType mixed="true">
 847                         <xsd:choice minOccurs="0" maxOccurs="unbounded"/>
 848                         <xsd:attribute name="type" type="xsd:string">
 849                                 <xsd:annotation>
 850                                         <xsd:documentation><![CDATA[
 851         The exact type that the value should be converted to. Only needed
 852         if the type of the target property or constructor argument is
 853         too generic: for example, in case of a collection element.
 854                                         ]]></xsd:documentation>
 855                                 </xsd:annotation>
 856                         </xsd:attribute>
 857                 </xsd:complexType>
 858         </xsd:element>
 859
 860         <xsd:element name="null">
 861                 <xsd:annotation>
 862                         <xsd:documentation><![CDATA[
 863         Denotes a Java null value. Necessary because an empty "value" tag
 864         will resolve to an empty String, which will not be resolved to a
 865         null value unless a special PropertyEditor does so.
 866                         ]]></xsd:documentation>
 867                 </xsd:annotation>
 868                 <xsd:complexType mixed="true">
 869                         <xsd:choice minOccurs="0" maxOccurs="unbounded"/>
 870                 </xsd:complexType>
 871         </xsd:element>
 872
 873         <!-- Collection Elements -->
 874         <xsd:group name="collectionElements">
 875                 <xsd:sequence>
 876                         <xsd:element ref="description" minOccurs="0"/>
 877                         <xsd:choice minOccurs="0" maxOccurs="unbounded">
 878                                 <xsd:element ref="bean"/>
 879                                 <xsd:element ref="ref"/>
 880                                 <xsd:element ref="idref"/>
 881                                 <xsd:element ref="value"/>
 882                                 <xsd:element ref="null"/>
 883                                 <xsd:element ref="list"/>
 884                                 <xsd:element ref="set"/>
 885                                 <xsd:element ref="map"/>
 886                                 <xsd:element ref="props"/>
 887                                 <xsd:any namespace="##other" processContents="strict" minOccurs="0" maxOccurs="unbounded"/>
 888                         </xsd:choice>
 889                 </xsd:sequence>
 890         </xsd:group>
 891
 892         <xsd:element name="list">
 893                 <xsd:annotation>
 894                         <xsd:documentation><![CDATA[
 895         A list can contain multiple inner bean, ref, collection, or value elements.
 896         A list can also map to an array type; the necessary conversion is performed
 897         automatically.
 898                         ]]></xsd:documentation>
 899                 </xsd:annotation>
 900                 <xsd:complexType>
 901                         <xsd:complexContent>
 902                                 <xsd:extension base="listOrSetType">
 903                                         <xsd:attribute name="merge" type="defaultable-boolean">
 904                                                 <xsd:annotation>
 905                                                         <xsd:documentation><![CDATA[
 906         Enables/disables merging for collections when using parent/child beans.
 907                                                         ]]></xsd:documentation>
 908                                                 </xsd:annotation>
 909                                         </xsd:attribute>
 910                                 </xsd:extension>
 911                         </xsd:complexContent>
 912                 </xsd:complexType>
 913         </xsd:element>
 914
 915         <xsd:element name="set">
 916                 <xsd:annotation>
 917                         <xsd:documentation><![CDATA[
 918         A set can contain multiple inner bean, ref, collection, or value elements.
 919                         ]]></xsd:documentation>
 920                 </xsd:annotation>
 921                 <xsd:complexType>
 922                         <xsd:complexContent>
 923                                 <xsd:extension base="listOrSetType">
 924                                         <xsd:attribute name="merge" type="defaultable-boolean">
 925                                                 <xsd:annotation>
 926                                                         <xsd:documentation><![CDATA[
 927         Enables/disables merging for collections when using parent/child beans.
 928                                                         ]]></xsd:documentation>
 929                                                 </xsd:annotation>
 930                                         </xsd:attribute>
 931                                 </xsd:extension>
 932                         </xsd:complexContent>
 933                 </xsd:complexType>
 934         </xsd:element>
 935
 936         <xsd:element name="map">
 937                 <xsd:annotation>
 938                         <xsd:documentation><![CDATA[
 939         A mapping from a key to an object. Maps may be empty.
 940                         ]]></xsd:documentation>
 941                 </xsd:annotation>
 942                 <xsd:complexType>
 943                         <xsd:complexContent>
 944                                 <xsd:extension base="mapType">
 945                                         <xsd:attribute name="merge" type="defaultable-boolean">
 946                                                 <xsd:annotation>
 947                                                         <xsd:documentation><![CDATA[
 948         Enables/disables merging for collections when using parent/child beans.
 949                                                         ]]></xsd:documentation>
 950                                                 </xsd:annotation>
 951                                         </xsd:attribute>
 952                                 </xsd:extension>
 953                         </xsd:complexContent>
 954                 </xsd:complexType>
 955         </xsd:element>
 956
 957         <xsd:element name="entry" type="entryType">
 958                 <xsd:annotation>
 959                         <xsd:documentation><![CDATA[
 960         A map entry can be an inner bean, ref, value, or collection.
 961         The key of the entry is given by the "key" attribute or child element.
 962                         ]]></xsd:documentation>
 963                 </xsd:annotation>
 964         </xsd:element>
 965
 966         <xsd:element name="props">
 967                 <xsd:annotation>
 968                         <xsd:documentation><![CDATA[
 969         Props elements differ from map elements in that values must be strings.
 970         Props may be empty.
 971                         ]]></xsd:documentation>
 972                 </xsd:annotation>
 973                 <xsd:complexType>
 974                         <xsd:complexContent>
 975                                 <xsd:extension base="propsType">
 976                                         <xsd:attribute name="merge" type="defaultable-boolean">
 977                                                 <xsd:annotation>
 978                                                         <xsd:documentation><![CDATA[
 979         Enables/disables merging for collections when using parent/child beans.
 980                                                         ]]></xsd:documentation>
 981                                                 </xsd:annotation>
 982                                         </xsd:attribute>
 983                                 </xsd:extension>
 984                         </xsd:complexContent>
 985                 </xsd:complexType>
 986         </xsd:element>
 987
 988         <xsd:element name="key">
 989                 <xsd:annotation>
 990                         <xsd:documentation><![CDATA[
 991         A key element can contain an inner bean, ref, value, or collection.
 992                         ]]></xsd:documentation>
 993                 </xsd:annotation>
 994                 <xsd:complexType>
 995                         <xsd:group ref="collectionElements"/>
 996                 </xsd:complexType>
 997         </xsd:element>
 998
 999         <xsd:element name="prop">
1000                 <xsd:annotation>
1001                         <xsd:documentation><![CDATA[
1002         The string value of the property. Note that whitespace is trimmed
1003         off to avoid unwanted whitespace caused by typical XML formatting.
1004                         ]]></xsd:documentation>
1005                 </xsd:annotation>
1006                 <xsd:complexType mixed="true">
1007                         <xsd:choice minOccurs="0" maxOccurs="unbounded"/>
1008                         <xsd:attribute name="key" type="xsd:string" use="required">
1009                                 <xsd:annotation>
1010                                         <xsd:documentation><![CDATA[
1011         The key of the property entry.
1012                                         ]]></xsd:documentation>
1013                                 </xsd:annotation>
1014                         </xsd:attribute>
1015                 </xsd:complexType>
1016         </xsd:element>
1017
1018         <xsd:complexType name="propertyType">
1019                 <xsd:sequence>
1020                         <xsd:element ref="description" minOccurs="0"/>
1021                         <xsd:choice minOccurs="0" maxOccurs="1">
1022                                 <xsd:element ref="meta"/>
1023                                 <xsd:element ref="bean"/>
1024                                 <xsd:element ref="ref"/>
1025                                 <xsd:element ref="idref"/>
1026                                 <xsd:element ref="value"/>
1027                                 <xsd:element ref="null"/>
1028                                 <xsd:element ref="list"/>
1029                                 <xsd:element ref="set"/>
1030                                 <xsd:element ref="map"/>
1031                                 <xsd:element ref="props"/>
1032                                 <xsd:any namespace="##other" processContents="strict"/>
1033                         </xsd:choice>
1034                 </xsd:sequence>
1035                 <xsd:attribute name="name" type="xsd:string" use="required">
1036                         <xsd:annotation>
1037                                 <xsd:documentation><![CDATA[
1038         The name of the property, following JavaBean naming conventions.
1039                                 ]]></xsd:documentation>
1040                         </xsd:annotation>
1041                 </xsd:attribute>
1042                 <xsd:attribute name="ref" type="xsd:string">
1043                         <xsd:annotation>
1044                                 <xsd:documentation><![CDATA[
1045         A short-cut alternative to a nested "<ref bean='...'/>".
1046                                 ]]></xsd:documentation>
1047                         </xsd:annotation>
1048                 </xsd:attribute>
1049                 <xsd:attribute name="value" type="xsd:string">
1050                         <xsd:annotation>
1051                                 <xsd:documentation><![CDATA[
1052         A short-cut alternative to a nested "<value>...</value>" element.
1053                                 ]]></xsd:documentation>
1054                         </xsd:annotation>
1055                 </xsd:attribute>
1056         </xsd:complexType>
1057
1058         <!-- Collection Types -->
1059
1060         <!-- base type for collections that have (possibly) typed nested values -->
1061         <xsd:complexType name="collectionType">
1062                 <xsd:attribute name="value-type" type="xsd:string">
1063                         <xsd:annotation>
1064                                 <xsd:documentation source="java:java.lang.Class"><![CDATA[
1065         The default Java type for nested values. Must be a fully qualified
1066         class name.
1067                                 ]]></xsd:documentation>
1068                         </xsd:annotation>
1069                 </xsd:attribute>
1070         </xsd:complexType>
1071
1072         <!-- 'list' and 'set' collection type -->
1073         <xsd:complexType name="listOrSetType">
1074                 <xsd:complexContent>
1075                         <xsd:extension base="collectionType">
1076                                 <xsd:group ref="collectionElements"/>
1077                         </xsd:extension>
1078                 </xsd:complexContent>
1079         </xsd:complexType>
1080
1081         <!-- 'map' element type -->
1082         <xsd:complexType name="mapType">
1083                 <xsd:complexContent>
1084                         <xsd:extension base="collectionType">
1085                                 <xsd:sequence>
1086                                         <xsd:element ref="description" minOccurs="0"/>
1087                                         <xsd:choice minOccurs="0" maxOccurs="unbounded">
1088                                                 <xsd:element ref="entry"/>
1089                                         </xsd:choice>
1090                                 </xsd:sequence>
1091                                 <xsd:attribute name="key-type" type="xsd:string">
1092                                         <xsd:annotation>
1093                                                 <xsd:documentation source="java:java.lang.Class"><![CDATA[
1094         The default Java type for nested entry keys. Must be a fully qualified
1095         class name.
1096                                                 ]]></xsd:documentation>
1097                                         </xsd:annotation>
1098                                 </xsd:attribute>
1099                         </xsd:extension>
1100                 </xsd:complexContent>
1101         </xsd:complexType>
1102
1103         <!-- 'entry' element type -->
1104         <xsd:complexType name="entryType">
1105                 <xsd:sequence>
1106                         <xsd:element ref="key" minOccurs="0"/>
1107                         <xsd:group ref="collectionElements"/>
1108                 </xsd:sequence>
1109                 <xsd:attribute name="key" type="xsd:string">
1110                         <xsd:annotation>
1111                                 <xsd:documentation><![CDATA[
1112         Each map element must specify its key as attribute or as child element.
1113         A key attribute is always a String value.
1114                                 ]]></xsd:documentation>
1115                         </xsd:annotation>
1116                 </xsd:attribute>
1117                 <xsd:attribute name="key-ref" type="xsd:string">
1118                         <xsd:annotation>
1119                                 <xsd:documentation><![CDATA[
1120         A short-cut alternative to a to a "key" element with a nested
1121         "<ref bean='...'/>".
1122                                 ]]></xsd:documentation>
1123                         </xsd:annotation>
1124                 </xsd:attribute>
1125                 <xsd:attribute name="value" type="xsd:string">
1126                         <xsd:annotation>
1127                                 <xsd:documentation><![CDATA[
1128         A short-cut alternative to a nested "<value>...</value>"
1129         element.
1130                                 ]]></xsd:documentation>
1131                         </xsd:annotation>
1132                 </xsd:attribute>
1133                 <xsd:attribute name="value-ref" type="xsd:string">
1134                         <xsd:annotation>
1135                                 <xsd:documentation><![CDATA[
1136         A short-cut alternative to a nested "<ref bean='...'/>".
1137                                 ]]></xsd:documentation>
1138                         </xsd:annotation>
1139                 </xsd:attribute>
1140         </xsd:complexType>
1141
1142         <!-- 'props' collection type -->
1143         <xsd:complexType name="propsType">
1144                 <xsd:complexContent>
1145                         <xsd:extension base="collectionType">
1146                                 <xsd:sequence>
1147                                         <xsd:choice minOccurs="0" maxOccurs="unbounded">
1148                                                 <xsd:element ref="prop"/>
1149                                         </xsd:choice>
1150                                 </xsd:sequence>
1151                         </xsd:extension>
1152                 </xsd:complexContent>
1153         </xsd:complexType>
1154
1155         <!-- simple internal types -->
1156         <xsd:simpleType name="defaultable-boolean">
1157                 <xsd:restriction base="xsd:NMTOKEN">
1158                         <xsd:enumeration value="default"/>
1159                         <xsd:enumeration value="true"/>
1160                         <xsd:enumeration value="false"/>
1161                 </xsd:restriction>
1162         </xsd:simpleType>
1163
1164 </xsd:schema>