Spring IOC—基于XML配置和管理Bean 万字详解（通俗易懂）

一、前言

二、通过类型来获取Bean

0.总述（重要） :

1.基本介绍 :

2.应用实例 :

三、通过指定构造器为Bean注入属性

1.基本介绍 :

2.应用实例 :

四、通过p命名空间为Bean注入属性

1.基本介绍 :

2.应用实例 :

五、通过ref引用实现Bean的相互引用

1.基本介绍 :

2.应用实例 :

六、对Bean注入属性的内容延伸

1.准备工作 :

2.注入List类型的属性 :

3.注入Set类型的属性 :

4.注入Map类型的属性 :

5.注入数组类型的属性 :

6.注入Properties类型的属性 :

7.List属性注入之通过util命名空间注入 :

8.级联属性注入 :

七、通过静态工厂获取Bean

1.基本介绍 :

2.应用实例 :

八、通过实例工厂获取Bean

1.基本介绍 :

2.应用实例 :

九、通过FactoryBean获取Bean

1.基本介绍 :

2.应用实例 :

十、关于Bean配置的更多内容和细节

十一、总结

一、前言

第二节内容，up打算和大家分享一下Spring IOC——基于XML方式对Bean的配置和管理。(PS: 若对XML文件未曾了解，可以去快速阅读一下up的“速通XML”一文。)
注意事项——①代码中的注释也很重要；②不要眼高手低，自己跟着过一遍才有收获；③点击文章的侧边栏目录或者文章开头的目录可以进行跳转。
良工不示人以朴，所有文章都会适时补充完善。大家如果有问题都可以在评论区进行交流或者私信up。感谢阅读！

二、通过类型来获取Bean

0.总述（重要） :

(1) Spring对Bean的管理主要包括两方面内容——创建bean对象 和 为bean注入属性。

(2) Spring对Bean的配置方式也主要是两种——基于XML文件配置的方式 和 基于注解配置的方式。

(3) 上一小节中，我们已经演示过“通过id属性来获取bean对象”的方式(基于beans.xml配置文件)，因此这一小节，我们直接演示其他方式（这一小节均是基于XML文件配置的方式）。

1.基本介绍 :

(1) 通过类型来获取bean对象，其实是调用了getBean(Class<T> aClass)方法，该方法与我们上一小节中演示的“通过id获取bean对象”的方法构成重载，如下图所示 :

(2) 通过类型来获取bean时，要求ioc容器中同一类型的bean对象只能有一个，否则会抛出异常NoUniqueBeanDefinitionException（不唯一Bean定义异常），如下图所示 :

(3) “通过类型获取Bean”方式的适用场景——在一个线程中只需要一个对象实例（单例）的情况，eg : XxxAction / Servlet / Controller / XxxService。

(4) PS : 在容器配置文件(eg : beans.xml)中给bean对象的属性赋值，底层是通过setter方法完成的，因此我们定义的JavaBean（比如之前的Student）类中，必须提供相应的setter方法，否则报错。

2.应用实例 :

需求 : 在beans.xml配置文件中配置一个bean对象，并通过Class类型的方式来获取到该bean对象。
首先，我们需要创建一个JavaBean类，以Student类为例，Student类代码如下 :

package com.cyan.spring.bean;

/**
 * @author : Cyan_RA9
 * @version : 21.0
 */
public class Student {
    private String name;
    private int age;
    private int score;

