spring中bean的基本xml配置

在spring容器内拼凑bean叫作装配。装配bean的时候，你是在告诉容器，需要哪些bean，以及容器如何使用依赖注入将它们配合在一起。
    理论上，bean装配可以从任何资源获得，包括属性文件，关系数据库等，但xml是最常见的spring 应用系统配置源。Spring中的几种容器都支持使用XML装配bean，包括：
    XMLBeanFactory ，
    ClassPathXMLApplicationContext ，
    FileSystemXMLApplicationContext ，
    XMLWebApplicationContext

    基本的XML配置包括如下几个方面：
   
    1．添加一个bean
    2．设置bean的属性
        2.1 手动设置
            2.1.1 通过Setter方法
            2.1.2 通过构造器
        2.2 自动设置
    其中bean的属性即为bean里的成员变量，这些成员变量值的获得可以通过setter方法，例如某个属性为name,则setter方法为setName(String name)；或者通过构造器在类被实例化时初始化。Setter方法(例如setName方法)或者构造器的调用都可以通过在XML文件里进行配置，从而实现让spring容器来自动进行。

1．添加一个bean
    以下是一个例子：
    <bean
        id = “mybean”
        Class = “blog.spring.MyBean”
        Singleton = “false”
        init-method = “initMethod”
        destroy-method = “destroyMethod”
        autowire = “autowire type”
    />
    下面是对该标签里各个属性的解释：
    Id : 标识该bean的名称，通过factory.getBean(“id”)来获得实例。
    Class : 该bean的类路径。
    Singleton : 默认为true，即单实例模式，每次getBean(“id”)时获取的都是同
一个实例，如果设置为false，即原型模式，则每次获取的是新创建
的实例。
    Init-method : 在bean实例化后要调用的方法(bean里定义好的方法)。
    Destroy-method : bean从容器里删除之前要调用的方法。
    Autowire : 其属性要通过何种方法进行属性的自动装配。
    对于上述的各个属性，id和class是必要的，其他的则可以省略。例如如果设置了autowire的值，则表明需要自动装配，否则是手动装配。

2．通过Setter方法手动设置bean里的属性
    Bean里的属性通过<property>标签来标识。有以下几种情况：
    ● 简单类型属性
        <bean id = “mybean” class = “blog.spring.MyBean”>
            <property name = “name”>
                <value>springTest</value>
            </property>
        </bean>
    ● 引用其他bean
        <bean id = “mybean” class = “blog.spring.MyBean” />
        <bean id = “mybean1” class = “blog.spring.MyBean1”>
            <property name = “name”>
                <ref bean = “mybean” />
            </property>
        </bean>
也可以将<ref>改为
    <bean class = “..”>
这样叫做内部bean，缺点是无法在其他地方重用这个bean的实例。
    ● 装配集合
        共有以下几种集合的装配：
    ****装配List和数组****
        <property name = ”nameList”>
            <list>
                <value>something</value>
                <ref bean = “blog.spring.MyBean” />
                <value>otherThing</value>
            </list>
        </property>
    ****装配Set****
        <property name = ”nameList”>
            <set>
                <value>something</value>
                <ref bean = “blog.spring.MyBean” />
                <value>otherThing</value>
            </set>
        </property>
    ****装配Map****
        <property name = ”nameList”>
            <map>
                <entry key = “key1”>
                    <value>value1</value>
                </entry>
                <entry key = “key2”>
                    <ref bean = “mybean” />
                </entry>
            </map>
        </property>
    ****装配Properties****
        <property name = ”nameList”>
            <props>
                <prop key = “prop1”>value1</prop>
                <prop key = “prop2”>value2</prop>
            </props>
        </property>
    ● 设置null
        要将一个属性null，需要通过<null />标签，如果不设置，则属性为默认值(在实例化时)而不是null。
        <property name=”name”> <null /> </property>

3．通过构造器手动设置bean里的属性
    假设有如下一个bean：
    Public class MyBean {
        Public MyBean( String arg1, MyBean1 arg2, String arg3 )
    }
则可以在XML里这样配置该bean：
<bean id = “mybean” class = “blog.spring.MyBean”>
        <constructor-arg index = “1”>
            <value>springTest</value>
        <constructor-arg>
        <constructor-arg index = “0”>
            <ref bean = “mybean1” />
        <constructor-arg>
</bean>
其中的index是用来标识该参数在构造函数里的位置的，并从0开始。

4．让spring完成自动装配
    例如：
<bean
id = “mybean”
class = “blog.spring.MyBean”
autowire = “autowire type”
/>
下面是几种autowire type的说明：
● byname : 试图在容器中寻找和需要自动装配的属性名相同的bean或id，如果没有找到相应的bean，则这个属性未被装配上。
● byType : 试图在容器中寻找一个与需要自动装配的属性类型相同的bean或id，如果没有找到，则该属性未被装配上。
● constructor : 试图在容器中寻找与需要自动装配的bean的构造函数参数一致的一个或多个bean，如果没找到则抛出异常。
● autodetect : 首先尝试使用constructor来自动装配，然后再使用byType方式。
从上面可以看出，如果某个bean不手动设置autowire属性，则默认为手动装配。如果需要将所有bean都设置为自动装配时，可以通过在<beans>标签中设置default-autowire属性。<beans>标签是整个XML文档的根，在它下面就是一个个的<bean>。
其中default-autowire的值也有byName，byType，constructor，autodetect四种。
例如配置如下：
<beans default-autowire = “byName”>
    ...
