Configuring Beans in the Spring IoC Container

Configuring Beans in the Spring IoC Container

这本书对spring bean的配置比较全面。

注：配置类似
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
的时候，xsd的版本号不要带，至于为什么，参考以前转载的老外博客。

Problem

Spring offers a powerful IoC container to manage the beans that make up an application. To utilize the

container services, you have to configure your beans to run in the Spring IoC container.

Solution

You can configure your beans in the Spring IoC container through XML files, properties files,

annotations, or even APIs.

Spring allows you to configure your beans in one or more bean configuration files. For a

simple application, you can simply centralize your beans in a single configuration file. But for a large

application with a lot of beans, you should separate them in multiple configuration files according to

their functionalities. One useful division is by the architectural layer that a given context services.

How It Works

Suppose that you are going to develop an application for generating sequence numbers. In this

application, there may be many series of sequence numbers to generate for different purposes. Each

one of them will have its own prefix, suffix, and initial value. So, you have to create and maintain

multiple generator instances in your application.

Creating the Bean Class

In accordance with the requirements, you create the SequenceGenerator class that has three

properties_prefix, suffix, and initial_that can be injected via setter methods or a constructor. The

private field counter is for storing the current numeric value of this generator. Each time you call the

getSequence() method on a generator instance, you will get the last sequence number with the prefix

and suffix joined. You declare this method as synchronized to make it thread-safe.

package com.apress.springenterpriserecipes.sequence;
public class SequenceGenerator {
private String prefix;
private String suffix;
private int initial;
private int counter;
public SequenceGenerator() {}
public SequenceGenerator(String prefix, String suffix, int initial) {
this.prefix = prefix;
this.suffix = suffix;
this.initial = initial;
}
public void setPrefix(String prefix) {
this.prefix = prefix;
}
public void setSuffix(String suffix) {
this.suffix = suffix;
}
public void setInitial(int initial) {
this.initial = initial;
}
public synchronized String getSequence() {
StringBuffer buffer = new StringBuffer();
buffer.append(prefix);
buffer.append(initial + counter++);
buffer.append(suffix);
return buffer.toString();
}
}

As you see, this SequenceGenerator class can be configured by getters/setters or by the constructor.

When configuring them with the container, this is called constructor injection and setter injection.

Creating the Bean Configuration File

To declare beans in the Spring IoC container via XML, you first have to create an XML bean

configuration file with an appropriate name, such as beans.xml. You can put this file in the root

of the classpath for easier testing within an IDE.

The Spring configuration XML allows you to use custom tags from different schemas (tx, jndi, jee,

and so on) to make the bean configuration simpler and clearer. Here’s an example of the simplest XML

configuration possible.

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

Declaring Beans in the Bean Configuration File

Each bean should provide a unique name or id and a fully qualified class name for the Spring IoC

container to instantiate it. For each bean property of simple type (e.g., String and other primitive types),

you can specify a <value> element for it. Spring will attempt to convert your value into the declaring type

of this property. To configure a property via setter injection, you use the <property> element and specify

the property name in its name attribute. A <property> requires that the bean contain a corresponding

setter method.

<bean name="sequenceGenerator"
class="com.apress.springenterpriserecipes.sequence.SequenceGenerator">
<property name="prefix">
<value>30</value>
</property>
<property name="suffix">
<value>A</value>
</property>
<property name="initial">
<value>100000</value>
</property>
</bean>

You can also configure bean properties via constructor injection by declaring them in the

<constructor-arg>
elements. There’s not a
name
attribute in
<constructor-arg>
because constructor

arguments are position-based.

<bean name="sequenceGenerator"
class="com.apress.springenterpriserecipes.sequence.SequenceGenerator">
<constructor-arg>
<value>30</value>
</constructor-arg>
<constructor-arg>
<value>A</value>
</constructor-arg>
<constructor-arg>
<value>100000</value>
</constructor-arg>
</bean>

In the Spring IoC container, each bean’s name should be unique, although duplicate names are

allowed for overriding bean declaration if more than one context is loaded. A bean’s name can be

defined by the name
attribute of the <bean>
element. Actually, there’s a preferred way of identifying a

bean: through the standard XML
id attribute, whose purpose is to identify an element within an XML

document. In this way, if your text editor is XML-aware, it can help to validate each bean’s uniqueness at

design time.

<bean id="sequenceGenerator"
class="com.apress.springenterpriserecipes.sequence.SequenceGenerator">
...
</bean>

However, XML has restrictions on the characters that can appear in the XML
id
attribute, but

usually you won’t use those special characters in a bean name. Moreover, Spring allows you to specify

multiple names, separated by commas, for a bean in the
name attribute. But you can’t do so in the
id

attribute because commas are not allowed there.

In fact, neither the bean name nor the bean ID is required for a bean. A bean that has no name

defined is called an anonymous bean. You will usually create beans like this that serve only to interact

with the Spring container itself; that you are sure you will only inject by type later on; or that you will