    //PS : 无参构造器必须给出，因为底层要通过反射来创建对象。
    public Student() {

    }
    public Student(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

然后，在beans.xml配置文件中，配置一个Student类对象，beans.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">

    <!--
        (1) 在根元素beans中，通过<bean></bean>子元素来配置JavaBean对象。
            每配置一个bean，相当于配置了一个Java对象。
        (2) bean子元素需要配置两个属性———class 和 id。其中，
            class表示所要实例化类的正名(全类名);
            id表示该对象在Spring容器中的标识，通过id可以获取到对象。
        (3) property子元素用于配置该对象的成员变量(对象的属性)，其中，
            name表示属性名称，value表示属性的值。
        (4) XML内容回顾———若一个标签没有标签体，以<age></age>为例，可以简写为<age/>。
    -->

    <!-- 注意———此处我们没有为bean标签配置id属性，默认的分配id为：全类名#0 -->
    <bean class="com.cyan.spring.bean.Student">
        <property name="name" value="Rain"></property>
        <property name="age" value="19"></property>
        <property name="score" value="439"></property>
    </bean>
</beans>

接着，在测试类中调用getBean(Class<T> aClass)方法，以StudentBeanByXML类为测试类，通过JUnit框架进行单元测试，StudentBeanByXML类代码如下 :

package com.cyan.spring.test;

import com.cyan.spring.bean.Student;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author : Cyan_RA9
 * @version : 21.0
 */
public class StudentBeanByXML {
    //1.通过类型来获取Bean
    @Test
    public void getBeanByClass() {
        //(1) 获取Spring容器对象
            //IOC : Inversion Of Control
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        //(2) 通过JavaBean的类型来获取bean
        Student bean = ioc.getBean(Student.class);

        //(3) 打印出获取到的bean对象的信息
        System.out.println(bean);
    }
}

运行结果 :

三、通过指定构造器为Bean注入属性

1.基本介绍 :

“通过指定构造器为Bean注入属性”，即在beans.xml配置文件中通过<constructor-arg/>标签来指定一个JavaBean中的带参构造，利用该带参构造来完成对Bean的属性的初始化，其配置方式本质仍然是“IOC——基于XML文件配置Bean”。如下图所示 :

上图中演示的为通过index索引来确定参数，还可以通过type类型或者name属性名来确定参数，本质都是根据形参来唯一确定一个带参构造。

2.应用实例 :

需求 : 在beans.xml文件中新配置一个Bean对象，并通过<constructor-arg/>标签指定Student类的一个带参构造来初始化该Bean的属性。在StudentBeanByXML类中新定义一个单元测试方法，通过id属性获取到该Bean对象，并检测属性注入是否成功。
仍然使用Student类作为JavaBean类，首先我们要在beans.xml文件中配置Bean对象，up为了演示一下index, type, name三种形式的<constructor-arg/>标签，此处配置了三个Bean对象，代码如下 :

    <bean class="com.cyan.spring.bean.Student" id="stu03">
        <constructor-arg value="Cyan" index="0"></constructor-arg>
        <constructor-arg value="21" index="1"></constructor-arg>
        <constructor-arg value="453" index="2"></constructor-arg>
    </bean>
    <bean class="com.cyan.spring.bean.Student" id="stu04">
        <constructor-arg value="Eisen" type="java.lang.String"></constructor-arg>
        <constructor-arg value="21" type="int"></constructor-arg>
        <constructor-arg value="442" type="int"></constructor-arg>
    </bean>
    <bean class="com.cyan.spring.bean.Student" id="stu05">
        <constructor-arg value="Five" name="name"></constructor-arg>
        <constructor-arg value="20" name="age"></constructor-arg>
        <constructor-arg value="460" name="score"></constructor-arg>
    </bean>

接着，在StudentBeanByXML类中新定义一个方法，分别获取到id = stu03, id = stu04, id = stu05的对象，insertPropertiesByConstructor()方法代码如下 :

    //2.通过指定构造器为Bean注入属性
        //回顾————
        //对Bean的管理包括两方面 (1) 创建bean对象；(2) 为bean对象注入属性。
    @Test
    public void insertPropertiesByConstructor() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        Student stu03 = ioc.getBean("stu03", Student.class);
        Student stu04 = ioc.getBean("stu04", Student.class);
        Student stu05 = ioc.getBean("stu05", Student.class);

        System.out.println("stu03 = " + stu03);
        System.out.println("stu04 = " + stu04);
        System.out.println("stu05 = " + stu05);
    }

运行结果 :

可以看到，打印出的属性值与我们配置的一致，说明带参构造成功初始化该bean对象。

四、通过p命名空间为Bean注入属性

1.基本介绍 :

前文中用<bean></bean>标签配置Bean对象时，我们用到了class属性(JavaBean的全类名)，id属性(对象在容器中的标识)。现在我们可以用"p:property_name = property_value"(注意冒号)的形式，直接在bean标签内部为Bean注入属性，但直接使用会报错，如下图所示 :

报错提示 : "Namespace 'p' is not bound"（命名空间p未绑定）。

解决方法 : 将鼠标悬停在报错处，按下Alt + Enter，选择"Create namespace declaration"（创建命名空间声明），如下图所示 :

创建命名空间声明后，可以看到beans.xml根元素中已经自动加入了p命名空间的声明，如下图所示 :

2.应用实例 :

需求 : 在beans.xml文件中新配置一个Bean对象，并通过p命名空间为该对象注入属性。在StudentBeanByXML类中新定义一个单元测试方法，打印该对象信息，检测属性注入是否成功。
仍然使用Student类作为JavaBean类，首先我们要在beans.xml文件中配置Bean对象，代码如下 :