</beans>

    自动装配可能带来不确定性问题。例如使用byType时可能同时发现两个相同的类型，则不知道该采用哪一个。所以可能混合采用自动和手动装配。例如，对某个bean设置为自动装配，而对其某个属性则手动明确的设置其值，例如：
<bean id = “mybean” class = “blog.spring.MyBean”
    Autowire = “byType”
>
    <property name = “name”>
        <ref bean = “myBean1”>
    </property>
</bean>
通过这样的配置，对mybean里的name属性进行手动装配，而对除name外的其他属性就进行自动装配。

使用集合进行注入

一般，你的bean需要访问对象的集合，而不是访问一个单一的bean或者值。因此，理所当然的，Spring允许你在你的一个bean中注入一个对象的集合。使用集合很简单：你可以选择<list>、<map>、<set>或者<props>来描述List、Map、Set或者Properties的实例，然后就像你在其它注入中所用到的方式一传递这些对象。这个<props>标记只允许传递String值，因为Properties类只允许String作为属性的值。当使用<list>、<map>或者 <set>时，你可以使用注入到属性时可以使用的任何标记，甚至可以是其它的集合标记。这样，允许你传递存储Map的List，存储Set的 Map，甚至是List存储Map、Map中存储Set、Set中存储List这样的嵌套！Listing 4-27展示了可以注入四种集合类型的类。
Listing 4-27. 集合注入
public class CollectionInjection {
private Map map;
private Properties props;
private Set set;
private List list;
public static void main(String[] args) {
BeanFactory factory = new XmlBeanFactory(
new FileSystemResource("./ch4/src/conf/beans.xml"));
CollectionInjection instance = (CollectionInjection)
factory.getBean("injectCollection");
instance.displayInfo();
}

public void setList(List list) {
this.list = list;
}

public void setSet(Set set) {
this.set = set;
}

public void setMap(Map map) {
this.map = map;
}

public void setProps(Properties props) {
this.props = props;
}

public void displayInfo() {
// display the Map
Iterator i = map.keySet().iterator();
System.out.println("Map contents:\n");
while (i.hasNext()) {
Object key = i.next();
System.out.println("Key: " + key + " - Value: " + map.get(key));
}

// display the properties
i = props.keySet().iterator();
System.out.println("\nProperties contents:\n");
while (i.hasNext()) {
String key = i.next().toString();
System.out.println("Key: " + key + " - Value: "+ props.getProperty(key));
}

// display the set
i = set.iterator();
System.out.println("\nSet contents:\n");
while (i.hasNext()) {
System.out.println("Value: " + i.next());
}

// display the list
i = list.iterator();
System.out.println("\nList contents:\n");
while (i.hasNext()) {
System.out.println("Value: " + i.next());
}
}

}

这是很长的一段代码，但是它所作的工作去很少。Main()方法从Spring获得了一个CollectionInjection的bean，然后调用displayInfo()方法。这个方法只是输出从Spring注入的List、Map、Properties和Set的实例的内容。在 Listing 4-28中，你可以看到对于CollectionInjection类中注入的每一个属性所对应的注入值的配置。

Listing 4-28. 集合注入的配置
<bean id="injectCollection" class="com.apress.prospring.ch4.CollectionInjection">
<property name="map">
<map>
<entry key="someValue">
<value>Hello World!</value>
</entry>
<entry key="someBean">
<ref local="oracle"/>
</entry>
</map>
</property>

<property name="props">
<props>
<prop key="firstName">
Rob
</prop>
<prop key="secondName">
Harrop
</prop>
</props>
</property>

<property name="set">
<set>
<value>Hello World!</value>
<ref local="oracle"/>
</set>
</property>

<property name="list">
<list>
<value>Hello World!</value>
<ref local="oracle"/>
</list>
</property>

</bean>

在这段代码中，你可以看到，我们给ConstructorInjection类暴露的四个setter注入了值。对于map属性，我们使用< map>标记注入了一个Map的实例。注意，每一个条目都通过<entry>标签来指定，并且每一个都有一个String的键值和一个条目值。条目的值可以是你给单独的属性能够注入的任何类型；这个例子展示了<value>和<ref>标记的使用方法，添加了一个String值和一个bean的引用到Map中。对于props属性，我们使用了<props>标记来建立一个 java.util.Properties的实例，通过<prop>标记来扩展它。注意，虽然<prop>标记使用了类似 <entry>标记的方式来键入，但是你只能给Properties实例的每个属性指定一个String的值。

<list>和<set>标记工作的方式完全相同：你给每个元素指定值，可以使用在给一个属性注入单独的值的时候所能使用的任何标记，如<value>和<ref>。在Listing 4-28，你可以但到我们给List和Set各添加了一个String值和一个bean引用。

下面是Listing 4-28所产生的输出。和我们意料的一样，它列出了配置文件中生命的那些集合的元素。

Map contents:

Key: someValue - Value: Hello World!

Key: someBean - Value: com.apress.prospring.ch4.BookwormOracle@1ccce3c

Properties contents:

Key: secondName - Value: Harrop

Key: firstName - Value: Rob

Set contents:

Value: com.apress.prospring.ch4.BookwormOracle@1ccce3c

Value: Hello World!

List contents:

Value: Hello World!

Value: com.apress.prospring.ch4.BookwormOracle@1ccce3c

要记住，对于<list>、<map>和<set>元素，你可以使用任何用来设置非集合属性的标记来指定集合的条目的值。这个理念非常的强大，因此你在注入集合的时候后就不会被限制于使用原生值了，你也可以将一个集合的bean注入到另一个集合中。