Spring IoC 容易管理一个或者多个 bean。 bean 由你提供给容器的配置元数据创建,例如,在 XML 中的<bean/> 定义。

容器内部,这些 bean 定义表示为 BeanDefinition 对象,其中包含(其他信息)以下元数据:

• 限定包类名称:作为已经被定义bean的实际实现的代表。
• bean 行为配置元素,定义了容器中的Bean应该如何行为(范围、生命周期回调,等等)。
• bean 需要引用其他 bean 来完成工作,这些引用也称为合作者或依赖关系。
• 其他配置设置来设置新创建的对象,例如,连接使用 bean 的数量管理连接池,或者池的大小限制。

以下是每个 bean 定义的属性。

Table 6.1. The bean definition

除 bean 定义里包含的如何创建一个特定的bean的信息, ApplicationContext 的实现还允许由用户注册现有创建在容器之外的对象。这是通过访问 ApplicationContext 的 BeanFactory 的 getBeanFactory() 方法 返回 BeanFactory 的实现 DefaultListableBeanFactory 。DefaultListableBeanFactory 支持这种通过 registerSingleton(..) 和registerBeanDefinition(..) 方法来注册。然而,典型的应用程序只能通过元数据定义的 bean 来定义。

bean 定义基本上就是用来创建一个或多个对象的配置，当需要一个 bean 的时候，容器查看配置并且根据 bean 定义封装的配置元数据创建（或获取）一个实际的对象。

如果你使用基于 XML 的配置，你可以在<bean/>元素通过 class 属性来指定对象的类型。这个 class 属性，实际上是 BeanDefinition 实例中的一个 Class 属性。这个 class 属性通常是必须的（例外情况，查看“使用实例工厂方法实例化” 章节和 Section 6.7, “Bean定义的继承”），使用 Class 属性的两种方式：

• 通常情况下，直接通过反射调用构造方法来创建 bean，和在 Java 代码中使用 new 有点像。
• 通过静态工厂方法创建，类中包含静态方法。通过调用静态方法返回对象的类型可能和 Class 一样，也可能完全不一样。

内部类名。如果你想配置使用静态的内部类，你必须用内部类的二进制名称。例如，在 com.example 包下有个 Foo 类，这里类里面有个静态的内部类Bar，这种情况下bean定义的class属性应该…com.example.Foo$Bar 注意，使用$字符来分割外部类和内部类的名称。

通过构造函数实例化

当你使用构造方法来创建 bean 的时候，Spring 对类来说并没有什么特殊。也就是说，正在开发的类不需要实现任何特定的接口或者以特定的方式进行编码。但是，根据你使用那种类型的 IoC 来指定 bean，你可能需要一个默认（无参）的构造方法。

Spring IoC 容器可以管理几乎所有你想让它管理的类，它不限于管理POJO。大多数 Spring 用户更喜欢使用 POJO（一个默认无参的构造方法和setter,getter方法）。但在容器中使用非 bean 形式(non-bean style)的类也是可以的。比如遗留系统中的连接池，很显然它与 JavaBean规范不符，但 Spring 也能管理它。

当使用基于XML的元数据配置文件，可以这样来指定 bean 类：

<bean id="exampleBean" class="examples.ExampleBean"/>

<bean name="anotherExample" class="examples.ExampleBeanTwo"/>

给构造方法指定参数以及为bean实例化设置属性将在后面的依赖注入中详细说明。

使用静态工厂方法实例化

当采用静态工厂方法创建 bean 时，除了需要指定 class 属性外，还需要通过 factory-method 属性来指定创建 bean 实例的工厂方法。Spring将调用此方法(其可选参数接下来介绍)返回实例对象，就此而言，跟通过普通构造器创建类实例没什么两样。

下面的 bean 定义展示了如何通过工厂方法来创建bean实例。注意，此定义并未指定返回对象的类型，仅指定该类包含的工厂方法。在此例中，createInstance() 必须是一个 static 方法。