    <bean class="com.cyan.spring.bean.Student" id="stu06" p:name="Peter" p:age="33" p:score="1024">

    </bean>

接着，在StudentBeanByXML测试类中新定义一个方法，获取到id = stu06的对象，injectPropertiesByP()方法代码如下 :

    //3.通过p命名空间为Bean注入属性
    @Test
    public void injectPropertiesByP() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        Student stu06 = ioc.getBean("stu06", Student.class);

        System.out.println("stu06 = " + stu06);
    }

运行结果 :

五、通过ref引用实现Bean的相互引用

1.基本介绍 :

(1) 在JavaWeb中（比方说我们之前的Web项目——尘歌壶摆设购买系统），我们利用“分层设计”的思想，会分别建立DAO层，Service层，Web层；并根据“Web层调用Service层，Service层调用DAO层”的思想，在XxxServlet类中new一个XxxService对象，在XxxService类中new一个XxxDao对象。如下图所示 :

(2) 而有了Spring的加持后，我们可以通过ref（引用）来实现IOC容器中bean对象的相互引用，其本质是通过ref引用来为一个对象的引用类型的属性进行初始化，即属于“Bean管理——为bean注入属性”的范畴。

(3) ref在使用时，是作为property标签的一个属性（我们之前已经多次用到了property标签），格式如下 :

<property name="property_name" ref="otherBeans id"></property>（更多说明见beans.xml中的注释）

2.应用实例 :

需求 : 参照之前JavaWeb中“分层设计”的思想，在Service层中调用DAO层，但是不直接new出实例，而是在beans.xml文件中通过ref进行配置，试着根据输出语句，测试注入属性是否成功。
首先，我们需要创建用于测试的Service层和DAO层的类，以我们之前的尘歌壶摆设购买系统为参考，如下图所示 :

FurnishingDAOImpl类代码如下 : （定义了一个用于添加摆设的addFurnishing方法）

package com.cyan.spring.dao;

/**
 * @author : Cyan_RA9
 * @version : 21.0
 */
public class FurnishingDAOImpl {
    public FurnishingDAOImpl() {
        System.out.println("FurnishingDAOImpl的无参构造被调用~");
    }
    public void addFurnishing() {
        System.out.println("FurnishingDAOImpl的addFurnishing方法被调用~");
    }
}

FurnishingServiceImpl类代码如下 : （定义了一个FurnishingDAOImpl类型的属性，我们将在beans.xml文件中对其进行初始化；此外，定义addFurnishing()方法，实现Service层调用DAO层）

package com.cyan.spring.service;

import com.cyan.spring.dao.FurnishingDAOImpl;

/**
 * @author : Cyan_RA9
 * @version : 21.0
 */
public class FurnishingServiceImpl {
    //Service层调用DAO层（但通过beans.xml文件进行配置）
    private FurnishingDAOImpl furnishingDAO;

    public FurnishingServiceImpl() {
    }

    //About DAO's setter,getter
    public FurnishingDAOImpl getFurnishingDAO() {
        return furnishingDAO;
    }

    public void setFurnishingDAO(FurnishingDAOImpl furnishingDAO) {
        this.furnishingDAO = furnishingDAO;
    }

    //Add Furnishing
    public void addFurnishing() {
        System.out.println("FurnishingServiceImpl的addFurnishing()方法被调用~");
        furnishingDAO.addFurnishing();
    }
}

在beans.xml中配置这两个对象，代码如下 : （注意看注释）

    <!--
        (1) 配置一个FurnishingDAOImpl对象;
        (2) 由于该类暂时没有设置属性，所以此处不需要注入属性(下面furnishingService01同理)
     -->
    <bean class="com.cyan.spring.dao.FurnishingDAOImpl" id="furnishingDAO01"/>
    <!--
        (1) 配置一个FurnishingServiceImpl对象;
        (2) 仍然是通过property子元素来为id = furnishingService01的对象注入属性,
            注意，此处的"ref" 表示————
                id = furnishingService01的对象的furnishingDAO属性，
                引用了上面配置的id = furnishingDAO01的对象
            PS : ref体现了Spring的依赖注入(即一个对象的属性，引用了另一个对象)
     -->
    <bean class="com.cyan.spring.service.FurnishingServiceImpl" id="furnishingService01">
        <property name="furnishingDAO" ref="furnishingDAO01"></property>
    </bean>

