空間站

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知道容器的存在（參見來向容器請求新的bean B實例。 因為bean的代碼知道Spring并且耦合于Spring，所以這通常不是一個好的方案。

<!-- 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