Every Java package has a corresponding XML namespace. The namespace URN consists of the package name, with the prefix urn:java:. For example, the package com.mydomain.myapp has the XML namespace urn:java:com.mydomain.myapp.

<WebBeans xmlns="urn:java:javax.webbeans"
          xmlns:myapp="urn:java:com.mydomain.myapp">
    ...
</WebBeans>

Each namespace may, optionally, have a schema.

<WebBeans xmlns="urn:java:javax.webbeans"
          xmlns:myapp="urn:java:com.mydomain.myapp"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="urn:java:javax.webbeans http://java.sun.com/jee/web-beans-1.0.xsd
                               urn:java:com.mydomain.myapp http://mydomain.com/xsd/myapp-1.2.xsd">
    ...
</WebBeans>

An XML element belonging to a namespace represents a Java type in the corresponding Java package, or a method or field of a type in that package. There are exactly ten exceptions to this rule: the root <WebBeans> element together with the <Queue>, <Topic>, <destination>, <connectionFactory>, <value>, <Deploy>, <Interceptors>, <Decorators> and <Array> elements in the namespace urn:java:javax.webbeans do not correspond to Java types or members of Java types.

A class, interface or annotation type is represented by an element with the same name as the type, in the namespace corresponding to the Java package. For example, the element <List> in the namespace urn:java:java.util represents java.util.List.

Type parameters may be specified by child elements of the element that represents the type. For example:

<util:List>
    <myapp:Product/>
</util:List>

Members of a type may be specified by child elements of the element that represents the type, in the same namespace as the element that represents the type. For example:

<myapp:ShoppingCart>
    <myapp:paymentProcessor>
        ...
    </myapp:paymentProcessor>
</myapp:ShoppingCart>

Primitive types may be represented by the XML element that represents the corresponding wrapper type in java.lang, since primitive and wrapper types are considered identical for the purposes of typesafe resolution, and assignable for the purposes of injection. For example, the element <Integer> in the namespace urn:java:java.lang represent both int and java.lang.Integer.

Java array types may be represented by an <Array> element in the namespace urn:java:javax.webbeans, with a child element representing the element type. For example:

<Array>
    <myapp:Product/>
</Array>

The namespace urn:java:javax.webbeans is called the Web Beans namespace.

If a web-beans.xml file contains any XML element without a declared namespace, a DefinitionException is thrown by the Web Bean manager at initialization time.

An XML element that appears as a direct child of the root <WebBeans> element is interpreted as a Web Bean declaration if it is not a <Deploy>, <Interceptors> or <Decorators> element in the Web Beans namespace.

If the XML element is a <Queue> or <Topic> element in the Web Beans namespace, it declares a JMS endpoint, as defined in Section 3.5.2, “Declaring a JMS endpoint using XML”.

Otherwise, the name of the XML element is interpreted as a Java type name in the package corresponding to the child element namespace. The Web Beans manager inspects the Java type and other metadata to determine what kind of Web Bean is being declared. If no such Java type exists in the classpath, a NonexistentTypeException is thrown by the Web Bean manager at initialization time.

For example, the following XML file declares a simple Web Bean with the implementation class com.mydomain.myapp.PaymentProcessor:

<WebBeans xmlns="urn:java:javax.webbeans"
           xmlns:myapp="urn:java:com.mydomain.myapp"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="urn:java:javax.webbeans http://java.sun.com/jee/web-beans-1.0.xsd
                               urn:java:com.mydomain.myapp http://mydomain.com/xsd/myapp-1.2.xsd">
    
    <myapp:PaymentProcessor>
        ...
    </myapp:PaymentProcessor>
    
</WebBeans>

In addition, inline Web Bean declarations may occur at injection points, as defined in Section 9.6, “Inline Web Bean declarations”. Inline Web Bean declarations always declare simple Web Beans.

In a Java EE 5 environment, the Web Bean manager is not required to support XML-based declaration of enterprise Web Beans.

<myapp:Order>
    <ConversationScoped/>
    <myapp:PaymentProcessor>
        <myapp:Asynchronous/>
    </myapp:PaymentProcessor>
    <myapp:User/>
</myapp:Order>

<myapp:Config>
    <myapp:version>1.2.5</myapp:version>
    <myapp:timeout>1000</myapp:timeout>
    <myapp:administrators>
        <value>juan</value>
        <value>antonio</value>
        <value>sonia</value>
        <value>sara</value>
    </myapp:administrators>