最后，仍是在StudentBeanByXML测试类中新定义一个方法，测试FurnishingServiceImpl的FurnishingDAOImpl属性是否被初始化。
injectPropertiesByRef()方法代码如下 :

    //4.通过ref引用实现Bean的相互引用
    @Test
    public void injectPropertiesByRef() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        FurnishingServiceImpl furnishingService01 = ioc.getBean("furnishingService01", FurnishingServiceImpl.class);

        furnishingService01.addFurnishing();
    }

运行结果 :

可以看到，FurnishingDAOImpl类的无参构造成功被调用，说明它被成功初始化。
其实，除了使用ref属性外，还可以直接通过配置内部bean来完成对属性的初始化，如下所示 :

    <bean class="com.cyan.spring.service.FurnishingServiceImpl" id="furnishingService02">
        <property name="furnishingDAO">
            <bean class="com.cyan.spring.dao.FurnishingDAOImpl"/>
        </property>
    </bean>

这种方法的意思是，对引用类型属性的初始化不再使用Spring容器中已经配置好的对象，而是自己重新配置一个bean。经过测试，配置内部bean的方法也可以成功注入，大家有兴趣可以自己去试试。

六、对Bean注入属性的内容延伸

1.准备工作 :

上文中我们已经演示过多种为bean注入属性的方式，比如“通过指定构造器注入”，“通过p命名空间注入”，“通过ref引用实现Bean的相互引用”等。现在，让我们来讨论一下，如果bean对象的属性是数组或者集合类型，我们又该怎样去注入呢？

为了实现“注入数组 or 集合类型的属性”，我们先来创建一个类去维护这些属性，School类代码如下 :

package com.cyan.spring.bean;

import java.util.*;

/**
 * @author : Cyan_RA9
 * @version : 21.0
 */
public class School {
    private List<Student> studentList;
    private Set<Student> studentSet;
    private Map<String, Student> studentMap;
    private String[] studentNames;
    private Properties pros;

    public School() {

    }
    public School(List<Student> studentList, Set<Student> studentSet, Map<String, Student> studentMap, String[] studentNames, Properties pros) {
        this.studentList = studentList;
        this.studentSet = studentSet;
        this.studentMap = studentMap;
        this.studentNames = studentNames;
        this.pros = pros;
    }

    public List<Student> getStudentList() {
        return studentList;
    }
    public void setStudentList(List<Student> studentList) {
        this.studentList = studentList;
    }

    public Set<Student> getStudentSet() {
        return studentSet;
    }
    public void setStudentSet(Set<Student> studentSet) {
        this.studentSet = studentSet;
    }

    public Map<String, Student> getStudentMap() {
        return studentMap;
    }
    public void setStudentMap(Map<String, Student> studentMap) {
        this.studentMap = studentMap;
    }

    public String[] getStudentNames() {
        return studentNames;
    }
    public void setStudentNames(String[] studentNames) {
        this.studentNames = studentNames;
    }

    public Properties getPros() {
        return pros;
    }
    public void setPros(Properties pros) {
        this.pros = pros;
    }

    @Override
    public String toString() {
        return "School{" +
                "studentList=" + studentList +
                ", studentSet=" + studentSet +
                ", studentMap=" + studentMap +
                ", studentNames=" + Arrays.toString(studentNames) +
                ", pros=" + pros +
                '}';
    }
}

接着，我们在beans.xml中配置一个School类型的Bean对象，代码如下 :

    <bean class="com.cyan.spring.bean.School" id="school01">
        <!-- 暂未给属性赋值 -->
    </bean>

2.注入List类型的属性 :

在刚刚配置的id = school01的bean对象中，通过property标签为List类型的属性初始化，代码如下 :

        <property name="studentList">
            <list>
                <ref bean="stu03"></ref>
                <ref bean="stu04"></ref>
            </list>
        </property>

注入，除了"通过ref元素配置"的形式外，也可以在List元素中直接配置内部Bean。仍然是在StudentBeanByXML测试类中，我们新定义一个方法测试List属性是否注入成功，injectList()方法代码如下 :

    //5.为Bean注入集合 or 数组类型的属性
        //5.1 注入List类型的属性
    @Test
    public void injectList() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        School school01 = ioc.getBean("school01", School.class);

        System.out.println("School中的studentList属性如下 : ");
        System.out.println(school01.getStudentList());
    }

