空间站

3.2.3.1. 通过构造函数创建beanbean /> <bean />

至于为构造函数提供（可选的）参数，以及对象实例创建后设置实例属性，将会在后面叙述

当你定义一个使用静态工厂方法创建的bean，同时使用class属性指定包含静态工厂方法的类，这个时候需要factory-method属性来指定工厂方法名。Spring调用这个方法（包含一组可选的参数）并返回一个有效的对象，之后这个对象就完全和构造方法创建的对象一样。用户可以使用这样的bean定义在遗留代码中调用静态工厂。

下面是一个bean定义的例子，声明这个bean要通过factory-method指定的方法创建。注意这个bean定义并没有指定返回对象的类型，只指定包含工厂方法的类。在这个例子中，createInstance 必须是static方法 .

<bean
factory-method="createInstance"/>

至于为工厂方法提供（可选的）参数，以及对象实例被工厂方法创建后设置实例属性，将会在后面叙述.

使用一个实例工厂方法（非静态的）创建bean和使用静态工厂方法非常类似，调用一个已存在的bean（这个bean应该是工厂类型）的工厂方法来创建新的bean。

使用这种机制，class属性必须为空，而且factory-bean属性必须指定一个bean的名字，这个bean一定要在当前的bean工厂或者父bean工厂中，并包含工厂方法。 而工厂方法本身仍然要通过factory-method属性设置。

下面是一个例子：

<!-- The factory bean, which contains a method called
createInstance -->
<bean
>
...
</bean>
<!-- The bean to be created via the factory bean -->
<bean
factory-bean="myFactoryBean"
factory-method="createInstance"/>

虽然我们要在后面讨论设置bean的属性，但是这个方法意味着工厂bean本身能够被容器通过依赖注射来管理和配置

• 基于setter的依赖注射，是在调用无参的构造函数或无参的静态工厂方法实例化你的bean之后， 通过调用你的bean上的setter方法实现的。 在BeanFactory中定义的使用基于setter方法的注射依赖的bean是真正的JavaBean。 Spring一般提倡使用基于setter方法的依赖注射，因为很多的构造函数参数将会是笨重的， 尤其在有些属性是可选的情况下。

• 基于构造函数的依赖注射，它是通过调用带有许多参数的构造方法实现的， 每个参数表示一个合作者或者属性。 另外，调用带有特定参数的静态工厂方法来构造bean可以被认为差不多等同的， 接下来的文字会把构造函数的参数看成和静态工厂方法的参数类似。 虽然Spring一般提倡在大多数情况下使用基于setter的依赖注射， 但是Spring还是完全支持基于构造函数的依赖注射， 因为你可能想要在那些只提供多参数构造函数并且没有setter方法的遗留的bean上使用Spring。 另外对于一些比较简单的bean，一些人更喜欢使用构造函数方法以确保bean不会处于错误的状态。

1. BeanFactory通过使用一个描述所有bean的配置被创建和实例化。大多数的Spring用户使用一个支持XML格式配置文件的BeanFactory或ApplicationContext实现。

2. 每一个bean的依赖表现为属性，构造函数参数，或者当用静态工厂方法代替普通构造函数时工厂方法的参数。这些依赖将会在bean真正被创建出来后提供给bean。

3. 每一个属性或者构造函数参数要么是一个要被设置的值的定义，要么是一个指向BeanFactory中其他bean的引用。在ApplicationContext的情况下，这个引用可以指向一个父亲ApplicationContext中bean。