nest, inline, in the declaration of an outer bean.

Defining
Bean Properties by Shortcut

Spring
supports a shortcut for specifying the value of a simple type property. You can present a
value

attribute in the
<property> element instead of enclosing a
<value>
element inside.

<bean id="sequenceGenerator"
class="com.apress.springenterpriserecipes.sequence.SequenceGenerator">
<property name="prefix" value="30" />
<property name="suffix" value="A" />
<property name="initial" value="100000" />
</bean>
This shortcut also works for constructor arguments.
<bean name="sequenceGenerator"
class="com.apress.springenterpriserecipes.sequence.SequenceGenerator">
<constructor-arg value="30" />
<constructor-arg value="A" />
<constructor-arg value="100000" />
</bean>

Spring 2.0 provides another convenient shortcut for you to define properties. It’s by using the
p

schema to define bean properties as attributes of the
<bean>
element. This can shorten the lines of XML

configuration.

<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-3.0.xsd">

<span style="font-family: TheSansMonoCondensed-Plain; font-size: 9pt;"><bean id="sequenceGenerator"
<span style="font-size: 9pt;">class="com.apress.springenterpriserecipes.sequence.SequenceGenerator"
<span style="font-family: TheSansMonoCondensed-Black; font-size: 9pt;">p:prefix="30" p:suffix="A" p:initial="100000" />
<span style="font-family: TheSansMonoCondensed-Plain; font-size: 9pt;"></beans></span></span></span><br style="orphans: 2; text-align: -webkit-auto; widows: 2;" /></span>

Configuring Collections for Your Beans

List,
Set, and
Map
are the core interfaces representing three main types of collections. For each

collection type, Java provides several implementations with different functions and characteristics from

which you can choose. In Spring, these types of collections can be easily configured with a group of

built-in XML tags, such as <list>,
<set>, and
<map>.

Suppose you are going to allow more than one suffix for your sequence generator. The suffixes will

be appended to the sequence numbers with hyphens as the separators. You may consider accepting

suffixes of arbitrary data types and converting them into strings when appending to the sequence

numbers.

Lists, Arrays, and Sets

First, let’s use a java.util.List
collection to contain your suffixes. A
list is an ordered and indexed

collection whose elements can be accessed either by index or with a for-each loop.

package com.apress.springenterpriserecipes.sequence;
...
public class SequenceGenerator {
...
private List<Object> suffixes;
public void setSuffixes(List<Object> suffixes) {
this.suffixes = suffixes;
}
public void setPrefixGenerator(PrefixGenerator prefixGenerator) {
this.prefixGenerator = prefixGenerator;
}
public synchronized String getSequence() {
StringBuffer buffer = new StringBuffer();
...
for (Object suffix : suffixes) {
buffer.append("-");
buffer.append(suffix);
}
return buffer.toString();
}
}

To define a property of the interface
java.util.List
in the bean configuration, you specify a
<list>

tag that contains the elements. The elements allowed inside the
<list>
tag can be a simple constant

value specified by <value>, a bean reference by
<ref>, an inner bean definition by
<bean>, or a null

element by <null>. You can even embed other collections in a collection.

<bean id="sequenceGenerator"
class="com.apress.springenterpriserecipes.sequence.SequenceGenerator">
<property name="prefixGenerator" ref="datePrefixGenerator" />
<property name="initial" value="100000" />
<property name="suffixes">
<list>
<value>A</value>
<bean class="java.net.URL">
<constructor-arg value="http" />
<constructor-arg value="www.apress.com" />
<constructor-arg value="/" />
</bean>
<null />
</list>
</property>
</bean>

Conceptually, an
array is very similar to a list in that it’s also an ordered and indexed collection that

can be accessed by index. The main difference is that the length of an array is fixed and cannot be

extended dynamically. In the Java Collections framework, an array and a list can be converted to each

other through the Arrays.asList()
and
List.toArray() methods. For your sequence generator, you can

use an Object[]
array to contain the suffixes and access them either by index or with a for-each loop.

package com.apress.springenterpriserecipes.sequence;
...
public class SequenceGenerator {
...
private Object[] suffixes;
public void setSuffixes(Object[] suffixes) {
this.suffixes = suffixes;
}
...
}

The definition of an array in the bean configuration file is identical to a list denoted by the

<list>
tag.

Another common collection type is a set. Both the
java.util.List
interface and the java.util.Set

interface extend the same interface:
java.util.Collection. A set differs from a list in that it is neither

ordered nor indexed, and it can store unique objects only. That means no duplicate element can be

contained in a set. When the same element is added to a set for the second time, it will replace the old

one. The equality of elements is determined by the
equals() method.

package com.apress.springenterpriserecipes.sequence;

package com.apress.springenterpriserecipes.sequence;
...
public class SequenceGenerator {
...
private Set<Object> suffixes;
public void setSuffixes(Set<Object> suffixes) {
this.suffixes = suffixes;
}
...
}

To define a property of
java.util.Set
type, use the
<set>
tag to define the elements in the same way