运行结果 :

3.注入Set类型的属性 :

在“准备工作”中配置的id = school01的bean对象中，通过property标签为Set类型的属性初始化，代码如下 :

        <property name="studentSet">
            <set>
                <ref bean="stu03"></ref>
                <ref bean="stu06"></ref>
            </set>
        </property>

可以看到，Set类型属性的配置和List类型属性的配置非常类似，只不过前者是放在set元素里了。仍然是在StudentBeanByXML测试类中，我们新定义一个方法测试Set属性是否注入成功，injectSet()方法代码如下 :

        //5.2 注入Set类型的属性
    @Test
    public void injectSet() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        School school01 = ioc.getBean("school01", School.class);

        System.out.println("School中的studentSet属性如下 : ");
        System.out.println(school01.getStudentSet());
    }

运行结果 :

4.注入Map类型的属性 :

在“准备工作”中配置的id = school01的bean对象中，通过property标签为Map类型的属性初始化，代码如下 :

        <property name="studentMap">
            <map>
                <!-- entry表示一个键值对  -->
                <entry>
                    <!-- key元素用于配置key，注意此处的value是指key的值，字面意思 -->
                    <key>
                        <value>keyStu05</value>
                    </key>
                    <!-- 紧跟key元素其后的ref元素才是真正的当前键值对的value！ -->
                    <ref bean="stu05"></ref>
                </entry>
                <entry>
                    <key>
                        <value>keyStu06</value>
                    </key>
                    <ref bean="stu06"></ref>
                </entry>
            </map>
        </property>

仍然是在StudentBeanByXML测试类中，我们新定义一个方法测试Map属性是否注入成功，injectMap()方法代码如下 :

        //5.3 注入Map类型的属性
    @Test
    public void injectMap() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        School school01 = ioc.getBean("school01", School.class);

        System.out.println("School中的studentMap属性如下 : ");
        System.out.println(school01.getStudentMap());
    }

运行结果 :

5.注入数组类型的属性 :

在“准备工作”中配置的id = school01的bean对象中，通过property标签为String[]类型的属性初始化，代码如下 :

        <property name="studentNames">
            <array>
            <!-- 由于School类中维护的数组为String类型，所以此处直接以value元素配置 -->
                <value>Cyan</value>
                <value>Rain</value>
                <value>Five</value>
                <value>Ice</value>
            </array>
        </property>

仍然是在StudentBeanByXML测试类中，我们新定义一个方法测试String[]属性是否注入成功，injectArray()方法代码如下 :

        //5.4 注入数组类型的属性
    @Test
    public void injectArray() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        School school01 = ioc.getBean("school01", School.class);

        System.out.println("School中的studentNames属性如下 : ");
        System.out.println(Arrays.toString(school01.getStudentNames()));
    }

运行结果 :

6.注入Properties类型的属性 :

在“准备工作”中配置的id = school01的bean对象中，通过property标签为Properties类型的属性初始化，代码如下 :

        <property name="pros">
            <props>
                <prop key="username">Cyan_RA9</prop>
                <prop key="password">55555233</prop>
                <prop key="ip">127.0.0.1</prop>
            </props>
        </property>

仍然是在StudentBeanByXML测试类中，我们新定义一个方法测试Properties属性是否注入成功，injectProperties()方法代码如下 :

        //5.5 注入Properties类型的属性
    @Test
    public void injectProperties() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        School school01 = ioc.getBean("school01", School.class);

        System.out.println("School中的pros属性如下 : ");
        System.out.println(school01.getPros());
    }

运行结果 :

7.List属性注入之通过util命名空间注入 :

方才我们已经见过了如何通过property元素注入List类型的属性，其实是通过list子元素来实现的。
那么，假设现在给出一个需求：已知成华大道到二仙桥的路上开着两家书店，它们都卖《生死疲劳》《镜花缘》《湘行散记》《明朝那些事儿》《三体》这几本书，让你在beans.xml中配置这俩个书店对象，你能吗？
你可能会说：哟瞧你这话说的，这不是张飞吃豆芽——小菜一碟么？看我一波张飞穿针——粗中有细，给你整得明明白白，服服帖帖。

于是你就开整了，先新定义一个BookStore的JavaBean类，代码如下 :

package com.cyan.spring.bean;

import java.util.List;

public class BookStore {
    private List<String> bookList;

    public BookStore() {
    }
    public BookStore(List<String> bookList) {
        this.bookList = bookList;
    }