</myapp:Config>

A producer method declaration is formed by adding a direct child <Produces> element to an element that represents the method, as defined in Section 3.4.3, “Declaring a producer method using XML”.

<myapp:getPaymentProcessor>
    <Produces>
        <myapp:PaymentProcessor/>
    </Produces>
    ...
</myapp:getPaymentProcessor>

A simple Web Bean declaration is interpreted as an interceptor or decorator declaration if it contains a direct child <Interceptor> or <Decorator> element in the Web Beans namespace.

For example, the following XML file declares an interceptor of class RequiresTransactionInterceptor, an interceptor of class RequiresNewTransactionInterceptor and a decorator of class DataAccessAuthorizationDecorator, all in the Java package com.mydomain.myfwk:

<WebBeans xmlns="urn:java:javax.webbeans"
           xmlns:myapp="urn:java:com.mydomain.myapp"
           xmlns:myfwk="urn:java:com.mydomain.myfwk"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="urn:java:javax.webbeans http://java.sun.com/jee/web-beans-1.0.xsd
                               urn:java:com.mydomain.myfwk http://mydomain.com/xsd/myfwk-1.0.xsd
                               urn:java:com.mydomain.myapp http://mydomain.com/xsd/myapp-1.2.xsd">
    
    <myfwk:RequiresTransactionInterceptor>
        <Interceptor/>
        <myfwk:Transactional/>
    </myfwk:RequiresTransactionInterceptor>
    
    <myfwk:RequiresNewTransactionInterceptor>
        <Interceptor/>
        <myfwk:Transactional requiresNew="true"/>
    </myfwk:RequiresNewTransactionInterceptor>
    
    <myfwk:DataAccessAuthorizationDecorator>
        <Decorator/>
        <myfwk:dataAccess>
            <Decorates>
                <myfwk:DataAccess/>
            </Decorates>
        </myfwk:dataAccess>
    <myfwk:DataAccessAuthorizationDecorator>
    
</WebBeans>

If a Web Bean declaration that is not a simple Web Bean declaration contains a child <Interceptor> or <Decorator> element, or if an inline Web Bean declaration contains a child <Interceptor> or <Decorator> element, a DefinitionException is thrown by the Web Bean manager at initialization time.

If a simple Web Bean declaration contains more than one direct child <Interceptor> or <Decorator> element in the Web Beans namespace, a DefinitionException is thrown by the Web Bean manager at initialization time.

An injection point declaration is either:

When the Web Bean manager encounters an injection point declaration, it interprets the name of the element as the name of a Java class or interface in the package corresponding to the element namespace. If no such Java type exists in the classpath, a NonexistentTypeException is thrown by the Web Bean manager at initialization time.

An inline Web Bean declaration is a simple Web Bean declaration, as defined in Section 9.2, “Web Bean declarations” that occurs as an injection point declaration, instead of as a direct child of the <WebBeans> element.

<myapp:Admin>
    <ApplicationScoped/>
      
    <myapp:username>gavin</myapp:username>
    
    <myapp:name>
        <myapp:Name>
            <myapp:firstName>Gavin</myapp:firstName>
            <myapp:lastName>King</myapp:lastName>
        </myapp:Name>
    </myapp:name>
    
</myapp:Admin>

The name of the element is interpreted as the name of a Java class in the package corresponding to the element namespace. This Java class is the implementation class of the simple Web Bean.

Inline Web Bean declarations may not explicitly specify a binding type. If an inline Web Bean declaration explicitly specifies a binding type, a DefinitionException is thrown by the Web Bean manager at initialization time.

For every inline injection point, the Web Bean manager generates a unique value for an implementation-specific binding type. (For example, a particular Web Bean manager implementation might generate the value com.vendor.webbeans.Inline(id=12345) at some injection point.) This generated value is the binding type of the injection point, and the only binding type of the simple Web Bean. The API type of the injection point is the declared implementation class of the simple Web Bean.

Thus, an inline Web Bean declaration results in a simple Web Bean that is bound only to the injection point at which it was declared.

Every injection point and delegate attribute defined in XML must explicitly specify an API type and combination of binding types. XML-based producer method declarations must also explicitly specify the return type (which is used to calculate the set of API types) and binding types. A type declaration is:

For example, the following XML fragment declares the type List<Product> with binding type @All.

<util:List>
    <myapp:All/>
    <myapp:Product/>
