裝配 Bean 的概述

前面已經(jīng)介紹了 Spring IoC 的理念和設(shè)計(jì)，這一篇文章將介紹的是如何將自己開(kāi)發(fā)的 Bean 裝配到 Spring IoC 容器中。

大部分場(chǎng)景下，我們都會(huì)使用 ApplicationContext 的具體實(shí)現(xiàn)類，因?yàn)閷?duì)應(yīng)的 Spring IoC 容器功能相對(duì)強(qiáng)大。

而在 Spring 中提供了 3 種方法進(jìn)行配置：

• 在 XML 文件中顯式配置
• 在 Java 的接口和類中實(shí)現(xiàn)配置
• 隱式 Bean 的發(fā)現(xiàn)機(jī)制和自動(dòng)裝配原則

方式選擇的原則

在現(xiàn)實(shí)的工作中，這 3 種方式都會(huì)被用到，并且在學(xué)習(xí)和工作之中常?；旌鲜褂?，所以這里給出一些關(guān)于這 3 種優(yōu)先級(jí)的建議：

1.最優(yōu)先：通過(guò)隱式 Bean 的發(fā)現(xiàn)機(jī)制和自動(dòng)裝配的原則。
基于約定由于配置的原則，這種方式應(yīng)該是最優(yōu)先的

• 好處： 減少程序開(kāi)發(fā)者的決定權(quán)，簡(jiǎn)單又不失靈活。

2.其次：Java 接口和類中配置實(shí)現(xiàn)配置
在沒(méi)有辦法使用自動(dòng)裝配原則的情況下應(yīng)該優(yōu)先考慮此類方法

• 好處： 避免 XML 配置的泛濫，也更為容易。
• 典型場(chǎng)景： 一個(gè)父類有多個(gè)子類，比如學(xué)生類有兩個(gè)子類，一個(gè)男學(xué)生類和女學(xué)生類，通過(guò) IoC 容器初始化一個(gè)學(xué)生類，容器將無(wú)法知道使用哪個(gè)子類去初始化，這個(gè)時(shí)候可以使用 Java 的注解配置去指定。

3.最后：XML 方式配置
在上述方法都無(wú)法使用的情況下，那么也只能選擇 XML 配置的方式。

• 好處： 簡(jiǎn)單易懂（當(dāng)然，特別是對(duì)于初學(xué)者）
• 典型場(chǎng)景： 當(dāng)使用第三方類的時(shí)候，有些類并不是我們開(kāi)發(fā)的，我們無(wú)法修改里面的代碼，這個(gè)時(shí)候就通過(guò) XML 的方式配置使用了。

通過(guò) XML 配置裝配 Bean

使用 XML 裝配 Bean 需要定義對(duì)應(yīng)的 XML，這里需要引入對(duì)應(yīng)的 XML 模式（XSD）文件，這些文件會(huì)定義配置 Spring Bean 的一些元素，當(dāng)我們?cè)?IDEA 中創(chuàng)建 XML 文件時(shí)，會(huì)有友好的提示：

一個(gè)簡(jiǎn)單的 XML 配置文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

這就只是一個(gè)格式文件，引入了一個(gè) beans 的定義，引入了 xsd 文件，它是一個(gè)根元素，這樣它所定義的元素將可以定義對(duì)應(yīng)的 Spring Bean

裝配簡(jiǎn)易值

先來(lái)一個(gè)最簡(jiǎn)單的裝配：

<bean id="c" class="pojo.Category">
    <property name="name" value="測(cè)試" />
</bean>

簡(jiǎn)單解釋一下：