4. 每一个属性或构造函数参数的值，必须能够从（配置文件中）被指定的格式转变为真实类型。缺省情况下，Spring能够把一个字符串格式的值转变为所有内建的类型，比如int, long，String, boolean等等。另外当说到基于XML的BeanFactory实现的时候（包括ApplicationContext实现），它们已经为定义Lists, Maps, Sets和Properties集合类型提供了内在的支持。另外，Spring通过使用JavaBeans的 PropertyEditor定义，能够将字符串值转变为其他任意的类型。（你可以为PropertyEditor提供你自己的PropertyEditor定义从而能够转变你自定义的类型；更多关于PropertyEditors的信息以及如何手工增加自定义的PropertyEditors请参看第 3.9 节bean > <property ><ref bean="anotherExampleBean"/></property> <property ><ref bean="yetAnotherBean"/></property> <property ><value>1</value></property> </bean> <bean /> <bean />

    

    

   public class ExampleBean {
       private AnotherBean beanOne;
       private YetAnotherBean beanTwo;
       private int i;
       public void setBeanOne(AnotherBean beanOne) {
       this.beanOne = beanOne;
       }
       public void setBeanTwo(YetAnotherBean beanTwo) {
       this.beanTwo = beanTwo;
       }
       public void setIntegerProperty(int i) {
       this.i = i;
       }
       }

   正如你所看到的一样，setter方法被声明以符合XML文件中指定的属性。（XML文件中的属性，直接对应着RootBeanDefinition中的PropertyValues对象）

   接着是一个使用IoC type3（基于构造函数的依赖注射）的BeanFactory。下面是XML配置中的一段，指定了构造函数参数以及展示构造函数的代码：

   <bean  >
       <constructor-arg><ref bean="anotherExampleBean"/></constructor-arg>
       <constructor-arg><ref bean="yetAnotherBean"/></constructor-arg>
       <constructor-arg><value>1</value></constructor-arg>
       </bean>
       <bean  />
       <bean  />

    

   public class ExampleBean {
       private AnotherBean beanOne;
       private YetAnotherBean beanTwo;
       private int i;
       public ExampleBean(AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) {
       this.beanOne = anotherBean;
       this.beanTwo = yetAnotherBean;
       this.i = i;bean
       factory-method="createInstance">
       <constructor-arg><ref bean="anotherExampleBean"/></constructor-arg>
       <constructor-arg><ref bean="yetAnotherBean"/></constructor-arg>
       <constructor-arg><value>1</value></constructor-arg>
       </bean>
       <bean  />
       <bean  />

    

   public class ExampleBean {
       ...
       // a private constructor
       private 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.
       public static ExampleBean ExampleBean(AnotherBean anotherBean,
       YetAnotherBean yetAnotherBean, int i) {
       ExampleBean eb = new ExampleBean(...);
       // some other operations
       ...
       return eb;
       }
       }

   需要注意的是：静态工厂方法的参数由 constructor-arg元素提供，这和构造函数的用法是一样的。这些参数是可选的。重要的一点是工厂方法所返回的对象类型不一定和包含这个静态工厂方法的类一致，虽然上面这个例子中是一样的。前面所提到的实例工厂方法（non-static）用法基本上是一样的（除了使用factory-bean属性代替class属性），在这里就不再详细叙述了。 .

正如前面提到的那样，bean的属性和构造函数参数可以被定义为其他bean的引用（合作者），或者内联定义的值。为了达到这个目的，XmlBeanFactory在property和constructor-arg元素中支持许多子元素类型。

value元素用适合人读的字符串形式指定属性或构造函数参数。正如前面提到的那样，JavaBeans的PropertyEditors被用来将这些字符串从java.lang.String类型转变为真实的属性类型或参数类型。

<beans>
<bean   destroy-method="close">
<!-- results in a setDriverClassName(String) call -->
<property >
<value>com.mysql.jdbc.Driver</value>
</property>
<property >
<value>jdbc:mysql://localhost:3306/mydb</value>
</property>
<property >
<value>root</value>
</property>
</bean>
</beans>bean >
<property ><value></value></property>
</bean>        

导致email属性被设置为””，同java代码：exampleBean.setEmail("")等价。而专门的<null>元素则可以用来指定一个null值，所以

<bean >
<property ><null/></property>
</bean>        

同代码：exampleBean.setEmail(null)是等价的.

list, set, map, 以及 props 元素可以用来定义和设置类型 为Java的List,Set, Map, 和 Properties .

<beans>
...
<bean  >
<!-- results in a setPeople(java.util.Properties) call -->
<property >
<props>
<prop key="HarryPotter">The magic property</prop>
<prop key="JerrySeinfeld">The funny property</prop>
</props>
</property>
<!-- results in a setSomeList(java.util.List) call -->
<property >
<list>
<value>a list element followed by a reference</value>
<ref bean="myDataSource"/>
</list>
</property>
<!-- results in a setSomeMap(java.util.Map) call -->
<property >
<map>
<entry key="yup an entry">
<value>just some string</value>
</entry>
<entry key="yup a ref">
<ref bean="myDataSource"/>
</entry>
</map>
</property>
<!-- results in a setSomeSet(java.util.Set) call -->
<property >
<set>
<value>just some string</value>
<ref bean="myDataSource"/>
</set>
</property>
</bean>
</beans>

注意：Map的entry或set的value，它们的值又可以是下面元素中的任何一个：

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

在property 元素中定义的bean元素用来定义一个内联的bean，而不是引用BeanFactory其他地方定义的bean。内联bean定义不需要任何id定义

<bean  >
<!-- Instead of using a reference to target, just use an inner bean -->
<property >
<bean >
<property ><value>Tony</value></property>
<property ><value>51</value></property>
</bean>
</property>
</bean>

idref元素完全是一种简写和防止错误的方式，用来设置属性值为容器中其他bean的id 或name。

<bean  >
</bean>
<bean  >
<property >
<idref bean="theTargetBean"/>
</property>
</bean>

第一种形式比第二种形式更好的原因是：使用idref标记将会使Spring在部署的时候就验证其他的bean是否真正存在；在第二种形式中，targetName属性的类仅仅在Spring实例化这个类的时候做它自己的验证，这很可能在容器真正部署完很久之后。

另外，如果被引用的bean在同一个xml文件中而且bean的名称是bean的 id，那么就可以使用local属性。它会让XML解析器更早，在XML文档解析的时候，验证bean的名称。

    <property >
<idref local="theTargetBean"/>
</property>

ref元素是最后一个能在property元素中使用的元素。它是用来设置属性值引用容器管理的其他bean（可以叫做合作者）。正如前一节提到的，拥有这些属性的bean依赖被引用的bean，被引用的bean将会在属性设置前，必要的时候需要时初始化（如果是一个singleton bean可能已经被容器初始化）。所有的引用根本上是一个指向其他对象的引用，不过有3种形式指定被引用对象的id/name，这3种不同形式决定作用域和如何处理验证。

用ref元素的bean属性指定目标bean是最常见的形式，它允许指向的bean可以在同一个BeanFactory/ApplicationContext（无论是否在同一个XML文件中）中，也可以在父BeanFactory/ApplicationContext中。bean属性的值可以同目标bean的id属性相同，也可以同目标bean的name属性中任何一个值相同。

    <ref bean="someBean"/>

用local属性指定目标bean可以利用XML解析器的能力在同一个文件中验证XML id引用。local属性的值必须与目标bean的id属性一致。如果在同一个文件中没有匹配的元素，XML解析器将会产生一个错误。因此，如果目标bean在同一个XML文件中，那么使用local形式将是最好的选择（为了能够尽可能早的发现错误）。

    <ref local="someBean"/>

用parent属性指定目标bean允许引用当前BeanFactory（ApplicationContext）的父BeanFactory(ApplicationContext)中的bean。parent属性的值可以同目标bean的id属性相同，也可以同目标bean的name属性中的一个值相同，而且目标bean必须在当前BeanFactory（ApplicationContext）的父BeanFactory（ApplicationContext）中。当需要用某种proxy包装一个父上下文中存在的bean（可能和父上下文中的有同样的name），所以需要原始的对象用来包装它。

    <ref parent="someBean"/>

对于大部分的用户来说，容器中多数的bean是singleton的。当一个singleton的bean需要同另一个singleton的 bean合作（使用）时，或者一个非singleton的bean需要同另一个非singleton的bean合作的时候，通过定义一个bean为另一个bean的属性来处理这种依赖的关系就足够了。然而当bean的生命周期不同的时候就有一个问题。想想一下一个singleton bean A，或许在每次方法调用的时候都需要使用一个non-singleton bean B。容器仅仅会创建这个singleton bean A一次，因此仅仅有一次的机会去设置它的属性。因此容器没有机会每次去为bean A提供新的bean B的实例。

一个解决这个问题的方法是放弃一些反向控制。Bean A可以通过实现 BeanFactoryAware知道容器的存在（参见这里)），使用编程的手段（参见这里）在需要的时候通过调用getBean("B")来向容器请求新的bean B实例。 因为bean的代码知道Spring并且耦合于Spring，所以这通常不是一个好的方案。

方法注入，BeanFactory的高级特性之一，可以以清洁的方式处理这种情况以及其他一些情况。

<!-- a stateful bean deployed as a protype (non-singleton) -->
<bean  singleton="false">
</bean>
<!-- myBean uses singleShotHelper -->
<bean  >
<lookup-method
bean="singleShotHelper"/>
<property>
...
</property>
</bean>

...
public class MyValueCalculator {
public String computeValue(String input) {
... some real code
}
... some other methods
}

/** meant to be used to override the existing computeValue
implementation in MyValueCalculator */
public class 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 ...;bean >
<!-- arbitrary method replacement -->
<replaced-method  replacer="replacementComputeValue">
<arg-type>String</arg-type>
</replaced-method>
</bean>
<bean  >
</bean>

    java.lang.String
String
Str