</util:List>

This XML fragment declares the type Product[] with binding type @Available.

<Array>
    <myapp:Available/>
    <myapp:Product/>
</Array>

When the Web Bean manager encounters a type declaration it interprets the element as a Java type:

Next, the Web Bean manager inspects every direct child element of the type declaration. The name of each child element is interpreted as the name of a Java type in the package corresponding to the child element namespace. If no such Java type exists in the classpath, a NonexistentTypeException is thrown by the Web Bean manager at initialization time.

If multiple array element types are declared, a DefinitionException is thrown by the Web Bean manager at initialization time.

If the number of declared actual type parameters is not the same as the number of parameters of the Java type, a DefinitionException is thrown by the Web Bean manager at initialization time.

If a type parameter of the Java type is bounded, and the corresponding declared actual type parameter does not satisfy the upper or lower bound, a DefinitionException is thrown by the Web Bean manager at initialization time.

If a binding type declaration declares a Java annotation type that is not a Web Beans binding type, a DefinitionException is thrown by the Web Bean manager at initialization time.

If no binding type is declared, the default binding type @Current is assumed.

If the same binding type occurs more than once, a DuplicateBindingTypeException is thrown by the Web Bean manager at initialization time.

For fields, type declarations are specified as direct child elements of the field declaration:

<myapp:Order>
      
    <myapp:paymentProcessor>
    
        <myapp:PaymentProcessor>
            <myapp:PayBy>CHEQUE</myapp:PayBy>
        </myapp:PaymentProcessor>
        
    </myapp:paymentProcessor>
    
</myapp:Order>

<myapp:ShoppingCart>
      
    <myapp:catalog>
    
        <util:List>
            <myapp:All/>
            <myapp:Product/>
        </util:List>
        
    </myapp:catalog>

</myapp:ShoppingCart>

For methods, the method parameter declarations are type declarations:

<myapp:Order>
    
    <myapp:setPaymentProcessor>
        <Initializer/>
        
        <myapp:PaymentProcessor>
            <myapp:PayBy>CHEQUE</myapp:PayBy>
        </myapp:PaymentProcessor>
        
        <myfwk:Logger/>
        
    </myapp:setPaymentProcessor>

</myapp:Order>

For producer methods, the return type must also be specified:

<app:Shop>

    <app:getAvailableProducts>
    
        <Produces>
            <ApplicationScoped/>
            <Array>
                <app:Available/>
                <app:Product/>
            </Array>
        </Produces>
        
        <util:List>
            <app:All/>
            <app:Product/>
        </util:List>        
        
    </app:getAvailableProducts>
    
</app:Shop>

For constructors, the constructor parameter declarations are type declarations:

<myapp:Order>
    <ConversationScoped/>
    
    <myapp:PaymentProcessor>
        <myapp:PayBy>CHEQUE</myapp:PayBy>
    </myapp:PaymentProcessor>
    
    <myfwk:Logger/>
    
</myapp:Order>

Any binding type or interceptor binding type declaration must define the value of any annotation member without a default value, and may additionally define the value of any annotation member with a default value. Annotation member values are defined by attributes of the XML element which represents the Java annotation.

All attributes of any XML element which corresponds to a Java annotation are interpreted as members of the annotation. The name of the attribute is interpreted as the name of the corresponding annotation member. The value of the attribute is interpreted as the value of the annotation member. If there is no annotation member with the same name as the attribute, a NonexistentMemberException is thrown by the Web Bean manager at initialization time.

<myfwk:DataAccess transactional="true"/>

Alternatively, the value of an annotation member named value may be specified in the body of the XML element which corresponds to the Java annotation. If the XML element has a non-empty body and also specifies an attribute named value, a DefinitionException is thrown by the Web Bean manager at initialization time. If the XML element has a non-empty body, and there is no annotation member named value, a NonexistentMemberException is thrown by the Web Bean manager at initialization time.

<myapp:PayBy>CHEQUE</myapp:PayBy>

If the member value is not specified in the correct format for the type of the member, a DefinitionException is thrown by the Web Bean manager at initialization time.

If an XML element that refers to a Java annotation with a member with no default value does not declare a value for that member, a DefinitionException is thrown by the Web Bean manager at initialization time.

The <Deploy>, <Interceptors> and <Decorators> elements in the Web Beans namespace determine which Web Beans, interceptors and decorators are enabled in a particular deployment.