    public List<String> getBookList() {
        return bookList;
    }
    public void setBookList(List<String> bookList) {
        this.bookList = bookList;
    }
}

再去beans.xml文件中配置一波，代码如下 :

    <bean class="com.cyan.spring.bean.BookStore" id="bookStore01">
        <property name="bookList">
            <list>
                <value>生死疲劳</value>
                <value>镜花缘</value>
                <value>湘行散记</value>
                <value>明朝那些事儿</value>
                <value>三体</value>
            </list>
        </property>
    </bean>
    <bean class="com.cyan.spring.bean.BookStore" id="bookStore02">
        <property name="bookList">
            <list>
                <value>生死疲劳</value>
                <value>镜花缘</value>
                <value>湘行散记</value>
                <value>明朝那些事儿</value>
                <value>三体</value>
            </list>
        </property>
    </bean>

你还不尽兴，继续去测试类中定义了一个单元测试的方法，设法输出bookList属性进行检验，testMySB()方法代码如下 :

    @Test
    public void testMySB() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        BookStore bookStore01 = ioc.getBean("bookStore01", BookStore.class);
        BookStore bookStore02 = ioc.getBean("bookStore02", BookStore.class);

        System.out.println("bookStore01's bookList = " + bookStore01.getBookList());
        System.out.println("bookStore02's bookList = " + bookStore02.getBookList());
    }

运行结果 :

对此，我只能说：“你™是真🐂B呀”。是的，坦白说你做的针不戳儿。但是呢，假如现在成华大道到二仙桥的路上又开了5家书店，阁下又如何应对呢？
你可能会想：那我再配5个Bean不就完事儿了么，这up🐖怎么磨磨唧唧的，阴阳怪气，你到底想说啥你说呗，整这么绕一大圈子。对此，我想说：“你再配5个Bean也确实能成事儿，但我说你这么配就慢了，我们不仅要配得对，而且要配得快。

于是便要引出util命名空间了。直接上代码 : (当你使用<util:list>时，IDEA会自动帮你引入util命名空间)

    <util:list id="commonBookList">
        <value>生死疲劳</value>
        <value>镜花缘</value>
        <value>湘行散记</value>
        <value>明朝那些事儿</value>
        <value>三体</value>
    </util:list>

    <bean class="com.cyan.spring.bean.BookStore" id="bookStore01">
        <property name="bookList" ref="commonBookList">
        </property>
    </bean>
    <bean class="com.cyan.spring.bean.BookStore" id="bookStore02">
        <property name="bookList" ref="commonBookList">
        </property>
    </bean>

可以看到，其实就是将大家都有的📕放到了<util:list></util:list>元素中，然后在每个BookStore类型的Bean对象中，利用ref引用到<util:list>中。经测试，输出结果是一样的，这里就不再放图了。

8.级联属性注入 :

所谓“级联属性注入”，其实指的是Spring的IOC容器可以直接为“属性的属性”赋值，即当类中的某个属性有自己的属性时，我们希望在配置该类Bean对象时将对象属性和对象属性的属性都注入。

需求 : 定义一个员工类，维护员工id，员工姓名，员工的部门名称三个属性，其中，员工的部门名称通过部门类的deptName属性表示。要求设法实现“级联属性注入”。
首先，我们需要定义员工类和部门类，如下 :
Employee类代码如下 :

package com.cyan.spring.bean;

public class Employee {
    private Integer id;
    private String name;
    private Department department;

    public Employee() {
    }
    public Employee(Integer id, String name, Department department) {
        this.id = id;
        this.name = name;
        this.department = department;
    }

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public Department getDepartment() {
        return department;
    }
    public void setDepartment(Department department) {
        this.department = department;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", department=" + department +
                '}';
    }
}

Department类代码如下:

package com.cyan.spring.bean;

public class Department {
    private String deptName;

    public Department() {
    }
    public Department(String deptName) {
        this.deptName = deptName;
    }

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    @Override
    public String toString() {
        return "Department{" +
                "deptName='" + deptName + '\'' +
                '}';
    }
}

接着，在beans.xml文件中配置Employee对象和Department对象。代码如下 :

    <!-- 配置Employee类对象 -->
    <bean class="com.cyan.spring.bean.Employee" id="employee01">
        <property name="id" value="1"></property>
        <property name="name" value="Cyan"></property>
        <property name="department" ref="department01"></property>
        <!-- [级联属性注入] -->
        <!-- 其实是通过"对象名.属性名"的形式，对属性的属性进行注入操作 -->
        <property name="department.deptName" value="Back-End"></property>
        <!-- 此处，底层实际调用了setDeptName方法 -->
    </bean>
    <!-- 配置Department类对象 -->
    <bean class="com.cyan.spring.bean.Department" id="department01"/>

