创建应用对象之间协作关系的行为通常被称作装配（Wiring），这也是依赖注入的本质。

声明Bean

创建Spring配置

Spring容器提供了两种配置Bean的方式，其一是使用XML文件作为配置文件，其二是基于Java注解的配置方式。
以下是一个典型的Spring 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">

    <!-- 此处声明各个Bean -->

</beans>

在<beans>标签内可以放置相关的Spring配置信息，另外，Spring的核心框架自带了10个命名空间的配置：

声明一个简单的Bean

package com.springinaction.springidol;

public class Juggler implements Performer {

    private int beanBags = 3;

    public Juggler() {
    }

    public Juggler(int beanBags) {
        this.beanBags = beanBags;
    }

    @Override
    public void perform() throws PerformanceException {
        System.out.println("JUGGLING " + beanBags + " BEANBAGS");
    }

}

<bean id="duke" class="com.springinaction.springidol.Juggler"></bean>

<bean>元素是Spring中最基本的配置单元，通过该元素Spring将创建一个对象。当Spring容器加载该Bean时，Spring将使用默认的构造器来实例化该Bean，实际上，duke会使用如下代码来创建：
new com.springinaction.springidol.Juggler();

通过构造器注入

让bean使用另外一个构造方法：

<bean id="duke" class="com.springinaction.springidol.Juggler">
    <constructor-arg value="15"></constructor-arg>
</bean>

在构造Bean的时候，可以使用<constructor-arg>标签来告诉Spring额外的信息，这样Spring就不再会使用默认的构造器来实例化该Bean。
测试代码：

package com.springinaction.springidol;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {

    @Test
    public void testDuke() throws PerformanceException {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-idol.xml");
        Performer performer = (Performer) context.getBean("duke");
        performer.perform();
    }
}

通过运行结果JUGGLING 15 BEANBAGS可以15被注入到了构造器中。

通过构造器注入对象引用

现在需要一个新的类PoeticJuggler，该类需要Poem类作为其参数并通过构造器注入。

package com.springinaction.springidol;

public class PoeticJuggler extends Juggler {
    private Poem poem;

    // 注入Poem
    public PoeticJuggler(Poem poem) {
        super();
        this.poem = poem;
    }

    // 注入豆袋子数量和Poem
    public PoeticJuggler(int beanBags, Poem poem) {
        super(beanBags);
        this.poem = poem;
    }

    @Override
    public void perform() throws PerformanceException {
        super.perform();
        System.out.println("While reciting...");
        poem.recite();
    }
}

在配置文件中就需要声明一个 Poem的类，并将其注入到PoeticJuggler中：

<bean id="sonnet29" class="com.springinaction.springidol.Sonnet29"></bean>

<bean id="poeticDuke" class="com.springinaction.springidol.PoeticJuggler">
    <constructor-arg value="15" />
    <constructor-arg ref="sonnet29" />
</bean>

这里使用ref属性来将Id为sonnet29的Bean引用传递给构造器，当Spring遇到sonnet29和poeticDuke的bean声明时，所执行的逻辑脚本将是：

Poem sonnet29 = new Sonnet29();
Performer poeticDuke = new PoeticJuggler(15, sonnet29 );

通过工厂方法创建Bean

在没有公开的构造方法时，可以通过工厂方法来创建Bean，及<bean>元素的factory-method属性来装配工厂创建的Bean。
比如Stage是一个没有公开构造方法的类，但是可以通过getInstance获取其实例，那么可以通过下面的配置方式：

<bean id="theStage" class="com.springinaction.springidol.Stage"
    factory-method="getInstance" />

Bean的作用域

配置方法，设置<bean>标签的scope属性：

<bean id="sonnet29" class="com.springinaction.springidol.Sonnet29" scope="prototype"/>

Spring的单例只能保证在每个应用上下文中只有一个Bean的实例，你也可以通过定义多个<bean>的方式来实例化同一个Bean。

初始化和销毁Bean

可以为Bean定义初始化和销毁操作，只需使用init-method和destroy-method参数来配置<bean>标签即可。