• id 屬性是 Spring 能找到當(dāng)前 Bean 的一個(gè)依賴的編號(hào)，遵守 XML 語(yǔ)法的 ID 唯一性約束。必須以字母開(kāi)頭，可以使用字母、數(shù)字、連字符、下劃線、句號(hào)、冒號(hào)，不能以 / 開(kāi)頭。
  不過(guò) id 屬性不是一個(gè)必需的屬性，name 屬性也可以定義 bean 元素的名稱，能以逗號(hào)或空格隔開(kāi)起多個(gè)別名，并且可以使用很多的特殊字符，比如在 Spring 和 Spring MVC 的整合中，就得使用 name 屬性來(lái)定義 bean 的名稱，并且使用 / 開(kāi)頭。
  注意： 從 Spring 3.1 開(kāi)始，id 屬性也可以是 String 類型了，也就是說(shuō) id 屬性也可以使用 / 開(kāi)頭，而 bean 元素的 id 的唯一性由容器負(fù)責(zé)檢查。
  如果 id 和 name 屬性都沒(méi)有聲明的話，那么 Spring 將會(huì)采用 “全限定名#{number}” 的格式生成編號(hào)。 例如這里，如果沒(méi)有聲明 “id="c"” 的話，那么 Spring 為其生成的編號(hào)就是 “pojo.Category#0”，當(dāng)它第二次聲明沒(méi)有 id 屬性的 Bean 時(shí)，編號(hào)就是 “pojo.Category#1”，以此類推。
• class 屬性顯然就是一個(gè)類的全限定名
• property 元素是定義類的屬性，其中的 name 屬性定義的是屬性的名稱，而 value 是它的值。

這樣的定義很簡(jiǎn)單，但是有時(shí)候需要注入一些自定義的類，比如之前飲品店的例子，JuickMaker 需要用戶提供原料信息才能完成 juice 的制作：

<!-- 配置 srouce 原料 -->
<bean name="source" class="pojo.Source">
    <property name="fruit" value="橙子"/>
    <property name="sugar" value="多糖"/>
    <property name="size" value="超大杯"/>
</bean>

<bean name="juickMaker" class="pojo.JuiceMaker">
    <!-- 注入上面配置的id為srouce的Srouce對(duì)象 -->
    <property name="source" ref="source"/>
</bean>

這里先定義了一個(gè) name 為 source 的 Bean，然后再制造器中通過(guò) ref 屬性去引用對(duì)應(yīng)的 Bean，而 source 正是之前定義的 Bean 的 name ，這樣就可以相互引用了。

• 注入對(duì)象：使用 ref 屬性

裝配集合

有些時(shí)候我們需要裝配一些復(fù)雜的東西，比如 Set、Map、List、Array 和 Properties 等，為此我們?cè)?Packge【pojo】下新建一個(gè) ComplexAssembly 類：

package pojo;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class ComplexAssembly {
    
    private Long id;
    private List<String> list;
    private Map<String, String> map;
    private Properties properties;
    private Set<String> set;
    private String[] array;

    /* setter and getter */
}

這個(gè) Bean 沒(méi)有任何的實(shí)際意義，知識(shí)為了介紹如何裝配這些常用的集合類：

<bean id="complexAssembly" class="pojo.ComplexAssembly">
    <!-- 裝配Long類型的id -->
    <property name="id" value="1"/>
    
    <!-- 裝配List類型的list -->
    <property name="list">
        <list>
            <value>value-list-1</value>
            <value>value-list-2</value>
            <value>value-list-3</value>
        </list>
    </property>
    
    <!-- 裝配Map類型的map -->
    <property name="map">
        <map>
            <entry key="key1" value="value-key-1"/>
            <entry key="key2" value="value-key-2"/>
            <entry key="key3" value="value-key-2"/>
        </map>
    </property>
    
    <!-- 裝配Properties類型的properties -->
    <property name="properties">
        <props>
            <prop key="prop1">value-prop-1</prop>
            <prop key="prop2">value-prop-2</prop>
            <prop key="prop3">value-prop-3</prop>
        </props>
    </property>
    
    <!-- 裝配Set類型的set -->
    <property name="set">
        <set>
            <value>value-set-1</value>
            <value>value-set-2</value>
            <value>value-set-3</value>
        </set>
    </property>
    
    <!-- 裝配String[]類型的array -->
    <property name="array">
        <array>
            <value>value-array-1</value>
            <value>value-array-2</value>
            <value>value-array-3</value>
        </array>
    </property>
</bean>