最后，在测试类StudentBeanByXML中新定义一个单元测试方法，输出配置的Employee对象，查看级联属性注入是否成功。testCascade()方法代码如下 :

    //PS : 测试级联属性赋值
    @Test
    public void testCascade() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        Employee employee01 = ioc.getBean("employee01", Employee.class);

        System.out.println("employee01 = \n" + employee01);
    }

运行结果 :

可以看到，employee对象的属性department的属性deptName被成功初始化，说明级联属性注入成功。

七、通过静态工厂获取Bean

1.基本介绍 :

“通过静态工厂获取Bean”，本质上还是“基于XML方式配置Bean”；只不过我们并不直接在配置Bean时就为Bean对象注入属性，而是事先在静态工厂类的static代码块中完成了初始化（用静态的Map容器来存储Student类对象），并提供了一个静态方法用于获取已经初始化好的Student对象，然后在beans.xml配置文件中，我们只需要给定一个key，并指定调用静态工厂提供的用于获取Student对象的方法，Spring容器便可以根据该key获取到对应的Student类对象。

注意 :

(1) “通过静态工厂获取Bean”，在配置bean时，class不再是Student类的全路径，而是静态工厂类的全路径.

(2) 除了id和class外，还需要一个属性factory-method，表示指定一个静态工厂类的用于返回Bean对象的方法.

(3) 至于bean元素内部，则需要使用<construcotr-arg value="key"/>标签，说明要获取的对象在静态工厂类中对应的key。

2.应用实例 :

上面说了一堆，只是看肯定多少觉得一头雾水，下面我们来个实例感受一下。
首先，up定义一个自己的静态工厂类，CyanStaticFactory类代码如下 :

package com.cyan.spring.factory;

import com.cyan.spring.bean.Student;

import java.util.HashMap;
import java.util.Map;

public class CyanStaticFactory {
    //维护一个静态Map集合，用于保存Student对象
    private static Map<String, Student> studentMap;

    //在静态代码块中初始化Student对象
    static {
        studentMap = new HashMap<>();

        studentMap.put("student01", new Student("Cyan", 21, 450));
        studentMap.put("student02", new Student("Rain", 19, 460));
    }

    //提供一个获取Student对象的静态方法
    public static Student getStudent(String key) {
        return studentMap.get(key);
    }
}

然后在beans.xml文件中完成配置，代码如下 : （注意看up配置的id，表明最终返回的其实是一个Student类对象）

    <bean class="com.cyan.spring.factory.CyanStaticFactory" id="stu07"
        factory-method="getStudent">
        <constructor-arg value="student02"/>
    </bean>

最后，仍然是在测试类StudentBeanByXML中，定义一个单元测试方法，获取到Student对象，
getBeanByStaticFactory()方法代码如下 : （注意此处getBean方法得到的是Student类型的对象）

    //6.通过静态工厂获取Bean
    @Test
    public void getBeanByStaticFactory() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        Student stu07 = ioc.getBean("stu07", Student.class);

        System.out.println(stu07);
    }

运行结果 :

八、通过实例工厂获取Bean

1.基本介绍 :

“通过实例工厂获取Bean”，和通过静态工厂获取Bean类似，只不过见名知意，我们在自定义实例工厂类中通过非静态Map容器来保存Student类对象，并在非静态代码块中对Map容器进行初始化，并提供一个用于获取Student对象的非静态方法。然后在beans.xml文件中，除了指定一个用于获取Bean对象的方法，以及给出key外，必须先指定一个实例工厂对象。

回顾一下代码块——

静态代码块随着类的加载而被隐式地调用，最多只能执行一次；而对于非静态代码块，每实例化一次包含该非静态代码块的类，都会执行一次该类中的非静态代码块。

结合代码块的内容回顾，我们可以猜到：必须先实例化“实例工厂对象”，以执行其非静态代码块中的内容，完成对非静态Map集合的初始化；然后才能获取到其保存的学生对象。

注意 :

(1) “通过实例工厂获取Bean”，在配置bean时，需要同时配置实例工厂对象和学生对象.