<beanid="clientService"class="examples.ClientService"factory-method="createInstance"/>

publicclassClientService{
    privatestatic ClientService clientService = new ClientService();
    privateClientService(){}

    publicstatic ClientService createInstance(){
        return clientService;
    }
}

给工厂方法指定参数以及为bean实例设置属性的详细内容请查阅依赖和配置详解。

与通过 静态工厂方法 实例化类似，通过调用工厂实例的非静态方法进行实例化。 使用这种方式时，class属性置为空，而factory-bean属性必须指定为当前(或其祖先)容器中包含工厂方法的bean的名称，而该工厂bean的工厂方法本身必须通过factory-method属性来设定。

<!-- 工厂bean，包含createInstance()方法 --><beanid="serviceLocator"class="examples.DefaultServiceLocator"><!-- 其他需要注入的依赖项 --></bean><!-- 通过工厂bean创建的ben --><beanid="clientService"factory-bean="serviceLocator"factory-method="createClientServiceInstance"/>

publicclassDefaultServiceLocator{

    privatestatic ClientService clientService = new ClientServiceImpl();
    privateDefaultServiceLocator(){}

    public ClientService createClientServiceInstance(){
        return clientService;
    }
}

一个工厂类也可以有多个工厂方法，如下代码所示：

<beanid="serviceLocator"class="examples.DefaultServiceLocator"><!-- 其他需要注入的依赖项 --></bean><beanid="clientService"factory-bean="serviceLocator"factory-method="createClientServiceInstance"/><beanid="accountService"factory-bean="serviceLocator"factory-method="createAccountServiceInstance"/>

publicclassDefaultServiceLocator{

    privatestatic ClientService clientService = new ClientServiceImpl();
    privatestatic AccountService accountService = new AccountServiceImpl();

    privateDefaultServiceLocator(){}

    public ClientService createClientServiceInstance(){
        return clientService;
    }

    public AccountService createAccountServiceInstance(){
        return accountService;
    }

}

这种做法表明工厂bean本身也可以通过依赖注入（DI）进行管理配置。查看依赖和配置详解。

在Spring文档中，factory bean是指在Spring容器中配置的工厂类通过 实例 或 静态 工厂方法来创建对象。相比而言, FactoryBean (注意大小写) 代表了Spring中特定的 FactoryBean

publicclass SimpleMovieLister {

    // the SimpleMovieLister has a dependency on a MovieFinderprivate MovieFinder movieFinder;

    // a constructor so that the Spring container can inject a MovieFinderpublic SimpleMovieLister(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }

    // business logic that actually uses the injected MovieFinder is omitted...

}

package x.y;

publicclass Foo {

    public Foo(Bar bar, Baz baz) {
        // ...
    }

}

<beans><beanid="foo"class="x.y.Foo"><constructor-argref="bar"/><constructor-argref="baz"/></bean><beanid="bar"class="x.y.Bar"/><beanid="baz"class="x.y.Baz"/></beans>

package examples;

publicclass ExampleBean {

    // Number of years to calculate the Ultimate Answerprivateint years;

    // The Answer to Life, the Universe, and Everythingprivate String ultimateAnswer;

    public ExampleBean(int years, String ultimateAnswer) {
        this.years = years;
        this.ultimateAnswer = ultimateAnswer;
    }

}

<beanid="exampleBean"class="examples.ExampleBean"><constructor-argtype="int"value="7500000"/><constructor-argtype="java.lang.String"value="42"/></bean>

<beanid="exampleBean"class="examples.ExampleBean"><constructor-argindex="0"value="7500000"/><constructor-argindex="1"value="42"/></bean>

<beanid="exampleBean"class="examples.ExampleBean"><constructor-argname="years"value="7500000"/><constructor-argname="ultimateAnswer"value="42"/></bean>

package examples;

publicclass ExampleBean {

    // Fields omitted@ConstructorProperties({"years", "ultimateAnswer"})public ExampleBean(int years, String ultimateAnswer) {
        this.years = years;
        this.ultimateAnswer = ultimateAnswer;
    }

}