• 總結(jié)：
• List 屬性為對(duì)應(yīng)的 <list> 元素進(jìn)行裝配，然后通過(guò)多個(gè) <value> 元素設(shè)值
• Map 屬性為對(duì)應(yīng)的 <map> 元素進(jìn)行裝配，然后通過(guò)多個(gè) <entry> 元素設(shè)值，只是 entry 包含一個(gè)鍵值對(duì)(key-value)的設(shè)置
• Properties 屬性為對(duì)應(yīng)的 <properties> 元素進(jìn)行裝配，通過(guò)多個(gè) <property> 元素設(shè)值，只是 properties 元素有一個(gè)必填屬性 key ，然后可以設(shè)置值
• Set 屬性為對(duì)應(yīng)的 <set> 元素進(jìn)行裝配，然后通過(guò)多個(gè) <value> 元素設(shè)值
• 對(duì)于數(shù)組而言，可以使用 <array> 設(shè)置值，然后通過(guò)多個(gè) <value> 元素設(shè)值。

上面看到了對(duì)簡(jiǎn)單 String 類型的各個(gè)集合的裝載，但是有些時(shí)候可能需要更為復(fù)雜的裝載，比如一個(gè) List 可以是一個(gè)系列類的對(duì)象，為此需要定義注入的相關(guān)信息，其實(shí)跟上面的配置沒(méi)什么兩樣，只不過(guò)加入了 ref 這一個(gè)屬性而已：

• 集合注入總結(jié)：
• List 屬性使用 <list> 元素定義注入，使用多個(gè) <ref> 元素的 Bean 屬性去引用之前定義好的 Bean

<property name="list">
    <list>
        <ref bean="bean1"/>
        <ref bean="bean2"/>
    </list>
</property>

• Map 屬性使用 <map> 元素定義注入，使用多個(gè) <entry> 元素的 key-ref 屬性去引用之前定義好的 Bean 作為鍵，而用 value-ref 屬性引用之前定義好的 Bean 作為值

<property name="map">
    <map>
        <entry key-ref="keyBean" value-ref="valueBean"/>
    </map>
</property>

• Set 屬性使用 <set> 元素定義注入，使用多個(gè) <ref> 元素的 bean 去引用之前定義好的 Bean

<property name="set">
    <set>
        <ref bean="bean"/>
    </set>
</property>

命名空間裝配

除了上述的配置之外， Spring 還提供了對(duì)應(yīng)的命名空間的定義，只是在使用命名空間的時(shí)候要先引入對(duì)應(yīng)的命名空間和 XML 模式（XSD）文件。

——【① c-命名空間】——

c-命名空間是在 Spring 3.0 中引入的，它是在 XML 中更為簡(jiǎn)潔地描述構(gòu)造器參數(shù)的方式，要使用它的話，必須要在 XML 的頂部聲明其模式：

• 注意：是通過(guò)構(gòu)造器參數(shù)的方式

現(xiàn)在假設(shè)我們現(xiàn)在有這么一個(gè)類：

package pojo;

public class Student {

    int id;
    String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
    // setter and getter
}

在 c-命名空間和模式聲明之后，我們就可以使用它來(lái)聲明構(gòu)造器參數(shù)了：

<!-- 引入 c-命名空間之前 -->
<bean name="student1" class="pojo.Student">
    <constructor-arg name="id" value="1" />
    <constructor-arg name="name" value="學(xué)生1"/>
</bean>

<!-- 引入 c-命名空間之后 -->
<bean name="student2" class="pojo.Student"
      c:id="2" c:name="學(xué)生2"/>

c-命名空間屬性名以 “c:” 開(kāi)頭，也就是命名空間的前綴。接下來(lái)就是要裝配的構(gòu)造器參數(shù)名，在此之后如果需要注入對(duì)象的話則要跟上 -ref（如c:card-ref="idCard1"，則對(duì) card 這個(gè)構(gòu)造器參數(shù)注入之前配置的名為 idCard1 的 bean）

很顯然，使用 c-命名空間屬性要比使用 <constructor-arg> 元素精簡(jiǎn)，并且會(huì)直接引用構(gòu)造器之中參數(shù)的名稱，這有利于我們使用的安全性。

我們有另外一種替代方式：

<bean name="student2" class="pojo.Student"
      c:_0="3" c:_1="學(xué)生3"/>

我們將參數(shù)的名稱替換成了 “0” 和 “1” ，也就是參數(shù)的索引。因?yàn)樵?XML 中不允許數(shù)字作為屬性的第一個(gè)字符，因此必須要添加一個(gè)下劃線來(lái)作為前綴。