比如，舞台（Auditorium）需要在表演开始前开灯（turnOnLights），在结束时关灯（turnOffLights），那么就可以做下面的声明：

<bean id="auditorium" class="com.springinaction.springidol.Auditorium"
    init-method="turnOnLights" destroy-method="turnOffLights" />

默认的init-method和destroy-method

可以使用<beans>的default-init-method和default-destroy-method为上下文中所有的Bean设置共同的初始化和销毁方法。

注入Bean属性

Spring可以借助属性的set方法来配置属性的值，以实现setter方式的注入。

下面是一个音乐家（Instrumentalist）类，它演奏时需要歌曲（song）和乐器（instrument）两个属性。

package com.springinaction.springidol;

public class Instrumentalist implements Performer {

    private String song;

    private Instrument instrument;

    public Instrumentalist() {
    }

    public void perform() throws PerformanceException {
        System.out.print("Playing " + song + " : ");
        instrument.play();
    }

    public void setSong(String song) { // 注入歌曲
        this.song = song;
    }

    public String getSong() {
        return song;
    }

    public String screamSong() {
        return song;
    }

    public void setInstrument(Instrument instrument) { // 注入乐器
        this.instrument = instrument;
    }
}

配置文件中需要为Instrumentalist 注入这两个属性的值。

注入简单值

使用<property>标签可以通过调用属性的setter方法为Bean注入属性，而类似的<constructor-arg>是通过构造函数注入的。

<bean id="kenny" class="com.springinaction.springidol.Instrumentalist">
    <property name="song" value="Happy" />
</bean>

<property>元素会指示Spring调用setSong()方法将song属性的值设置为"Happy"。

注意value的属性值可以指定数值型（int、float、Double等）以及boolean等，Spring在调用set方法前会自动根据类型进行转换。

引用其他Bean

在演奏家kenny中需要一个乐器，那么我们就可以为其引用一个实现了Instrument接口的乐器。

<bean id="saxphone" class="com.springinaction.springidol.Saxophone" />
<bean id="kenny" class="com.springinaction.springidol.Instrumentalist">
    <property name="song" value="Happy" />
    <property name="instrument" ref="saxphone"></property>
</bean>

通过Performer接口引用一个参赛者，就可以产生任意类型的参赛者进行表演，面向接口编程和依赖注入实现了松耦合。

注入内部Bean

前文中，演奏家使用的instrument是其他Bean都可以进行共用的，若要独用一个类，那么可以声明一个类为内部Bean：

<bean id="kenny" class="com.springinaction.springidol.Instrumentalist">
    <property name="song" value="Happy" />
    <property name="instrument">
        <bean class="com.springinaction.springidol.Saxophone" />
    </property>
</bean>

如上面的代码，通过直接声明一个<bean>元素作为<property>元素的子节点。内部Bean不限于setter注入，也可以通过构造方法注入。

内部Bean没有Id属性，它们不能被复用，内部Bean仅适用于一次注入，而不能被其他Bean引用。

装配集合

下面一个演奏家可以演奏多种乐器：

package com.springinaction.springidol;

import java.util.Collection;

public class OneManBand implements Performer {
    public OneManBand() {
    }

    public void perform() throws PerformanceException {
        // 遍历演奏各个乐器
        for (Instrument instrument : instruments) {
            instrument.play();
        }
    }

    private Collection<Instrument> instruments;

    public void setInstruments(Collection<Instrument> instruments) {// 注入instruments集合
        this.instruments = instruments;
    }
}

装配List、Set和Array

可以使用下面的方式装配List,也可以使用<set>来装配：

<bean id="hank" class="com.springinaction.springidol.OneManBand">
    <property name="instruments">
        <list>
            <ref bean="guitar"/>
            <ref bean="cymbal"/>
            <ref bean="harmonica"/>
        </list>
    </property>
</bean>

装配Map

当OneManBand表演时，perform()方法可以把乐器（instrument）的音符打印出来，我们还想知道每个音符是由哪个乐器产生的，因此需要做以下改变：

