依赖配置详解
bean的属性及构造器参数既可以引用容器中的其他bean，也可以是内联（inline）bean。在spring的XML配置中使用
直接变量(基本类型、Strings类型等。)
<value/>元素通过人可以理解的字符串来指定属性或构造器参数的值。正如前面所提到的，JavaBean PropertyEditor将用于把字符串从java.lang.String类型转化为实际的属性或参数类型。
<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/mydb</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>masterkaoli</value>
</property>
</bean>
<property/> 和<constructor-arg/> 元素中也可以使用'value' 属性，这样会使我们的配置更简洁，比如下面的配置
<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<!-- results in a setDriverClassName(String) call -->
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
<property name="username" value="root"/>
<property name="password" value="masterkaoli"/>
</bean>
Spring团队更倾向采用属性方式（使用
<bean id="mappings" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<!-- typed as a java.util.Properties -->
<property name="properties">
<value>
jdbc.driver.className=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mydb
</value>
</property>
</bean>
如果采用上面的配置，Spring容器将使用JavaBean PropertyEditor把
idref元素
idref元素用来将容器内其它bean的id传给
<bean id="theTargetBean" class="..."/>
<bean id="theClientBean" class="...">
<property name="targetName">
<idref bean="theTargetBean" />
</property>
</bean>
上述bean定义片段完全地等同于（在运行时）以下的片段：
<bean id="theTargetBean" class="..." />
<bean id="client" class="...">
<property name="targetName" value="theTargetBean" />
</bean>
第一种形式比第二种更可取的主要原因是，使用idref标记允许容器在部署时 验证所被引用的bean是否存在。而第二种方式中，传给client bean的targetName属性值并没有被验证。任何的输入错误仅在client bean实际实例化时才会被发现（可能伴随着致命的错误）。如果client bean 是prototype类型的bean，则此输入错误（及由此导致的异常）可能在容器部署很久以后才会被发现。
此外，如果被引用的bean在同一XML文件内，且bean名字就是bean id，那么可以使用local属性，此属性允许XML解析器在解析XML文件时对引用的bean进行验证。
<property name="targetName">
<idref local="theTargetBean"/>
</property>
引用其它的bean（协作者）
在
第一种形式也是最常见的形式是通过使用标记指定bean属性的目标bean，通过该标签可以引用同一容器或父容器内的任何bean（无论是否在同一XML文件中）。XML 'bean'元素的值既可以是指定bean的id值也可以是其name值。
<ref bean="someBean"/>
第二种形式是使用ref的local属性指定目标bean，它可以利用XML解析器来验证所引用的bean是否存在同一文件中。local属性值必须是目标bean的id属性值。如果在同一配置文件中没有找到引用的bean，XML解析器将抛出一个例外。如果目标bean是在同一文件内，使用local方式就是最好的选择（为了尽早地发现错误）。
<ref local="someBean"/>
第三种方式是通过使用ref的parent属性来引用当前容器的父容器中的bean。parent属性值既可以是目标bean的id值，也可以是name属性值。而且目标bean必须在当前容器的父容器中。使用parent属性的主要用途是为了用某个与父容器中的bean同名的代理来包装父容器中的一个bean(例如，子上下文中的一个bean定义覆盖了他的父bean)。
<!-- in the parent context -->
<bean id="accountService" class="com.foo.SimpleAccountService">
</bean>
<!-- in the child (descendant) context -->
<bean id="accountService" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target">
<ref parent="accountService"/>
</property>
</bean>
内部bean
所谓的内部bean（inner bean）是指在一个bean的
<bean id="outer" class="...">
<property name="target">
<bean class="com.example.Person">
<property name="name" value="Fiona Apple"/>
<property name="age" value="25"/>
</bean>
</property>
</bean>
注意：内部bean中的scope标记及id或name属性将被忽略。内部bean总是匿名的且它们总是prototype模式的。同时将内部bean注入到包含该内部bean之外的bean是不可能的。
集合（重点）
通过<list/>、<set/>、<map/>及<props/>元素可以定义和设置与Java Collection类型对应List、Set、Map及Properties的值。
<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>
<value>an entry</value>
</key>
<value>just some string</value>
</entry>
<entry>
<key>
<value>a ref</value>
</key>
<ref bean="myDataSource" />
</entry>
</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>
map的key或value值，或set的value值还可以是以下元素：
bean | ref | idref | list | set | map | props | value | null
注入值（基本、集合）
注入基本类型的值、注入集合类型的值
<bean id="eb" class="basic.ExampleBean">
<property name="name" value="C罗"/>
<property name="age" value="22"/>
<property name="cities">
<list>
<value>北京</value>
<value>岳阳</value>
<value>长沙</value>
<!-- 允许重复元素 -->
<value>长沙</value>
</list>
</property>
<property name="interest">
<set>
<value>钓鱼</value>
<value>做饭</value>
<value>编程</value>
<!-- 不允许重复元素 -->
<value>编程</value>
</set>
</property>
<property name="score">
<map>
<entry key="english" value="59.5"/>
<entry key="math" value="69.5"/>
</map>
</property>
<property name="db">
<props>
<prop key="username">Tom</prop>
<prop key="password">1234</prop>
</props>
</property>
</bean>
将集合类型的值当做一个bean来配置。命名空间(namespace):为了区分同名元素而在
<util:list id="citiesBean">
<value>北京</value>
<value>武汉</value>
<value>济南</value>
</util:list>
<util:set id="interestBean">
<value>台球</value>
<value>钓鱼</value>
<value>做饭</value>
</util:set>
<util:map id="scoreBean">
<entry key="english" value="80"/>
<entry key="math" value="90"/>
</util:map>
<util:properties id="dbBean">
<prop key="username">Tom</prop>
<prop key="password">1234</prop>
</util:properties>
<bean id="eb2" class="basic.ExampleBean">
<property name="cities" ref="citiesBean"/>
<property name="interest" ref="interestBean"/>
<property name="score" ref="scoreBean"/>
<property name="db" ref="dbBean"/>
</bean>
<!--
读取location指定位置的文件的内容。
classpath:是spring框架内部的约定。
-->
<util:properties id="config"
location="classpath:config.properties"/>
集合的合并
Spring IoC容器支持集合的合并。这样我们可以定义parent-style和child-style的、
注意，关于合并的这部分利用了parent-child bean机制。
<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>
在上面的例子中，childbean的adminEmails属性的
administrator=administrator@example.com
sales=sales@example.com
support=support@example.co.uk
子bean的Properties集合将从父
XML配置文件的简写及其他
配置元数据冗长不是什么好事情，因此我们将通过下面的方式来对配置进行“减肥”，第一种做法就是通过使用<property/>来定义值和对其他bean的引用，另一个做法就是采用不同的属性定义格式。
基于XML配置元数据
<property/>、<constructor-arg/>及<entry/>元素都支持value属性（attribute），它可以用来替代内嵌的<value/>元素。
<property name="myProperty">
<value>hello</value>
</property>
<constructor-arg>
<value>hello</value>
</constructor-arg>
<entry key="myKey">
<value>hello</value>
</entry>
```
等同于：
```
<property name="myProperty" value="hello"/>
```
```
<constructor-arg value="hello"/>
```
```
<entry key="myKey" value="hello"/>
```
**<property/>和<constructor-arg/>**支持类似ref的简写属性，它可用来替代整个内嵌的<ref/>元素。因而，以下的代码：
```
<property name="myProperty">
<ref bean="myBean">
</property>
```
```
<constructor-arg>
<ref bean="myBean">
</constructor-arg>
```
等同于：
```
<property name="myProperty" ref="myBean"/>
```
```
<constructor-arg ref="myBean"/>
```
注意，尽管存在等同于**<ref bean="xxx">** 元素的简写形式，但并**没有<ref local="xxx">**的简写形式，为了对当前xml中bean的引用，你只能使用完整的形式。
最后，map中entry元素的简写形式为**key/key-ref** 和 **value /value-ref**属性，因而，以下的代码：
```
<entry>
<key>
<ref bean="myKeyBean" />
</key>
<ref bean="myValueBean" />
</entry>
```
等同于：
```
<entry key-ref="myKeyBean" value-ref="myValueBean"/>
```
### 使用p名称空间配置属性 ###
事实上，我们所看到的所有bean的配置格式都是基于一个 **XML Schema**文档。
特定的名称空间并不需要定义在一个XSD文件中，它只在**Spring内核中**存在。我们所说的**p名称空间**就是这样，它不需要一个schema定义，与我们前面采用<property/>元素定义bean的属性不同的是，当我们采用了p名称空间，我们就可以**在bean元素中使用属性（attribute）来描述**bean的property值。
下面的两段XML配置文件中都是用来定义同一个bean：一个采用的是标准的XML格式，一个是采用p名称空间。
```
<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-2.5.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>
```
从上面的bean定义中，我们采用p名称空间的方式包含了一个叫email的属性，而Spring会知道我们的bean包含了一个属性（property）定义。我们前面说了，p名称空间是**不需要schema**定义的，因此属性**（attribute）的名字就是你bean的property**的名字。
下面的例子包含了两个bean定义，它们都引用了另一个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-2.5.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>
```
上面的例子不仅使用p名称空间包含了一个属性（property）值，而且使用了一个特殊的格式声明了一个属性引用。在第一个bean定义中使用了**<property name="spouse" ref="jane"/>**来建立beanjohn到beanjane的引用，而第二个bean定义则采用**p:spouse-ref="jane**"属性（attribute）的方式达到了同样的目的。在这个例子中，"**spouse"是属性（property）名，而"-ref“则用来说明该属性不是一个具体的值而是对另外一个bean的引用。**
### depends-on ###
**depends-on属性可以用于当前bean初始化之前显式地强制一个或多个bean被初始化**。下面的例子中使用了depends-on属性来指定一个bean的依赖。
```
<bean id="beanOne" class="ExampleBean" depends-on="manager"/>
<bean id="manager" class="ManagerBean" />
```
若需要**表达对多个bean的依赖**，可以在'depends-on'中将指定的多个bean名字用分隔符进行分隔，分隔符可以是逗号、空格及分号等。下面的例子中使用了'depends-on'来表达对多个bean的依赖。
```
<bean id="beanOne" class="ExampleBean" depends-on="manager,accountDao">
<property name="manager" ref="manager" />
</bean>
<bean id="manager" class="ManagerBean" />
<bean id="accountDao" class="x.y.jdbc.JdbcAccountDao" />
```
**注意**
“depends-on”属性不仅用来**指定初始化时的依赖**，同时也用来**指定相应的销毁时的依赖**（该依赖只针对singletonbean）。depends-on属性中指定的依赖bean会**在相关bean销毁之前被销毁**，从而可以让用户控制销毁顺序。
## 延迟初始化bean ##
** 默认情况下，容器启动之后，会将所用作用域为
singleton的bean创建好。
可以设置lazy-init属性为true，表示延迟加载**
ApplicationContext实现的默认行为就是在**启动时将所有singleton bean提前进行实例化**。提前实例化意味着作为初始化过程的一部分，ApplicationContext实例会创建并配置所有的singleton bean。通常情况下这是件好事，因为这样在配置中的任何错误就会即刻被发现（否则的话可能要花几个小时甚至几天）。
有时候这种默认处理可能并不是你想要的。如果你不想让一个singleton bean在ApplicationContext初始化时被提前实例化，那么可以将bean设置为延迟实例化。一个延迟初始化bean将告诉IoC 容器是在启动时还是在第一次被用到时实例化。
在XML配置文件中，延迟初始化将通过<bean/>元素中的**lazy-init属性**来进行控制。例如：
```
<bean id="lazy" class="com.foo.ExpensiveToCreateBean" lazy-init="true"/>
<bean name="not.lazy" class="com.foo.AnotherBean"/>
```
当ApplicationContext实现加载上述配置时，设置为lazy的bean将不会在ApplicationContext启动时提前被实例化，而not.lazy却会被提前实例化。
需要说明的是，如果一个**bean被设置为延迟初始化**，而另一个**非延迟初始化**的singleton bean**依赖于它**，那么当ApplicationContext提前实例化singleton bean时，它必须也确保所有上述singleton 依赖bean也被预先初始化，当然也包括设置为延迟实例化的bean。因此，如果Ioc容器在启动的时候创建了那些设置为延迟实例化的bean的实例，你也不要觉得奇怪，因为那些延迟初始化的bean可能在配置的某个地方被注入到了一个非延迟初始化singleton bean里面。
在容器层次上通过在<beans/>元素上使用'default-lazy-init'属性来控制延迟初始化也是可能的。如下面的配置：
```
<beans default-lazy-init="true">
<!-- no beans will be pre-instantiated... -->
</beans>
```