——【② p-命名空間】——

c-命名空間通過(guò)構(gòu)造器注入的方式來(lái)配置 bean，p-命名空間則是用setter的注入方式來(lái)配置 bean ，同樣的，我們需要引入聲明：

然后我們就可以通過(guò) p-命名空間來(lái)設(shè)置屬性：

<!-- 引入p-命名空間之前 -->
<bean name="student1" class="pojo.Student">
    <property name="id" value="1" />
    <property name="name" value="學(xué)生1"/>
</bean>

<!-- 引入p-命名空間之后 -->
<bean name="student2" class="pojo.Student" 
      p:id="2" p:name="學(xué)生2"/>

我們需要先刪掉 Student 類中的構(gòu)造函數(shù)，不然 XML 約束會(huì)提示我們配置 <constructor-arg> 元素。

同樣的，如果屬性需要注入其他 Bean 的話也可以在后面跟上 -ref：

    <bean name="student2" class="pojo.Student"
          p:id="2" p:name="學(xué)生2" p:cdCard-ref="cdCard1"/>

——【③ util-命名空間】——

工具類的命名空間，可以簡(jiǎn)化集合類元素的配置，同樣的我們需要引入其聲明（無(wú)需擔(dān)心怎么聲明的問(wèn)題，IDEA會(huì)有很友好的提示）：

我們來(lái)看看引入前后的變化：

<!-- 引入util-命名空間之前 -->
<property name="list">
    <list>
        <ref bean="bean1"/>
        <ref bean="bean2"/>
    </list>
</property>

<!-- 引入util-命名空間之后 -->
<util:list id="list">
    <ref bean="bean1"/>
    <ref bean="bean2"/>
</util:list>

<util:list> 只是 util-命名空間中的多個(gè)元素之一，下表提供了 util-命名空間提供的所有元素：

引入其他配置文件

在實(shí)際開(kāi)發(fā)中，隨著應(yīng)用程序規(guī)模的增加，系統(tǒng)中 <bean> 元素配置的數(shù)量也會(huì)大大增加，導(dǎo)致 applicationContext.xml 配置文件變得非常臃腫難以維護(hù)。

• 解決方案：讓 applicationContext.xml 文件包含其他配置文件即可
  使用 <import> 元素引入其他配置文件

1.在【src】文件下新建一個(gè) bean.xml 文件，寫(xiě)好基礎(chǔ)的約束，把 applicationContext.xml 文件中配置的 <bean> 元素復(fù)制進(jìn)去

2.在 applicationContext.xml 文件中寫(xiě)入：

<import resource="bean.xml" />

3.運(yùn)行測(cè)試代碼，仍然能正確獲取到 bean:

通過(guò)注解裝配 Bean

上面，我們已經(jīng)了解了如何使用 XML 的方式去裝配 Bean，但是更多的時(shí)候已經(jīng)不再推薦使用 XML 的方式去裝配 Bean，更多的時(shí)候回考慮使用注解（annotation） 的方式去裝配 Bean。

• 優(yōu)勢(shì)：
  1.可以減少 XML 的配置，當(dāng)配置項(xiàng)多的時(shí)候，臃腫難以維護(hù)
  2.功能更加強(qiáng)大，既能實(shí)現(xiàn) XML 的功能，也提供了自動(dòng)裝配的功能，采用了自動(dòng)裝配后，程序猿所需要做的決斷就少了，更加有利于對(duì)程序的開(kāi)發(fā)，這就是“約定由于配置”的開(kāi)發(fā)原則

在 Spring 中，它提供了兩種方式來(lái)讓 Spring IoC 容器發(fā)現(xiàn) bean：

• 組件掃描：通過(guò)定義資源的方式，讓 Spring IoC 容器掃描對(duì)應(yīng)的包，從而把 bean 裝配進(jìn)來(lái)。
• 自動(dòng)裝配：通過(guò)注解定義，使得一些依賴關(guān)系可以通過(guò)注解完成。

使用@Compoent 裝配 Bean

我們把之前創(chuàng)建的 Student 類改一下：

package pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component(value = "student1")
public class Student {

