A<bean/>element inside the<property/>or<constructor-arg/>elements defines a so-calledinner bean.

<bean id="outer" class="...">
    <!-- instead of using a reference to a target bean,simply define the target bean inline -->
    <property name="target">
        <bean class="com.example.Person"> <!-- this is the inner bean -->
            <property name="name" value="Fiona Apple"/>
            <property name="age" value="25"/>
        </bean>
    </property>
</bean>

An inner bean definition does not require a defined id or name; the container ignores these values. It also ignores thescopeflag. Inner beans arealwaysanonymous and they arealwayscreated with the outer bean. It isnotpossible to inject inner beans into collaborating beans other than into the enclosing bean.

In the<list/>,<set/>,<map/>,and<props/>elements,you set the properties and arguments of the JavaCollectiontypesList,Set,Map,andProperties,respectively.

<bean id="moreComplexObject" class="example.ComplexObject">
    <!-- results in a setAdminEmails(java.util.Properties) call -->
    <property name="adminEmails">
        <props>
            <prop key="administrator">administrator@example.org</prop>
            <prop key="support">support@example.org</prop>
            <prop key="development">development@example.org</prop>
        </props>
    </property>
    <!-- results in a setSomeList(java.util.List) call -->
    <property name="someList">
        <list>
            <value>a list element followed by a reference</value>
            <ref bean="myDataSource" />
        </list>
    </property>
    <!-- results in a setSomeMap(java.util.Map) call -->
    <property name="someMap">
        <map>
            <entry key="an entry" value="just some string"/>
            <entry key ="a ref" value-ref="myDataSource"/>
        </map>
    </property>
    <!-- results in a setSomeSet(java.util.Set) call -->
    <property name="someSet">
        <set>
            <value>just some string</value>
            <ref bean="myDataSource" />
        </set>
    </property>
</bean>

The value of a map key or value,or a set value,can also again be any of the following elements:

bean | ref | idref | list | set | map | props | value | null

<beans>
    <bean id="parent" abstract="true" class="example.ComplexObject">
        <property name="adminEmails">
            <props>
                <prop key="administrator">administrator@example.com</prop>
                <prop key="support">support@example.com</prop>
            </props>
        </property>
    </bean>
    <bean id="child" parent="parent">
        <property name="adminEmails">
            <!-- the merge is specified on the child collection definition -->
            <props merge="true">
                <prop key="sales">sales@example.com</prop>
                <prop key="support">support@example.co.uk</prop>
            </props>
        </property>
    </bean>
<beans>

administrator=administrator@example.com
sales=sales@example.com
support=support@example.co.uk

public class Foo {

    private Map<String,Float> accounts;

    public void setAccounts(Map<String,Float> accounts) {
        this.accounts = accounts;
    }
}

<beans>
    <bean id="foo" class="x.y.Foo">
        <property name="accounts">
            <map>
                <entry key="one" value="9.99"/>
                <entry key="two" value="2.75"/>
                <entry key="six" value="3.99"/>
            </map>
        </property>
    </bean>
</beans>

Spring treats empty arguments for properties and the like as emptyStrings. The following XML-based configuration Metadata snippet sets the email property to the emptyStringvalue ("").

<bean class="ExampleBean">
    <property name="email" value=""/>
</bean>

The preceding example is equivalent to the following Java code:exampleBean.setEmail(""). The<null/>element handlesnullvalues. For example:

<bean class="ExampleBean">
    <property name="email">
        <null/>
    </property>
</bean>

The above configuration is equivalent to the following Java code:exampleBean.setEmail(null).

The p-namespace enables you to use thebeanelement’s attributes,instead of nested<property/>elements,to describe your property values and/or collaborating beans.

Spring supports extensible configuration formatswith namespaces,which are based on an XML Schema definition. Thebeansconfiguration format discussed in this chapter is defined in an XML Schema document. However,the p-namespace is not defined in an XSD file and exists only in the core of Spring.

The following example shows two XML snippets that resolve to the same result: The first uses standard XML format and the second uses the p-namespace.

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean name="classic" class="com.example.ExampleBean">
        <property name="email" value="foo@bar.com"/>
    </bean>

    <bean name="p-namespace" class="com.example.ExampleBean"
        p:email="foo@bar.com"/>
</beans>

The example shows an attribute in the p-namespace called email in the bean definition. This tells Spring to include a property declaration. As prevIoUsly mentioned,the p-namespace does not have a schema definition,so you can set the name of the attribute to the property name.

This next example includes two more bean definitions that both have a reference to another bean:

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean name="john-classic" class="com.example.Person">
        <property name="name" value="John Doe"/>
        <property name="spouse" ref="jane"/>
    </bean>

    <bean name="john-modern"
        class="com.example.Person"
        p:name="John Doe"
        p:spouse-ref="jane"/>

    <bean name="jane" class="com.example.Person">
        <property name="name" value="Jane Doe"/>
    </bean>
</beans>

As you can see,this example includes not only a property value using the p-namespace,but also uses a special format to declare property references. Whereas the first bean definition uses<property name="spouse" ref="jane"/>to create a reference from beanjohnto beanjane,the second bean definition usesp:spouse-ref="jane"as an attribute to do the exact same thing. In this casespouseis the property name,whereas the-refpart indicates that this is not a straight value but rather a reference to another bean.

Similar to thethe section called “XML shortcut with the p-namespace”,thec-namespace,newly introduced in Spring 3.1,allows usage of inlined attributes for configuring the constructor arguments rather then nestedconstructor-argelements.

Let’s review the examples fromthe section called “Constructor-based dependency injection”with thec:namespace:

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:c="http://www.springframework.org/schema/c"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="bar" class="x.y.Bar"/>
    <bean id="baz" class="x.y.Baz"/>

    <!-- traditional declaration -->
    <bean id="foo" class="x.y.Foo">
        <constructor-arg ref="bar"/>
        <constructor-arg ref="baz"/>
        <constructor-arg value="foo@bar.com"/>
    </bean>

    <!-- c-namespace declaration -->
    <bean id="foo" class="x.y.Foo" c:bar-ref="bar" c:baz-ref="baz" c:email="foo@bar.com"/>

</beans>

Thec:namespace uses the same conventions as thep:one (trailing-reffor bean references) for setting the constructor arguments by their names. And just as well,it needs to be declared even though it is not defined in an XSD schema (but it exists inside the Spring core).

For the rare cases where the constructor argument names are not available (usually if the bytecode was compiled without debugging information),one can use fallback to the argument indexes:

<!-- c-namespace index declaration -->
<bean id="foo" class="x.y.Foo" c:_0-ref="bar" c:_1-ref="baz"/>

In practice,the constructor resolutionmechanismis quite efficient in matching arguments so unless one really needs to,we recommend using the name notation through-out your configuration.

You can use compound or nested property names when you set bean properties,as long as all components of the path except the final property name are notnull. Consider the following bean definition.

<bean id="foo" class="foo.Bar">
    <property name="fred.bob.sammy" value="123" />
</bean>

Thefoobean has afredproperty,which has abobproperty,which has asammyproperty,and that finalsammyproperty is being set to the value123. In order for this to work,thefredproperty offoo,and thebobproperty offredmust not benullafter the bean is constructed,or aNullPointerExceptionis thrown.