(2) 属性factory-method，表示指定一个实例工厂类的用于返回Bean对象的方法；属性factory-bean，表示指定使用一个特定的实例工厂对象返回Bean。

(3) bean元素内部，仍需要使用<construcotr-arg value="key"/>标签，说明要获取的对象在实例工厂类中对应的key。

2.应用实例 :

首先，up定义一个自己的实例工厂类，CyanInstanceFactory类代码如下 :

package com.cyan.spring.factory;

import com.cyan.spring.bean.Student;

import java.util.HashMap;
import java.util.Map;

public class CyanInstanceFactory {
    private Map<String, Student> studentMap;

    {
        studentMap = new HashMap<>();

        studentMap.put("student03", new Student("Eisen", 22, 437));
        studentMap.put("student04", new Student("Five", 20, 429));
    }

    public Student getStudent(String key) {
        return studentMap.get(key);
    }
}

然后在beans.xml文件中完成配置，代码如下 :

    <!-- 配置实例工厂对象 -->
    <bean class="com.cyan.spring.factory.CyanInstanceFactory" id="cyanInstanceFactory01"/>
    <!-- 配置学生对象 -->
    <bean id="stu08" factory-bean="cyanInstanceFactory01" factory-method="getStudent">
        <constructor-arg value="student03"/>
    </bean>

最后，仍然是在测试类StudentBeanByXML中，定义一个单元测试方法，获取到Student对象，
getBeanByInstanceFactory()方法代码如下 :

    //7.通过实例工厂获取Bean
    @Test
    public void getBeanByInstanceFactory() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        Student stu08 = ioc.getBean("stu08", Student.class);

        System.out.println(stu08);
    }

运行结果 :

九、通过FactoryBean获取Bean

1.基本介绍 :

“通过FactoryBean获取Bean”，又和上文中通过实例工厂获取Bean类似，都是维护了一个非静态Map容器来保存Bean对象，并在非静态代码块中对Map容器进行初始化，此外，还需要单独维护一个String类型的key属性。并且，我们需要去实现FactoryBean<>接口，并重写接口中的方法。

注意 :

(1) “通过FactoryBean获取Bean”，在配置bean时，class为FactoryBean的全类名.

(2) 通过property子元素为key属性初始化。

2.应用实例 :

首先，我们需要定义一个自己的FactoryBean类并实现FactoryBean接口，CyanFactoryBean类代码如下 :

package com.cyan.spring.factory;

import com.cyan.spring.bean.Student;
import org.springframework.beans.factory.FactoryBean;

import java.util.HashMap;
import java.util.Map;

public class CyanFactoryBean implements FactoryBean<Student> {
    private String key;
    private Map<String, Student> studentMap;
    {
        studentMap = new HashMap<>();

        studentMap.put("student05", new Student("Irving", 32, 427));
        studentMap.put("student06", new Student("Rose", 23, 431));
    }

    public void setKey(String key) {
        this.key = key;
    }

    @Override
    public Student getObject() throws Exception {
        return studentMap.get(key);
    }

    @Override
    public Class<?> getObjectType() {
        return Student.class;
    }

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

接着，在beans.xml中配置bean对象，代码如下 :

    <!-- 配置Student对象，通过FactoryBean获取 -->
    <bean class="com.cyan.spring.factory.CyanFactoryBean" id="stu09">
        <property name="key" value="student05"/>
    </bean>

最后，在StudentBeanByXML测试类中定义一个单元测试方法，测试是否配置成功。getBeanByFactoryBean()方法代码如下 :

    //8.通过实例工厂获取Bean
    @Test
    public void getBeanByFactoryBean() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        Student stu09 = ioc.getBean("stu09", Student.class);

        System.out.println(stu09);
    }

运行结果 :

十、关于Bean配置的更多内容和细节

由于“Spring IOC—基于XML配置和管理Bean”内容较多，而up写到这里时编辑器已经很卡了😂。故打算将Bean配置信息重用，Bean生命周期，以及Bean后置处理器等内容单独放一篇文章中。

链接如下 :

待更新---🕊🕊

十一、总结

🆗，以上就是Spring系列博文第二小节的全部内容了。
总的来看，Spring 基于XML配置和管理Bean内容很多，我们可以通过多种方式获取Bean或者为Bean注入属性，足以感受到Spring配置和管理Bean的灵活性。再来简单回顾一下上文的总述，如下图所示 :

下一节内容——Spring IOC——基于注解配置和管理Bean。感谢阅读！