    @Value("1")
    int id;
    @Value("student_name_1")
    String name;

    // getter and setter
}

解釋一下：

• @Component注解：
  表示 Spring IoC 會(huì)把這個(gè)類掃描成一個(gè) bean 實(shí)例，而其中的 value 屬性代表這個(gè)類在 Spring 中的 id，這就相當(dāng)于在 XML 中定義的 Bean 的 id：<bean id="student1" class="pojo.Student" />，也可以簡(jiǎn)寫(xiě)成 @Component("student1")，甚至直接寫(xiě)成 @Component ，對(duì)于不寫(xiě)的，Spring IoC 容器就默認(rèn)以類名來(lái)命名作為 id，只不過(guò)首字母小寫(xiě)，配置到容器中。
• @Value注解：
  表示值的注入，跟在 XML 中寫(xiě) value 屬性是一樣的。

這樣我們就聲明好了我們要?jiǎng)?chuàng)建的一個(gè) Bean，就像在 XML 中寫(xiě)下了這樣一句話：

<bean name="student1" class="pojo.Student">
    <property name="id" value="1" />
    <property name="name" value="student_name_1"/>
</bean>

但是現(xiàn)在我們聲明了這個(gè)類，并不能進(jìn)行任何的測(cè)試，因?yàn)?Spring IoC 并不知道這個(gè) Bean 的存在，這個(gè)時(shí)候我們可以使用一個(gè) StudentConfig 類去告訴 Spring IoC ：

package pojo;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan
public class StudentConfig {
}

這個(gè)類十分簡(jiǎn)單，沒(méi)有任何邏輯，但是需要說(shuō)明兩點(diǎn)：

• 該類和 Student 類位于同一包名下
• @ComponentScan注解：
  代表進(jìn)行掃描，默認(rèn)是掃描當(dāng)前包的路徑，掃描所有帶有 @Component 注解的 POJO。

這樣一來(lái)，我們就可以通過(guò) Spring 定義好的 Spring IoC 容器的實(shí)現(xiàn)類——AnnotationConfigApplicationContext 去生成 IoC 容器了：

ApplicationContext context = new AnnotationConfigApplicationContext(StudentConfig.class);
Student student = (Student) context.getBean("student1", Student.class);
student.printInformation();

這里可以看到使用了 AnnotationConfigApplicationContext 類去初始化 Spring IoC 容器，它的配置項(xiàng)是 StudentConfig 類，這樣 Spring IoC 就會(huì)根據(jù)注解的配置去解析對(duì)應(yīng)的資源，來(lái)生成 IoC 容器了。

• 明顯的弊端：
• 對(duì)于 @ComponentScan 注解，它只是掃描所在包的 Java 類，但是更多的時(shí)候我們希望的是可以掃描我們指定的類
• 上面的例子只是注入了一些簡(jiǎn)單的值，測(cè)試發(fā)現(xiàn)，通過(guò) @Value 注解并不能注入對(duì)象

@Component 注解存在著兩個(gè)配置項(xiàng)：

• basePackages：它是由 base 和 package 兩個(gè)單詞組成的，而 package 還是用了復(fù)數(shù)，意味著它可以配置一個(gè) Java 包的數(shù)組，Spring 會(huì)根據(jù)它的配置掃描對(duì)應(yīng)的包和子包，將配置好的 Bean 裝配進(jìn)來(lái)
• basePackageClasses：它由 base、package 和 class 三個(gè)單詞組成，采用復(fù)數(shù)，意味著它可以配置多個(gè)類， Spring 會(huì)根據(jù)配置的類所在的包，為包和子包進(jìn)行掃描裝配對(duì)應(yīng)配置的 Bean

我們來(lái)試著重構(gòu)之前寫(xiě)的 StudentConfig 類來(lái)驗(yàn)證上面兩個(gè)配置項(xiàng)：

package pojo;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan(basePackages = "pojo")
public class StudentConfig {
}

//  —————————————————— 【 宇宙超級(jí)無(wú)敵分割線】—————————————————— 
package pojo;

import org.springframework.context.annotation.ComponentScan;

@ComponentScan(basePackageClasses = pojo.Student.class)
public class StudentConfig {
}