as a list.

<bean id="sequenceGenerator"
class="com.apress.springenterpriserecipes.sequence.SequenceGenerator">
...
<property name="suffixes">
<set>
<value>A</value>
<bean class="java.net.URL">
<constructor-arg value="http" />
<constructor-arg value="www.apress.com" />
<constructor-arg value="/" />
</bean>
<null />
</set>
</property>
</bean>

Although there’s not an order concept in the original set semantics, Spring preserves the order of

your elements by using java.util.LinkedHashSet, an implementation of the
java.util.Set
interface

that does preserve element order.

Maps
and Properties

A
map
is a table that stores its entries in key/value pairs. You can get a particular value from a map by its

key, and also iterate the map entries with a for-each loop. Both the keys and values of a map can be of

arbitrary type. Equality between keys is also determined by the
equals() method. For example, you can

modify your sequence generator to accept a
java.util.Map collection that contains suffixes with keys.

package com.apress.springenterpriserecipes.sequence;
...
public class SequenceGenerator {
...
private Map<Object, Object> suffixes;
public void setSuffixes(Map<Object, Object> suffixes) {
this.suffixes = suffixes;
}
public synchronized String getSequence() {
StringBuffer buffer = new StringBuffer();
...
for (Map.Entry entry : suffixes.entrySet()) {
buffer.append("-");
buffer.append(entry.getKey());
buffer.append("@");
buffer.append(entry.getValue());
}
return buffer.toString();
}
}

In Spring, a map is defined by the
<map>
tag, with multiple
<entry>
tags as children. Each entry

contains a key and a value. The key must be defined inside the <key>
tag. There is no restriction on the

type of the key and value, so you are free to specify a <value>,
<ref>,
<bean>,
<idref>, or
<null>
element

for them. Spring will also preserve the order of the map entries by using
java.util.LinkedHashMap.

<bean id="sequenceGenerator"
class="com.apress.springenterpriserecipes.sequence.SequenceGenerator">
...
<property name="suffixes">
<map>
<entry>
<key>
<value>type</value>
</key>
<value>A</value>
</entry>
<entry>
<key>
<value>url</value>
</key>
<bean class="java.net.URL">
<constructor-arg value="http" />
<constructor-arg value="www.apress.com" />
<constructor-arg value="/" />
</bean>
</entry>
</map>
</property>
</bean>

There are shortcuts to defining map keys and values as attributes of the
<entry>
tag. If they are

simple constant values, you can define them by key
and
value. If they are bean references, you can

define them by key-ref
and
value-ref.

<pre name="code" class="html"><bean id="sequenceGenerator"
class="com.apress.springenterpriserecipes.sequence.SequenceGenerator">
...
<property name="suffixes">
<map>
<entry key="type" value="A" />
<entry key="url">
<bean class="java.net.URL">
<constructor-arg value="http" />
<constructor-arg value="www.apress.com" />
<constructor-arg value="/" />
</bean>
</entry>
</map>
</property>
</bean>

In all the collection classes seen thus far, you used values to set the properties. Sometimes the

desired goal is to configure a
null value using a
Map instance. Spring’s XML configuration schema

includes explicit support for this. Here is a map with null values for the value of an entry:

<property name="nulledMapValue">
<map>
<entry>
<key> <value>null</value> </key>
</entry>
</map>
</property>

A
java.util.Properties collection is very similar to a map. It also implements the
java.util.Map

interface and stores entries in key/value pairs. The only difference is that the keys and values of a

Properties
collection are always strings.

package com.apress.springenterpriserecipes.sequence;
...
public class SequenceGenerator {
...
private Properties suffixes;
public void setSuffixes(Properties suffixes) {
this.suffixes = suffixes;
}
...
}

To define a
java.util.Properties collection in Spring, use the
<props>
tag with multiple <prop>
tags

as children. Each <prop>
tag must have a key
attribute defined and the corresponding value enclosed.

<bean id="sequenceGenerator"
class="com.apress.springenterpriserecipes.sequence.SequenceGenerator">
...
<property name="suffixes">
<props>
<prop key="type">A</prop>
<prop key="url">http://www.apress.com/</prop>
<prop key="null">null</prop>
</props>
</property>
</bean>

If you define your beans with inheritance, a child bean’s collection can be merged with that of its

parent by setting the merge
attribute to
true. For a
<list>
collection, the child elements will be added.

来源：
Spring Enterprise Recipes: A Problem-Solution Approach 2016年2月10

Copyright © 2009 by Gary Mak and Josh Long

All rights reserved. No part of this work may be reproduced or transmitted in any form or by any

means, electronic or mechanical, including photocopying, recording, or by any information

storage or retrieval system, without the prior written permission of the copyright owner and the

publisher.

ISBN-13 (pbk): 978-1-4302-2497-6

ISBN-13 (electronic): 978-1-4302-2498-3

Printed and bound in the United States of America 9 8 7 6 5 4 3 2 1