• ApplicationContext 类被创建并初始化描述所有Bean的元数据配置。元数据配置是通过XML，JAVA代码，或者是生命来指定的。
• 对于每一个Bean，他的依赖都会以属性的形式、构造参数的形式、或者是静态工厂方法的方式（如果你用静态工厂方法代替默认构造函数）被表达。当Bean被创建的时候，这些依赖就会提供给Bean。
• 每一个属性或者构造参数都是一个实际要被设置值的定义，或者是容器中另一个Bean的引用。
• 每一个属性或者是构造参数的值都会被转换为一个构造参数或者是属性的实际类型，默认情况下，Spring可以把一个字符串值转换为任何的基础类型，像int，long，String，boolean等等。

<beanid="exampleBean"class="examples.ExampleBean"><!-- setter injection using the nested ref element --><propertyname="beanOne"><refbean="anotherExampleBean"/></property><!-- setter injection using the neater ref attribute --><propertyname="beanTwo"ref="yetAnotherBean"/><propertyname="integerProperty"value="1"/></bean><beanid="anotherExampleBean"class="examples.AnotherBean"/><beanid="yetAnotherBean"class="examples.YetAnotherBean"/>

publicclass ExampleBean {

    private AnotherBean beanOne;
    private YetAnotherBean beanTwo;
    privateint i;

    publicvoid setBeanOne(AnotherBean beanOne) {
        this.beanOne = beanOne;
    }

    publicvoid setBeanTwo(YetAnotherBean beanTwo) {
        this.beanTwo = beanTwo;
    }

    publicvoid setIntegerProperty(int i) {
        this.i = i;
    }

}

<beanid="exampleBean"class="examples.ExampleBean"><!-- constructor injection using the nested ref element --><constructor-arg><refbean="anotherExampleBean"/></constructor-arg><!-- constructor injection using the neater ref attribute --><constructor-argref="yetAnotherBean"/><constructor-argtype="int"value="1"/></bean><beanid="anotherExampleBean"class="examples.AnotherBean"/><beanid="yetAnotherBean"class="examples.YetAnotherBean"/>

publicclass ExampleBean {

    private AnotherBean beanOne;
    private YetAnotherBean beanTwo;
    privateint i;

    public ExampleBean(
        AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) {
        this.beanOne = anotherBean;
        this.beanTwo = yetAnotherBean;
        this.i = i;
    }

}

<beanid="exampleBean"class="examples.ExampleBean"factory-method="createInstance"><constructor-argref="anotherExampleBean"/><constructor-argref="yetAnotherBean"/><constructor-argvalue="1"/></bean><beanid="anotherExampleBean"class="examples.AnotherBean"/><beanid="yetAnotherBean"class="examples.YetAnotherBean"/>

publicclass ExampleBean {

    // a private constructorprivate ExampleBean(...) {
        ...
    }

    // a static factory method; the arguments to this method can be// considered the dependencies of the bean that is returned,// regardless of how those arguments are actually used.publicstatic ExampleBean createInstance (
        AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) {

        ExampleBean eb = new ExampleBean (...);
        // some other operations...return eb;
    }

}

直接的值（基础类型，String等等）

<beanid="myDataSource"class="org.apache.commons.dbcp.BasicDataSource"destroy-method="close"><!-- results in a setDriverClassName(String) call --><propertyname="driverClassName"value="com.mysql.jdbc.Driver"/><propertyname="url"value="jdbc:mysql://localhost:3306/mydb"/><propertyname="username"value="root"/><propertyname="password"value="masterkaoli"/></bean>

<beansxmlns="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"><beanid="myDataSource"class="org.apache.commons.dbcp.BasicDataSource"destroy-method="close"p:driverClassName="com.mysql.jdbc.Driver"p:url="jdbc:mysql://localhost:3306/mydb"p:username="root"p:password="masterkaoli"/></beans>