驗(yàn)證都能通過(guò)，bingo！

• 對(duì)于 【basePackages】 和 【basePackageClasses】 的選擇問(wèn)題：
  【basePackages】 的可讀性會(huì)更好一些，所以在項(xiàng)目中會(huì)優(yōu)先選擇使用它，但是在需要大量重構(gòu)的工程中，盡量不要使用【basePackages】，因?yàn)楹芏鄷r(shí)候重構(gòu)修改包名需要反復(fù)地配置，而 IDE 不會(huì)給你任何的提示，而采用【basePackageClasses】會(huì)有錯(cuò)誤提示。

自動(dòng)裝配——@Autowired

上面提到的兩個(gè)弊端之一就是沒(méi)有辦法注入對(duì)象，通過(guò)自動(dòng)裝配我們將解決這個(gè)問(wèn)題。

所謂自動(dòng)裝配技術(shù)是一種由 Spring 自己發(fā)現(xiàn)對(duì)應(yīng)的 Bean，自動(dòng)完成裝配工作的方式，它會(huì)應(yīng)用到一個(gè)十分常用的注解 @Autowired 上，這個(gè)時(shí)候 Spring 會(huì)根據(jù)類型去尋找定義的 Bean 然后將其注入，聽(tīng)起來(lái)很神奇，讓我們實(shí)際來(lái)看一看：

1.先在 Package【service】下創(chuàng)建一個(gè) StudentService 接口：

package service;

public interface StudentService {
    public void printStudentInfo();
}

使用接口是 Spring 推薦的方式，這樣可以更為靈活，可以將定義和實(shí)現(xiàn)分離

2.為上面的接口創(chuàng)建一個(gè) StudentServiceImp 實(shí)現(xiàn)類：

package service;

import org.springframework.beans.factory.annotation.Autowired;
import pojo.Student;

@Component("studentService")
public class StudentServiceImp implements StudentService {

    @Autowired
    private Student student = null;

     // getter and setter

    public void printStudentInfo() {
        System.out.println("學(xué)生的 id 為：" + student.getName());
        System.out.println("學(xué)生的 name 為：" + student.getName());
    }
}

該實(shí)現(xiàn)類實(shí)現(xiàn)了接口的 printStudentInfo() 方法，打印出成員對(duì)象 student 的相關(guān)信息，這里的 @Autowired 注解，表示在 Spring IoC 定位所有的 Bean 后，這個(gè)字段需要按類型注入，這樣 IoC 容器就會(huì)尋找資源，然后將其注入。

3.編寫(xiě)測(cè)試類：

// 第一步：修改 StudentConfig 類，告訴 Spring IoC 在哪里去掃描它：
package pojo;

import org.springframework.context.annotation.ComponentScan;

@ComponentScan(basePackages = {"pojo", "service"})
public class StudentConfig {
}

// 或者也可以在 XML 文件中聲明去哪里做掃描
<context:component-scan base-package="pojo" />
<context:component-scan base-package="service" />

// 第二步：編寫(xiě)測(cè)試類：
package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import pojo.StudentConfig;
import service.StudentService;
import service.StudentServiceImp;

public class TestSpring {

    public static void main(String[] args) {
        // 通過(guò)注解的方式初始化 Spring IoC 容器
        ApplicationContext context = new AnnotationConfigApplicationContext(StudentConfig.class);
        StudentService studentService = context.getBean("studentService", StudentServiceImp.class);
        studentService.printStudentInfo();
    }
}

運(yùn)行代碼：

• 再次理解： @Autowired 注解表示在 Spring IoC 定位所有的 Bean 后，再根據(jù)類型尋找資源，然后將其注入。
• 過(guò)程： 定義 Bean ——》 初始化 Bean（掃描） ——》 根據(jù)屬性需要從 Spring IoC 容器中搜尋滿足要求的 Bean ——》 滿足要求則注入
• 問(wèn)題： IoC 容器可能會(huì)尋找失敗，此時(shí)會(huì)拋出異常（默認(rèn)情況下，Spring IoC 容器會(huì)認(rèn)為一定要找到對(duì)應(yīng)的 Bean 來(lái)注入到這個(gè)字段，但有些時(shí)候并不是一定需要，比如日志）
• 解決： 通過(guò)配置項(xiàng) required 來(lái)改變，比如 @Autowired(required = false)