package com.springinaction.springidol;

import java.util.Map;

public class OneManBandMap implements Performer {
    public OneManBandMap() {
    }

    public void perform() throws PerformanceException {
        for (String key : instruments.keySet()) {
            System.out.print(key + " : ");
            Instrument instrument = instruments.get(key);
            instrument.play();
        }
    }

    private Map<String, Instrument> instruments;

    public void setInstruments(Map<String, Instrument> instruments) {// 以map类型注入instruments
        this.instruments = instruments;
    }
}

Spring配置map注入：

<bean id="hankk" class="com.springinaction.springidol.OneManBandMap">
    <property name="instruments">
        <map>
            <entry key="GUITAR" value-ref="guitar" />
            <entry key="CYMBAL" value-ref="cymbal" />
            <entry key="HARMONICA" value-ref="harmonica" />
        </map>
    </property>
</bean>

<map>中的<entry>元素由一个键和一个值组成，键和值可以是简单类型，也可以是其他Bean的引用：

装配Properties集合

若OneManBandMap中的Instrument属性所配置的Map的每一个entry的键和值都是String类型，可以使用java.util.Properties来代替Map：

<bean id="hank" class="com.springinaction.springidol.OneManBand">
    <property name="instruments">
        <props>
            <prop key="GUITAR">Strum Strum Strum</prop>
            <prop key="CYMBAL">Crush Crush Crush</prop>
            <prop key="HARMONICA">Hum Hum Hum</prop>
        </props>
    </property>
</bean>

• <property>元素用于把值或者Bean引用注入到Bean的属性中；
• <props>用于定义一个java.util.Properties类型的集合值；
• <prop>用于定义<props>集合的一个成员

装配空值

<property name="someNonNullProperty"><null/></property>

使用表达式装配

如果为属性装配的值只有在运行期间才能获取，那该如何实现？
Spring表达式语言（ Spring Expression Language , SpEL），可以通过运行期执行的表达式将值装配到Bean的属性或者构造器参数中，其特性有：

• 使用Bean的id来引用Bean；
• 调用方法和访问对象的属性；
• 对值进行算术、关系和逻辑运算；
• 正则表达式匹配；
• 集合操作。

SpEL基本用法

字面值

比如<property name="count" value="#{5}"/>，#{ }标记会提示Spring这是个SpEL表达式。

可以与非SpEL表达式混用：<property name="message" value="The value is #{5}"/>。

另外，浮点型、科学计数法、布尔型（true和false）也可以直接使用。

字符串使用时，需要用单引号或者双引号括起。

引用Bean、Properties和方法（避免空指针）

新声明一个id为carl的模仿者，Kenny唱什么他就唱什么：

<bean id="carl" class="com.springinaction.springidol.Instrumentalist">
    <property name="song" value="#{kenny.song}" />
</bean>

注入到Carl的song属性的表达式是由两部分组成的，第一部分（kenny）指向了kenny的Bean，第二部分（song）指向了kenny Bean的song属性，其实等价于下面的代码：

Instrumentalist carl = new Instrumentalist();
carl.setSong(kenny.getSong());

还可以调用其他Bean的方法：
<property name="song" value="#{songSelector.selectSong()}"/>
<property name="song" value="#{songSelector.selectSong().toUpperCase()}"/>

如果selectSong()返回一个null，那么SpEL会抛出空指针异常，可以采用下面的方法避免：
<property name="song" value="#{songSelector.selectSong()?.toUpperCase()}"/>
使用?.来代替.来访问toUpperCase()方法，访问之前会确保左边项不为null，若为null就不会再继续调用。

操作类

可以使用T()运算符调用类作用域的方法和常量。比如：
<property name="multiplier" value="#{T(java.lang.Math).PI}"/>
<property name="randomNumber" value="#{T(java.lang.Math).random()}"/>

在SpEL值上进行操作

如果觉得有用，欢迎关注我的微信，有问题可以直接交流：

你的关注是对我最大的鼓励！