<beanid="mappings"class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><!-- typed as a java.util.Properties --><propertyname="properties"><value>
            jdbc.driver.className=com.mysql.jdbc.Driver
            jdbc.url=jdbc:mysql://localhost:3306/mydb
        </value></property></bean>

<beanid="theTargetBean"class="..."/><beanid="theClientBean"class="..."><propertyname="targetName"><idrefbean="theTargetBean" /></property></bean>

<beanid="theTargetBean"class="..." /><beanid="client"class="..."><propertyname="targetName"value="theTargetBean" /></bean>

	local 标签的idref 在4.0版本中不再被支持， 因为它不再支持提冲常规bean引用的值。当更新到4.0版本后，简单把你的idref local改为idref bean就行

<idref/> 元素的值 是在AOP的配置拦截器ProxyFactoryBean bean定义的。当你指定一个拦截器的名字校验拦截器ID拼写错误时，使用<idref/>元素。

其他Bean的引用（协作的bean）

<refbean="someBean"/>

<!-- in the parent context --><beanid="accountService"class="com.foo.SimpleAccountService"><!-- insert dependencies as required as here --></bean>

<!-- in the child (descendant) context --><beanid="accountService"<!--beannameisthesameastheparentbean-->class="org.springframework.aop.framework.ProxyFactoryBean"><propertyname="target"><refparent="accountService"/><!-- notice how we refer to the parent bean --></property><!-- insert other configuration and dependencies as required here --></bean>

	local 标签的idref 在4.0版本中不再被支持， 因为它不再支持提冲常规bean引用的值。当更新到4.0版本后，简单把你的idref local改为idref bean就行

内部bean

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

集合

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

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

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

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

集合合并的限制

你不能合并不同的集合类型（例如一个 Map  和一个 List合并），如果你尝试那么做就会抛出异常。 merge  属性必须在低层次的，继承的，子集合中定义。在父集合中设置 merge 属性是多余的并且不会获得想要的合并结果。

强类型集合

随着JAVA5推出了泛型，你可以使用强类型集合。这就使声明一个只包含String类型的集合成为可能。如果你用Spring给一个bean依赖注入一个强类型集合，你可以借助Spring的类型转换支持，那样你的强类型结合实例的元素就会在加入集合之前被转换为合适的类型。