@Autowired 注解不僅僅能配置在屬性之上，還允許方法配置，常見(jiàn)的 Bean 的 setter 方法也可以使用它來(lái)完成注入，總之一切需要 Spring IoC 去尋找 Bean 資源的地方都可以用到，例如：

/* 包名和import */
public class JuiceMaker {
    ......
    @Autowired
    public void setSource(Source source) {
        this.source = source;
    }
}

在大部分的配置中都推薦使用這樣的自動(dòng)注入來(lái)完成，這是 Spring IoC 幫助我們自動(dòng)裝配完成的，這樣使得配置大幅度減少，滿足約定優(yōu)于配置的原則，增強(qiáng)程序的健壯性。

自動(dòng)裝配的歧義性（@Primary和@Qualifier）

在上面的例子中我們使用 @Autowired 注解來(lái)自動(dòng)注入一個(gè) Source 類型的 Bean 資源，但如果我們現(xiàn)在有兩個(gè) Srouce 類型的資源，Spring IoC 就會(huì)不知所措，不知道究竟該引入哪一個(gè) Bean：

<bean name="source1" class="pojo.Source">
    <property name="fruit" value="橙子"/>
    <property name="sugar" value="多糖"/>
    <property name="size" value="超大杯"/>
</bean>
<bean name="source2" class="pojo.Source">
    <property name="fruit" value="橙子"/>
    <property name="sugar" value="少糖"/>
    <property name="size" value="小杯"/>
</bean>

我們可以會(huì)想到 Spring IoC 最底層的容器接口——BeanFactory 的定義，它存在一個(gè)按照類型獲取 Bean 的方法，顯然通過(guò) Source.class 作為參數(shù)無(wú)法判斷使用哪個(gè)類實(shí)例進(jìn)行返回，這就是自動(dòng)裝配的歧義性。

為了消除歧義性，Spring 提供了兩個(gè)注解：

• @Primary 注解：
  代表首要的，當(dāng) Spring IoC 檢測(cè)到有多個(gè)相同類型的 Bean 資源的時(shí)候，會(huì)優(yōu)先注入使用該注解的類。
• 問(wèn)題：該注解只是解決了首要的問(wèn)題，但是并沒(méi)有選擇性的問(wèn)題
• @Qualifier 注解：
  上面所談及的歧義性，一個(gè)重要的原因是 Spring 在尋找依賴注入的時(shí)候是按照類型注入引起的。除了按類型查找 Bean，Spring IoC 容器最底層的接口 BeanFactory 還提供了按名字查找的方法，如果按照名字來(lái)查找和注入不就能消除歧義性了嗎？
• 使用方法： 指定注入名稱為 "source1" 的 Bean 資源

/* 包名和import */
public class JuiceMaker {
    ......
    @Autowired
    @Qualifier("source1")
    public void setSource(Source source) {
        this.source = source;
    }
}

使用@Bean 裝配 Bean

• 問(wèn)題： 以上都是通過(guò) @Component 注解來(lái)裝配 Bean ，并且只能注解在類上，當(dāng)你需要引用第三方包的（jar 文件），而且往往并沒(méi)有這些包的源碼，這時(shí)候?qū)o(wú)法為這些包的類加入 @Component 注解，讓它們變成開(kāi)發(fā)環(huán)境中的 Bean 資源。
• 解決方案：
  1.自己創(chuàng)建一個(gè)新的類來(lái)擴(kuò)展包里的類，然后再新類上使用 @Component 注解，但這樣很 low
  2.使用 @Bean 注解，注解到方法之上，使其成為 Spring 中返回對(duì)象為 Spring 的 Bean 資源。

我們?cè)?Package【pojo】 下新建一個(gè)用來(lái)測(cè)試 @Bean 注解的類：

package pojo;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class BeanTester {

    @Bean(name = "testBean")
    public String test() {
        String str = "測(cè)試@Bean注解";
        return str;
    }
}

• 注意： @Configuration 注解相當(dāng)于 XML 文件的根元素，必須要，有了才能解析其中的 @Bean 注解