publicclass Foo {

    private Map<String, Float> accounts;

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

<beans><beanid="foo"class="x.y.Foo"><propertyname="accounts"><map><entrykey="one"value="9.99"/><entrykey="two"value="2.75"/><entrykey="six"value="3.99"/></map></property></bean></beans>

当 foo  的 accounts  属性准备被注入的时候，强类型 Map<String, Float>元素类型的泛型信息就会通过反射生效。这样Spring类型转换结构会把各种值元素认为是 Float类型，把String值 9.99, 2.75和 3.99转换成真正的 Float  类型。

Null和空字符串

Spring把属性或相似空参数市委空字符串。下面基于XML配置文件片段把email属性设置为空的字符串（""）。

<beanclass="ExampleBean"><propertyname="email"value=""/></bean>

上面的例子和下面的JAVA代码是相同的：

exampleBean.setEmail("")

<null/>元素代表 null值。例如：

<beanclass="ExampleBean"><propertyname="email"><null/></property></bean>

上面的配置和下面的JAVA代码是相同的：

exampleBean.setEmail(null)

用p-namespace简写XML

p-namespace允许你使用bean元素的属性来代替嵌套的<property/> 元素，来描述你属性的值或者是依赖的bean。

Spring支持命名空间的可扩展的配置格式，此拓展的格式是基于XML模式定义的、这章讨论的bean的配置格式是被定义在XML模式文档中的。但是，p-namespace没有被定义在XSD文件中而是仅仅存在Spring核心模块中。

下面的的例子展示的两个XML片段产生相同的结果：第一个用标准的XML格式，第二个用p-namespace。

<beansxmlns="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"><beanname="classic"class="com.example.ExampleBean"><propertyname="email"value="foo@bar.com"/></bean><beanname="p-namespace"class="com.example.ExampleBean"p:email="foo@bar.com"/></beans>

例子展示了一个在bean定义中用p-namespace定义的email属性。这告诉Spring包含一个属性声明。正如前面提到的，p-namespace不需要有一个模式定义，你可以把标签的名字设置为属性名。

下面展示了两个更多的例子，这两个的bean都有对方的引用：

<beansxmlns="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"><beanname="john-classic"class="com.example.Person"><propertyname="name"value="John Doe"/><propertyname="spouse"ref="jane"/></bean><beanname="john-modern"class="com.example.Person"p:name="John Doe"p:spouse-ref="jane"/><beanname="jane"class="com.example.Person"><propertyname="name"value="Jane Doe"/></bean></beans>

正如你看到的，这个例子不仅包含一个用p-namespace定义的属性值，还用一个特殊的格式声明了一个属性的引用。第一个bean用<property name="spouse" ref="jane"/>创建了john对jane的引用，对二个例子用p:spouse-ref="jane"做了同样的事。在这个例子中，spouse 是一个属性名，-ref 代表这不是一个直接的值而是对另一个bean的引用。

	p-namespace不像标准的XML格式那样灵活。例如，对于结尾是ref的属性就会和证明属性引用的格式冲突，这种情况不会再XML标准格式上发生。我们建议谨慎选择你的方式，并且和你的团队成员沟通好，来避免在配置XML文档时同时使用三种方式。

用c-namespace简写XML

和p-namespace简写相似，c-namespace是spring3.1引进的，允许使用内部属性的方式来配置构造参数而不是嵌套的constructor-arg元素。

让我们来看下面这个用c-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>

c:命名空间和 p:用相同的命名方式（结尾 -ref代表bean的引用）来通过他们的名字设置构造参数。它也不是通过XSD模式定义的（而是存在Spring核心模块中）。

对于上面的例子构造参数名字不可用的时（通常如果二进制代码没有编译时没有Debug信息），可以使用参数索引的方式：

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

	由于XML语法的因素，索引符号需要_的存在，因为属性不成不能以数字开头（即使有一些IDE支持）

复合属性名称

当你设置一个bean的属性时你可以使用复合或者嵌套的属性名，只要除了最后的属性名其他的组件路径不为空。考虑下面的bean定义：

<beanid="foo"class="foo.Bar"><propertyname="fred.bob.sammy"value="123" /></bean>

bean  foo  下面有一个 fred  属性， fred  下面有一个 bob  属性， bob  下面有一个 sammy  属性，最终 sammy  被设置为123。为了使这个能工作，必须保证bean被创建以后 foo下的 fred  和 fred  下的 bob  不为空，要不就会抛出空指针异常 NullPointerException  。

使用depends-on

如果一个bean是另一个的依赖，通常意味着一个bean被设置为另一个bean的属性。通常情况下你通过XML配置文件的   <ref/> 标签来完成配置。但是，有些时候bean之间的依赖没有那么直接。例如，一个类中静态初始化器需要被触发，比如数据库驱动注册。 depends-on属性可以明确的强制一个或多个bean在被用到需要初始化之前被初始化。下面的例子展示用 depends-on属性来表达一个单例的依赖。

<beanid="beanOne"class="ExampleBean"depends-on="manager"/><beanid="manager"class="ManagerBean" />

通过提供一个bean名称的列表作为depend-on的值，用逗号，空格或者分号作为一个可用的分隔符，来表达对多个bean的依赖。

<beanid="beanOne"class="ExampleBean"depends-on="manager,accountDao"><propertyname="manager"ref="manager" /></bean><beanid="manager"class="ManagerBean" /><beanid="accountDao"class="x.y.jdbc.JdbcAccountDao" />

	Bean中的depends-on属性不仅可以指定初始化时间的依赖，并且仅仅对于单例范围的bean的情况，还可以指定一个相应的销毁时间的依赖。depends-on指定的依赖关系会在给定的bean被销毁之前被销毁。因此depends-on属性可以控制依赖关系关闭的顺序。

延迟初始化bean

ApplicationContext 默认情况下会立即创建和注册单例范围的bean做为它初始化的一部分。通常情况下这种提前的初始化是可取的，因为在配合和周边环境中的错误可以被及时发现，如果不这样就会在数小时后甚至数天之后才会被发现。当不需要这样做的时候，你可以通过定义bean的延迟加载来阻止单例bean提前初始化。配置为延迟加载的bean告诉IoC容器当他被请求的时候再实例化而不是容器启动的时候。

在XML配置中，这个行为是被 <bean/>元素的 lazy-init属性控制的，例子如下：

<beanid="lazy"class="com.foo.ExpensiveToCreateBean"lazy-init="true"/><beanname="not.lazy"class="com.foo.AnotherBean"/>

当前面的配置被 ApplicationContext执行，名字是 lazy的bean当 ApplicationContext启动的时候不会立即提前初始化，而名字是 not.lazy的bean会立即执行提前初始化。

但是，当一个延迟初始化的bean是一个单例bean的依赖的时候，就不会延迟初始化了。 ApplicationContext  在启动的时候创建延迟加载的bean，因为它必须满足单例的依赖关系。延迟初始化的bean被注入答单例bean里，这里他就不会延迟加载。

你可以用 default-lazy-init属性控制容器延迟初始化的等级；例如：

<beansdefault-lazy-init="true"><!-- no beans will be pre-instantiated... --></beans>

自动装配

Spring容器可以自动装配各协作bean之间的关系。你可以允许Spring通过检查ApplicationContext的上下文来为你的bean自动处理协作关系。自动装配有如下优势：

• 自动装配可以大量减少指定属性或者构造参数的需要。（其他机制例如本章将会讨论到的bean模板技术也会避免这些操作）
• 自动装配可以随着你的对象改变而改变。例如，你需要为类增加一个依赖，在不用更改配置的情况下依赖就可以满足自动装配。因此自动装配在开发期间尤其有用，不需要使显示的写的选项失效可以使代码更稳定。

当用XML配置的时候，你需要用<bean/> 元素的autowire 属性为bean定义指定自动装配模式。自动装配功能有四种模式，你为每个bean指定自动装配，因此你可以选择哪一个进行自动装配。

Table 6.2. 自动装配模式

模式	解释
no	默认不装配。bean引用必须通过ref 元素定义。对于大量的加载更改默认配置是不推荐的，因为显示的指定协作关系可以更好的控制和更清晰。某种程度上，它是系统结构的文档。
byName	通过属性名来自动装配。当属性需要被自动装配时Spring寻找有相同名字的bean来进行装备。例如，如果一个bean的autowiring属性设置为byName，并且它包含一个master变量（也就是他有一个setMaster(...)方法），Spring寻找名字是master的bean，用它为变量赋值。
byType	如果恰好容器中有一个bean的属性类型时，允许变量进行自动装配。如果多于一个时，异常就会抛出，预示着你可能不能把bean的autowiring属性设置为byType。若果没有匹配的类型，什么也不会发生，变量不会被设置。
constructor	类似于byType，但是提供是的构造参数。如果恰好容器中没有bean的构造参数类型，一个错误就会抛出。

你可以通过byType或constructor自动装配模式装配数组和类型集合。在这种情况下，所有的容器中符合预期的自动装配类型都会被提供来满足依赖。如果期望的map的key类型时String你可以自动装配强类型的map。自动装配的map的value会包括所有符合预期类型的实例，并且map的key会包括所有相应bean的名称。

你可以把自动装备和依赖校验合到一起，这样依赖校验会在自动装配完成以后执行。

自动装配的局限和缺点

自动装配当始终用在一个项目上的时候运行时最好的。如果自动装配不这样使用，它可能会使开发者疑惑使用它装配了仅仅一个还是两个bean定义。

考虑下自动装配的局限和缺点：

• 显示的用property 和constructor-arg设置依赖通常会覆盖自动装配。你不能自动装配简单属性，像基础类型，Strings，类（包含简单类型的数组）。设计就是如此。
• 自动装配没有显示装配准确。尽管，正如上面表格提到的，当遇到歧义可能导致预想不到的结果时，Spring很小心的避免猜测。
• 装配信息可对不能用于从Spring容器产生文档的工具。
• 容器中的多个bean定义有可能都符合setter方法和构造参数被自动装配。对于数组，集合或者map，这不是问题。但是对于那些希望单个值的依赖，这个歧义就不能武断的解决了。如果没有唯一的bean定义可用，就会抛出异常。

遇到后者情况，你有几个选择：

• 放弃自动装配选择显示装配
• 避免自动装配时设置bean定义的autowire-candidate属性为false，正如下面一节描述的
• 通过设置<bean/>的primary属性为true，指定一个唯一的bean定义作为主要的候选
• 通过声明的配置来实现一些细微粒度的控制，正如在6.9“基于声明的配置”中描述的

从自动装配剔除指定的bean

在每一个bean的基础上，你都可以从自动装配中剔除。在XML配置中，设置<bean/>的autowire-candidate属性为false。容器就会从自动装配结构上剔除指定的bean（包括用声明配置的bean，例如@Autowired）。

你也可以通过基于模式匹配候选bean的方式来显示bean的名称。最顶层的<beans/>元素在default-autowire-candidates参数中接受一个或多个模式。例如，来剔除那些名字末尾是repository的候选bean，提供一个*repository的值。可以通过逗号分开列表的方式提供多种模式。通过显示指定bean的autowire-candidate属性为true 或false 会被优先处理，对于这些bean，模式匹配上的都不会使用。

这项技术对于你不想把一些bean通过自动注入的方式注入到其他bean的时候会很有用。这并不是意味着被剔除的bean自己不能使用自动装配，而是说这个bean不会被自动装配给其他的bean 。

方法注入

对于大多应用程序场景，大多数容器中的bean都是单例范围的。当一个单例范围的bean需要和另一个单例范围的bean协作的时候，或者一个非单例范围的bean需要和另一个非单例范围的bean协作的，通常你会定义一个bean作为另一个的属性的方式来保持依赖。当bean的声明周期不同时，问题就会产生了。假设一个单例Bean A需要用一个非单例（原型范围）Bean    B，假设A的每一个方法都调用了B。容器只创建单例范围Bean A一次，而且只有一次机会来设置依赖。容器不能每一次在需要B的时候都提供一个Bean B新的实例。

一种方案是放弃一些依赖注入。你可以使Bean A实现 ApplicationContextAware  接口来使A意识到容器的存在，然后通过调用getBean("B")来在每次需要B的时候请求容器产生一个B的实例（通常情况是新的）。下面是这种方法的例子：

// a class that uses a stateful Command-style class to perform some processingpackage fiona.apple;

// Spring-API importsimport org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

publicclass CommandManager implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    public Object process(Map commandState) {
        // grab a new instance of the appropriate Command
        Command command = createCommand();
        // set the state on the (hopefully brand new) Command instance
        command.setState(commandState);
        return command.execute();
    }

    protected Command createCommand() {
        // notice the Spring API dependency!returnthis.applicationContext.getBean("command", Command.class);
    }

    publicvoid setApplicationContext(
            ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

上面的做法实不可取的，应为业务代码意识到了容器的存在并且和Spring容器耦合了。方法注入，一些Spring IoC容器更高级的特征，允许用一种更简洁的方式实现这种情况。

搜索方法注入

搜索方法注入是容器通过重写被容器管理的bean的方法返回一个搜索的容器中另一个命名bean结果的能力。这个搜索通常会涉及到一个原型Bean，正如上一部分的场景中描述的。Spring通过字节码，这些字节码是从CGLIB库动态创建子类用来重写方法，来实现方法的注入。

	为了让这个动态子类工作，将要被Spring容器实现子类的类不能为final，并且将要被重写的方法也不能为final 当对有抽象方法的类进行单元测试时，需要你自己实现子类，并提供抽象方法的直接实现。 组件扫描所需的具体方法也需要具体的类。 一个更关键的限制是，搜索的方法不能和工厂方法一起工作并且不能和配置类里的@Bean方法一起。因为容器在那种情况下不负责创建实例，因此不能在运行期间创建一个子类。 最后对象中作为注入的目标方法不能是序列化的

看下上面片段中的 CommandManager  类，你会看到Spring容器会动态的重写 createCommand()方法的实现。你的 CommandManager  类将不会有任何Spring的依赖，正如下面修改了的例子中看到的：

package fiona.apple;

// no more Spring imports!publicabstractclass CommandManager {

    public Object process(Object commandState) {
        // grab a new instance of the appropriate Command interface
        Command command = createCommand();
        // set the state on the (hopefully brand new) Command instance
        command.setState(commandState);
        return command.execute();
    }

    // okay... but where is the implementation of this method?protectedabstract Command createCommand();
}

客户端类包含的方法被注入了（在这里是 CommandManager  类），要被注入的方法需要下面的格式：

<public|protected> [abstract] <return-type> theMethodName(no-arguments);

如果方法是抽象的，动态产生的子类会实现这个方法。否则，动态产生的子类会重写定义在原始类中实体的方法。例如：

<!-- a stateful bean deployed as a prototype (non-singleton) --><beanid="command"class="fiona.apple.AsyncCommand"scope="prototype"><!-- inject dependencies here as required --></bean><!-- commandProcessor uses statefulCommandHelper --><beanid="commandManager"class="fiona.apple.CommandManager"><lookup-methodname="createCommand"bean="command"/></bean>

Bean定义为当任何时候它需要一个 command  Bean的实例的时候都会调用它自己的 createCommand()方法。你必须小心的把 command  Bean加载为原型范围，就像实际需要的那样。如果加载为单例范围，每次就会返回相同的实例。

	感兴趣的读者可能也发现ServiceLocatorFactoryBean （在包org.springframework.beans.factory.config中）也可以被使用。这个类的用法和另一个使用的类相似，这个类是ObjectFactoryCreatingFactoryBean。但是他允许你指定你自己的搜索接口的方式而不是用Spring指定的所搜接口。更多的信息请参考这些类的javadoc文档

任意方法替换

一个比搜索方法注入更有用的方法注入的形式是通过另一个方法的实现来替换Bean中的任意方法。用户在不需要这些功能的时候可以跳过剩下的部分。

用XML的方式，你可以用 replaced-method属性来吧存在的方法实现替换为另一个方法实现。考虑下面的类，我们想重写下面类的ComputeValue方法：

publicclass MyValueCalculator {

    public String computeValue(String input) {
        // some real code...
    }

    // some other methods...

}

类通过实现 org.springframework.beans.factory.support.MethodReplacer接口提供了一个新的方法定义。

/**
 * meant to be used to override the existing computeValue(String)
 * implementation in MyValueCalculator
 */publicclass ReplacementComputeValue implements MethodReplacer {

    public Object reimplement(Object o, Method m, Object[] args) throws Throwable {
        // get the input value, work with it, and return a computed result
        String input = (String) args[0];
        ...
        return ...;
    }
}

你可以通过使用一个或多个包含在 <replaced-method/>元素里的 <arg-type/>  属性来表明方法的方法签名要被重写。只有当方法是重载的或者类中存在多个变种时参数的签名才是必须的。为了方便，参数的类型字符串可以是参数全名的一个子字符串。例如，下面的都会匹配 java.lang.String。

java.lang.String
String
Str

因为参数的个数通常足够来区分每一个可能的选择，这样缩写可以节省很多输入，通过允许你输入一个简单的字符串来匹配参数类型。