然后我們?cè)跍y(cè)試類中編寫(xiě)代碼，從 Spring IoC 容器中獲取到這個(gè) Bean ：

// 在 pojo 包下掃描
ApplicationContext context = new AnnotationConfigApplicationContext("pojo");
// 因?yàn)檫@里獲取到的 Bean 就是 String 類型所以直接輸出
System.out.println(context.getBean("testBean"));

@Bean 的配置項(xiàng)中包含 4 個(gè)配置項(xiàng)：

• name： 是一個(gè)字符串?dāng)?shù)組，允許配置多個(gè) BeanName
• autowire： 標(biāo)志是否是一個(gè)引用的 Bean 對(duì)象，默認(rèn)值是 Autowire.NO
• initMethod： 自定義初始化方法
• destroyMethod： 自定義銷(xiāo)毀方法

使用 @Bean 注解的好處就是能夠動(dòng)態(tài)獲取一個(gè) Bean 對(duì)象，能夠根據(jù)環(huán)境不同得到不同的 Bean 對(duì)象?；蛘哒f(shuō)將 Spring 和其他組件分離（其他組件不依賴 Spring，但是又想 Spring 管理生成的 Bean）

Bean 的作用域

在默認(rèn)的情況下，Spring IoC 容器只會(huì)對(duì)一個(gè) Bean 創(chuàng)建一個(gè)實(shí)例，但有時(shí)候，我們希望能夠通過(guò) Spring IoC 容器獲取多個(gè)實(shí)例，我們可以通過(guò) @Scope 注解或者 <bean> 元素中的 scope 屬性來(lái)設(shè)置，例如：

// XML 中設(shè)置作用域
<bean id="" class="" scope="prototype" />
// 使用注解設(shè)置作用域
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

Spring 提供了 5 種作用域，它會(huì)根據(jù)情況來(lái)決定是否生成新的對(duì)象：

在開(kāi)發(fā)中主要使用 scope="singleton"、scope="prototype"，對(duì)于MVC中的Action使用prototype類型，其他使用singleton，Spring容器會(huì)管理 Action 對(duì)象的創(chuàng)建,此時(shí)把 Action 的作用域設(shè)置為 prototype.

擴(kuò)展閱讀：@Profile 注解 、 條件化裝配 Bean

Spring 表達(dá)式語(yǔ)言簡(jiǎn)要說(shuō)明

Spring 還提供了更靈活的注入方式，那就是 Spring 表達(dá)式，實(shí)際上 Spring EL 遠(yuǎn)比以上注入方式都要強(qiáng)大，它擁有很多功能：

• 使用 Bean 的 id 來(lái)引用 Bean
• 調(diào)用指定對(duì)象的方法和訪問(wèn)對(duì)象的屬性
• 進(jìn)行運(yùn)算
• 提供正則表達(dá)式進(jìn)行匹配
• 集合配置

我們來(lái)看一個(gè)簡(jiǎn)單的使用 Spring 表達(dá)式的例子：

package pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component("elBean")
public class ElBean {
    // 通過(guò) beanName 獲取 bean，然后注入 
    @Value("#{role}")
    private Role role;
    
    // 獲取 bean 的屬性 id
    @Value("#{role.id}")
    private Long id;
    
    // 調(diào)用 bean 的 getNote 方法
    @Value("#{role.getNote().toString()}")
    private String note;
    /* getter and setter */
}

與屬性文件中讀取使用的 “$” 不同，在 Spring EL 中則使用 “#”

擴(kuò)展閱讀： Spring 表達(dá)式語(yǔ)言

參考資料：

• 《Java EE 互聯(lián)網(wǎng)輕量級(jí)框架整合開(kāi)發(fā)》
• 《Java 實(shí)戰(zhàn)（第四版）》
• 萬(wàn)能的百度 and 萬(wàn)能的大腦

歡迎轉(zhuǎn)載，轉(zhuǎn)載請(qǐng)注明出處！
簡(jiǎn)書(shū)ID：@我沒(méi)有三顆心臟
github：wmyskxz
歡迎關(guān)注公眾微信號(hào)：wmyskxz
分享自己的學(xué)習(xí) & 學(xué)習(xí)資料 & 生活
想要交流的朋友也可以加qq群：3382693