基于XML管理Bean

1. 工程准备

搭建子模块spring6-ioc-xml Alt text 拷贝beans.xml、log4j2.xml到spring6-ioc-xml的resource目录下面

2 获取bean

2.1 根据id获取

由于id属性指定了bean的唯一标识，所以根据bean标签的id属性可以精确获取到一个组件对象。

java

@Test
public void testHelloWorld1(){
	ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    HelloWorld bean = ac.getBean("helloWorld");
    bean.sayHello();
}

1.2 根据类型获取

java

@Test
public void testHelloWorld2(){
	ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    HelloWorld bean = ac.getBean(HelloWorld.class);
    bean.sayHello();
}

1.3 根据id和类型

java

@Test
public void testHelloWorld2(){
	ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    HelloWorld bean = ac.getBean("helloworld", HelloWorld.class);
    bean.sayHello();
}

1.4 根据接口类型可以获取bean

编写UserDao.java和UserDaoImpl.java文件以及配置beans.xml：

UserDao.javaUserDaoImpl.javabeans.xml

java

public interface UserDao {
    void getUser();
}

java

public class UserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("User info");
    }
}

xml

<bean id="userDao" class="com.rocket.spring.UserDaoImpl"></bean>

测试运行：

java

public class ApplicationTest {

    private static Logger logger = LoggerFactory.getLogger(ApplicationTest.class);

    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        UserDao userDao = ac.getBean(UserDao.class);
        userDao.getUser();
        logger.info("执行完成");
    }
}

运行结果：
Alt text

注意

当根据类型获取bean时，要求IOC容器中指定类型的bean有且只能有一个:

xml

<!-- 当IOC容器中配置了两个相同类 -->
<bean id="helloworldOne" class="com.rocket.spring.HelloWorld"></bean>
<bean id="helloworldTwo" class="com.rocket.spring.HelloWorld"></bean>

根据类型获取时会抛出异常：
org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.rocket.spring.HelloWorld' available: expected single matching bean but found 2: helloworldOne,helloworldTwo
2. 如果一个接口有多个实现类，这些实现类都配置了bean，根据接口类型可以获取bean吗？
不行，因为bean不唯一
根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果，只要返回的是true就可以认定为和类型匹配，能够获取到。
java中，instanceof运算符用于判断前面的对象是否是后面的类，或其子类、实现类的实例。如果是返回true，否则返回false。也就是说：用instanceof关键字做判断时，instanceof操作符的左右操作必须有继承或实现关系

3. 依赖注入之setter注入

创建学生类Student和配置beans.xml:

spring-di.xmlStudent.java

xml

<bean id="studentOne" class="com.rocket.spring.Student">
    <!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 -->
    <!-- name属性：指定属性名(这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关) -->
    <!-- value属性：指定属性值 -->
    <property name="id" value="1001"></property>
    <property name="name" value="张三"></property>
    <property name="age" value="23"></property>
    <property name="sex" value="男"></property>
</bean>

java

public class Student {

    private Integer id;

    private String name;

    private Integer age;

    private String sex;

    public Student() {
    }

    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 Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

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

测试运行:

java

@Test
public void testDIBySet(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring-di.xml");
    Student studentOne = ac.getBean("studentOne", Student.class);
    System.out.println(studentOne);
}

4. 依赖注入之构造器注入

在Student类中添加有参构造函数,添加配置到beans.xml:

Student.javabeans.xml

java

public Student(Integer id, String name, Integer age, String sex) {
    this.id = id;
    this.name = name;
    this.age = age;
    this.sex = sex;
}

xml

<bean id="studentTwo" class="com.rocket.spring.Student">
    <constructor-arg value="1002"></constructor-arg>
    <constructor-arg value="李四"></constructor-arg>
    <constructor-arg value="33"></constructor-arg>
    <constructor-arg value="女"></constructor-arg>
</bean>

注意

constructor-arg标签还有两个属性可以进一步描述构造器参数：

index属性：指定参数所在位置的索引(从0开始)
name属性：指定参数名

5. 特殊值处理

5.1 字面量赋值

什么是字面量？ int a = 10;
声明一个变量a，初始化为10，此时a就不代表字母a了，而是作为一个变量的名字。当我们引用a的时候，我们实际上拿到的值是10。
而如果a是带引号的：'a'，那么它现在不是一个变量，它就是代表a这个字母本身，这就是字面量。所以字面量没有引申含义，就是我们看到的这个数据本身。比如：

xml

<!-- 使用value属性给bean的属性赋值时，Spring会把value属性的值看做字面量 -->
<property name="name" value="张三"/>

5.2 null值

xml

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

注意：<property name="name" value="null"></property> 以上写法，为name所赋的值是字符串null

5.3 xml实体

xml

<!-- 小于号在XML文档中用来定义标签的开始，不能随便使用 -->
<!-- 解决方案一：使用XML实体来代替 -->
<property name="expression" value="a &lt; b"/>

5.4 CDATA节点

xml

<property name="expression">
    <!-- 解决方案二：使用CDATA节 -->
    <!-- CDATA中的C代表Character，是文本、字符的含义，CDATA就表示纯文本数据 -->
    <!-- XML解析器看到CDATA节就知道这里是纯文本，就不会当作XML标签或属性来解析 -->
    <!-- 所以CDATA节中写什么符号都随意 -->
    <value><![CDATA[a < b]]></value>
</property>

6. 为对象类型属性赋值

创建班级类Clazz, 修改Student类, 在Student类中添加以下代码:

Student.javaClazz.java

java

private Clazz clazz;

public Clazz getClazz() {
	return clazz;
}

public void setClazz(Clazz clazz) {
	this.clazz = clazz;
}

java

public class Clazz {

    private Integer clazzId;

    private String clazzName;

    public Integer getClazzId() {
        return clazzId;
    }

    public void setClazzId(Integer clazzId) {
        this.clazzId = clazzId;
    }

    public String getClazzName() {
        return clazzName;
    }

    public void setClazzName(String clazzName) {
        this.clazzName = clazzName;
    }

    @Override
    public String toString() {
        return "Clazz{" +
                "clazzId=" + clazzId +
                ", clazzName='" + clazzName + '\'' +
                '}';
    }

    public Clazz() {
    }

    public Clazz(Integer clazzId, String clazzName) {
        this.clazzId = clazzId;
        this.clazzName = clazzName;
    }
}

6.1 引用外部bean

beans.xml中配置Clazz类型的bean：

xml

<bean id="clazzOne" class="com.rocket.spring.Clazz">
    <property name="clazzId" value="1111"></property>
    <property name="clazzName" value="财源滚滚班"></property>
</bean>

为Student中的clazz属性赋值：

xml

<bean id="studentFour" class="com.rocket.spring.Student">
    <property name="id" value="1004"></property>
    <property name="name" value="赵六"></property>
    <property name="age" value="26"></property>
    <property name="sex" value="女"></property>
    <!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 -->
    <property name="clazz" ref="clazzOne"></property>
</bean>

错误演示：

xml

<bean id="studentFour" class="com.rocket.spring.Student">
    <property name="id" value="1004"></property>
    <property name="name" value="赵六"></property>
    <property name="age" value="26"></property>
    <property name="sex" value="女"></property>
    <property name="clazz" value="clazzOne"></property>
</bean>

如果错把ref属性写成了value属性，会抛出异常： Caused by: java.lang.IllegalStateException: Cannot convert value of type 'java.lang.String' to required type 'com.rocket.spring.Clazz' for property 'clazz': no matching editors or conversion strategy found 意思是不能把String类型转换成我们要的Clazz类型，说明我们使用value属性时，Spring只把这个属性看做一个普通的字符串，不会认为这是一个bean的id，更不会根据它去找到bean来赋值。

6.2 内部bean

xml

<bean id="studentFour" class="com.rocket.spring.Student">
    <property name="id" value="1004"></property>
    <property name="name" value="赵六"></property>
    <property name="age" value="26"></property>
    <property name="sex" value="女"></property>
    <property name="clazz">
        <!-- 在一个bean中再声明一个bean就是内部bean -->
        <!-- 内部bean只能用于给属性赋值，不能在外部通过IOC容器获取，因此可以省略id属性 -->
        <bean id="clazzInner" class="com.rocket.spring.Clazz">
            <property name="clazzId" value="2222"></property>
            <property name="clazzName" value="远大前程班"></property>
        </bean>
    </property>
</bean>

6.3 级联属性赋值

xml

<bean id="studentFour" class="com.rocket.spring.Student">
    <property name="id" value="1004"></property>
    <property name="name" value="赵六"></property>
    <property name="age" value="26"></property>
    <property name="sex" value="女"></property>
    <property name="clazz" ref="clazzOne"></property>
    <property name="clazz.clazzId" value="3333"></property>
    <property name="clazz.clazzName" value="最强王者班"></property>
</bean>

7. 为数组类型属性赋值

修改Student类, 在Student类中添加以下代码：

Student.javabeans.xml

java

private String[] hobbies;

public String[] getHobbies() {
    return hobbies;
}

public void setHobbies(String[] hobbies) {
    this.hobbies = hobbies;
}

xml

<bean id="studentFour" class="com.rocket.spring.Student">
    <property name="id" value="1004"></property>
    <property name="name" value="赵六"></property>
    <property name="age" value="26"></property>
    <property name="sex" value="女"></property>
    <!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 -->
    <property name="clazz" ref="clazzOne"></property>
    <property name="hobbies">
        <array>
            <value>抽烟</value>
            <value>喝酒</value>
            <value>烫头</value>
        </array>
    </property>
</bean>

8. 为集合类型属性赋值

8.1 为List集合类型属性赋值

在Clazz类中添加以下代码, 配置beans.xml：

Clazz.javabeans.xml

java

private List<Student> students;

public List<Student> getStudents() {
    return students;
}

public void setStudents(List<Student> students) {
    this.students = students;
}

xml

<bean id="clazzTwo" class="com.rocket.spring.Clazz">
    <property name="clazzId" value="4444"></property>
    <property name="clazzName" value="Javaee0222"></property>
    <property name="students">
        <list>
            <ref bean="studentOne"></ref>
            <ref bean="studentTwo"></ref>
            <ref bean="studentThree"></ref>
        </list>
    </property>
</bean>

若为Set集合类型属性赋值，只需要将其中的list标签改为set标签即可。

8.2 为Map集合类型属性赋值

创建教师类Teacher, 在Student类中添加以下代码,配置beans.xml：

Teacher.javaTeacher.javabeans.xml

java

private Map<String, Teacher> teacherMap;

public Map<String, Teacher> getTeacherMap() {
    return teacherMap;
}

public void setTeacherMap(Map<String, Teacher> teacherMap) {
    this.teacherMap = teacherMap;
}

java

public class Teacher {

    private Integer teacherId;

    private String teacherName;

    public Integer getTeacherId() {
        return teacherId;
    }

    public void setTeacherId(Integer teacherId) {
        this.teacherId = teacherId;
    }

    public String getTeacherName() {
        return teacherName;
    }

    public void setTeacherName(String teacherName) {
        this.teacherName = teacherName;
    }

    public Teacher(Integer teacherId, String teacherName) {
        this.teacherId = teacherId;
        this.teacherName = teacherName;
    }

    public Teacher() {

    }
    
    @Override
    public String toString() {
        return "Teacher{" +
                "teacherId=" + teacherId +
                ", teacherName='" + teacherName + '\'' +
                '}';
    }
}

xml

<bean id="teacherOne" class="com.rocket.spring.Teacher">
    <property name="teacherId" value="10010"></property>
    <property name="teacherName" value="大宝"></property>
</bean>

<bean id="teacherTwo" class="com.rocket.spring.Teacher">
    <property name="teacherId" value="10086"></property>
    <property name="teacherName" value="二宝"></property>
</bean>

<bean id="studentFour" class="com.rocket.spring.Student">
    <property name="id" value="1004"></property>
    <property name="name" value="赵六"></property>
    <property name="age" value="26"></property>
    <property name="sex" value="女"></property>
    <!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 -->
    <property name="clazz" ref="clazzOne"></property>
    <property name="hobbies">
        <array>
            <value>抽烟</value>
            <value>喝酒</value>
            <value>烫头</value>
        </array>
    </property>
    <property name="teacherMap">
        <map>
            <entry>
                <key>
                    <value>10010</value>
                </key>
                <ref bean="teacherOne"></ref>
            </entry>
            <entry>
                <key>
                    <value>10086</value>
                </key>
                <ref bean="teacherTwo"></ref>
            </entry>
        </map>
    </property>
</bean>

8.3 引用集合类型的bean

xml

<!--list集合类型的bean-->
<util:list id="students">
    <ref bean="studentOne"></ref>
    <ref bean="studentTwo"></ref>
    <ref bean="studentThree"></ref>
</util:list>
<!--map集合类型的bean-->
<util:map id="teacherMap">
    <entry>
        <key>
            <value>10010</value>
        </key>
        <ref bean="teacherOne"></ref>
    </entry>
    <entry>
        <key>
            <value>10086</value>
        </key>
        <ref bean="teacherTwo"></ref>
    </entry>
</util:map>
<bean id="clazzTwo" class="com.rocket.spring.Clazz">
    <property name="clazzId" value="4444"></property>
    <property name="clazzName" value="Javaee0222"></property>
    <property name="students" ref="students"></property>
</bean>
<bean id="studentFour" class="com.rocket.spring.Student">
    <property name="id" value="1004"></property>
    <property name="name" value="赵六"></property>
    <property name="age" value="26"></property>
    <property name="sex" value="女"></property>
    <!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 -->
    <property name="clazz" ref="clazzOne"></property>
    <property name="hobbies">
        <array>
            <value>抽烟</value>
            <value>喝酒</value>
            <value>烫头</value>
        </array>
    </property>
    <property name="teacherMap" ref="teacherMap"></property>
</bean>

使用util:list、util:map标签必须引入相应的命名空间。

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"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/util
    http://www.springframework.org/schema/util/spring-util.xsd
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">

9. p命名空间

引入p命名空间:

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"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/util
       http://www.springframework.org/schema/util/spring-util.xsd
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

引入p命名空间后，可以通过以下方式为bean的各个属性赋值:

xml

<bean id="studentSix" class="com.rocket.spring.Student"
    p:id="1006" p:name="小明" p:clazz-ref="clazzOne" p:teacherMap-ref="teacherMap"></bean>

10. 引入外部属性文件

①创建外部属性文件jdbc.properties, pom.xml加入相关依赖包, 创建spring-datasource.xml引入属性文件,引入context名称空间:

jdbc.propertiespom.xmlspring-datasource.xml

ini

jdbc.user=root
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
jdbc.driver=com.mysql.cj.jdbc.Driver

xml

<!-- MySQL驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.30</version>
</dependency>
<!-- 数据源 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.15</version>
</dependency>

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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 引入外部属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!-- 使用外部属性 -->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="url" value="${jdbc.url}"/>
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="username" value="${jdbc.user}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>
</beans>

在使用<context:property-placeholder>元素加载外包配置文件功能前，首先需要在XML配置的一级标签 <beans>中添加 context相关的约束。测试运行：

java

@Test
public void testDataSource() throws SQLException {
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring-datasource.xml");
    DataSource dataSource = ac.getBean(DataSource.class);
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
}

11. bean的作用域

在Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围，各取值含义参加下表：

取值	含义	创建对象的时机
singleton(默认)	在IOC容器中，这个bean的对象始终为单实例	IOC容器初始化时
prototype	这个bean在IOC容器中有多个实例	获取bean时

如果是在WebApplicationContext环境下还会有另外几个作用域(但不常用)：

取值	含义
request	在一个请求范围内有效
session	在一个会话范围内有效

创建类User, 配置spring-scope.xml:

User.javaspring-scope.xml

java

package com.rocket.spring;

public class User {

    private Integer id;

    private String username;

    private String password;

    private Integer age;

    public User() {
    }

    public User(Integer id, String username, String password, Integer age) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

xml

<!-- scope属性：取值singleton(默认值)，bean在IOC容器中只有一个实例，IOC容器初始化时创建对象 -->
<!-- scope属性：取值prototype，bean在IOC容器中可以有多个实例，getBean()时创建对象 -->
<bean class="com.rocket.spring.User" scope="prototype"></bean>

运行测试：

java

@Test
public void testBeanScope(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring-scope.xml");
    User user1 = ac.getBean(User.class);
    User user2 = ac.getBean(User.class);
    System.out.println(user1==user2);
}

12. bean生命周期

bean对象创建(调用无参构造器)
给bean对象设置属性
bean的后置处理器(初始化之前)
bean对象初始化(需在配置bean时指定初始化方法)
bean的后置处理器(初始化之后)
bean对象就绪可以使用
bean对象销毁(需在配置bean时指定销毁方法)
IOC容器关闭

12.1 配置初始化和销毁方法

修改类User, 以及配置bean：

User.javabeans.xml

java

public class User {

    private Integer id;

    private String username;

    private String password;

    private Integer age;

    public User() {
        System.out.println("生命周期：1、创建对象");
    }

    public User(Integer id, String username, String password, Integer age) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        System.out.println("生命周期：2、依赖注入");
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void initMethod(){
        System.out.println("生命周期：3、初始化");
    }

    public void destroyMethod(){
        System.out.println("生命周期：5、销毁");
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

xml

<!-- 使用init-method属性指定初始化方法 -->
<!-- 使用destroy-method属性指定销毁方法 -->
<bean class="com.rocket.spring.bean.User" scope="prototype" init-method="initMethod" destroy-method="destroyMethod">
    <property name="id" value="1001"></property>
    <property name="username" value="admin"></property>
    <property name="password" value="123456"></property>
    <property name="age" value="23"></property>
</bean>

注意: 其中的initMethod()和destroyMethod()，可以通过配置bean指定为初始化和销毁的方法测试运行：

java

@Test
public void testLife(){
    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
    User bean = ac.getBean(User.class);
    System.out.println("生命周期：4、通过IOC容器获取bean并使用");
    ac.close();
}

13. bean的后置处理器

bean的后置处理器会在生命周期的初始化前后添加额外的操作，需要实现BeanPostProcessor接口，且配置到IOC容器中，需要注意的是，bean后置处理器不是单独针对某一个bean生效，而是针对IOC容器中所有bean都会执行。
创建bean的后置处理器MyBeanProcessor, 在beans.xml中配置后置处理器：

MyBeanProcessor.javabeans.xmlApplicationTest.java

java

package com.rocket.spring.process;
    
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("☆☆☆" + beanName + " = " + bean);
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("★★★" + beanName + " = " + bean);
        return bean;
    }
}

xml

<!-- bean的后置处理器要放入IOC容器才能生效 -->
<bean id="myBeanProcessor" class="com.rocket.spring.process.MyBeanProcessor"/>

java

public static void main(String[] args) {
    ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    HelloWorld helloWorld = ac.getBean(HelloWorld.class);
    helloWorld.sayHello();
    UserDao userDao = ac.getBean(UserDao.class);
    userDao.getUser();
    logger.info("执行完成");
}

运行测试类：
Alt text

14. FactoryBean

FactoryBean是Spring提供的一种整合第三方框架的常用机制。和普通的bean不同，配置一个FactoryBean类型的bean，在获取bean的时候得到的并不是class属性中配置的这个类的对象，而是getObject()方法的返回值。通过这种机制，Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们。将来我们整合Mybatis时，Spring就是通过FactoryBean机制来帮我们创建SqlSessionFactory对象的。
创建UserFactoryBean.java, 配置spring-factorybean.xml:

FactoryBean.javaUserFactoryBean.javaspring-factorybean.xml

java

package org.springframework.beans.factory;

import org.springframework.lang.Nullable;

public interface FactoryBean<T> {

    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

    @Nullable
    T getObject() throws Exception;

    @Nullable
    Class<?> getObjectType();


    default boolean isSingleton() {
        return true;
    }
}

java

package com.rocket.spring.bean;

public class UserFactoryBean implements FactoryBean<User> {
    @Override
    public User getObject() throws Exception {
        return new User();
    }

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

xml

<bean id="user" class="com.rocket.spring.bean.UserFactoryBean"></bean>

单元测试：

java

@Test
public void testUserFactoryBean(){
    //获取IOC容器
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring-factorybean.xml");
    User user = (User) ac.getBean("user");
    System.out.println(user);
}

15. 基于xml自动装配

自动装配：根据指定的策略，在IOC容器中匹配某一个bean，自动为指定的bean中所依赖的类类型或接口类型属性赋值
创建接口UserController\UserService, 并且UserServiceImpl实现接口UserService, 接口UserDao, 创建类UserDaoImpl实现接口UserDao

UserController.javaUserServiceImpl.javaUserDaoImpl.java

java

package com.rocket.spring.autowire.controller

public class UserController {

    private UserService userService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void saveUser(){
        userService.saveUser();
    }
}

java

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void saveUser() {
        userDao.saveUser();
    }
}

java

public class UserDaoImpl implements UserDao {

    @Override
    public void saveUser() {
        System.out.println("userDao --->保存成功");
    }
}

配置bean:

使用bean标签的autowire属性设置自动装配效果
自动装配方式：byType
byType：根据类型匹配IOC容器中的某个兼容类型的bean，为属性自动赋值
若在IOC中，没有任何一个兼容类型的bean能够为属性赋值，则该属性不装配，即值为默认值null
若在IOC中，有多个兼容类型的bean能够为属性赋值，则抛出异常NoUniqueBeanDefinitionException

xml

<bean id="userController" class="com.rocket.spring.autowire.controller.UserController" autowire="byType"></bean>

<bean id="userService" class="com.rocket.spring.autowire.service.impl.UserServiceImpl" autowire="byType"></bean>

<bean id="userDao" class="com.rocket.spring.autowire.dao.impl.UserDaoImpl"></bean>

自动装配方式：byName
byName：将自动装配的属性的属性名，作为bean的id在IOC容器中匹配相对应的bean进行赋值

xml

<bean id="userController" class="com.rocket.spring.autowire.controller.UserController" autowire="byName"></bean>

<bean id="userService" class="com.rocket.spring.autowire.service.impl.UserServiceImpl" autowire="byName"></bean>
<bean id="userServiceImpl" class="com.rocket.spring.autowire.service.impl.UserServiceImpl" autowire="byName"></bean>

<bean id="userDao" class="com.rocket.spring.autowire.dao.impl.UserDaoImpl"></bean>
<bean id="userDaoImpl" class="com.rocket.spring.autowire.dao.impl.UserDaoImpl"></bean>

运行测试：

java

@Test
public void test3(){
    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("spring-autowire.xml");
    UserController userController = (UserController) ac.getBean("userController");
    userController.saveUser();
    ac.close();
}

执行结果：
Alt text

基于XML管理Bean ​

1. 工程准备 ​

2 获取bean ​

2.1 根据id获取 ​

1.2 根据类型获取 ​

1.3 根据id和类型 ​

1.4 根据接口类型可以获取bean ​

3. 依赖注入之setter注入 ​

4. 依赖注入之构造器注入 ​

5. 特殊值处理 ​

5.1 字面量赋值 ​

5.2 null值 ​

5.3 xml实体 ​

5.4 CDATA节点 ​

6. 为对象类型属性赋值 ​

6.1 引用外部bean ​

6.2 内部bean ​

6.3 级联属性赋值 ​

7. 为数组类型属性赋值 ​

8. 为集合类型属性赋值 ​

8.1 为List集合类型属性赋值 ​

8.2 为Map集合类型属性赋值 ​

8.3 引用集合类型的bean ​

9. p命名空间 ​

10. 引入外部属性文件 ​

11. bean的作用域 ​

12. bean生命周期 ​

12.1 配置初始化和销毁方法 ​

13. bean的后置处理器 ​

14. FactoryBean ​

15. 基于xml自动装配 ​

基于XML管理Bean

1. 工程准备

2 获取bean

2.1 根据id获取

1.2 根据类型获取

1.3 根据id和类型

1.4 根据接口类型可以获取bean

3. 依赖注入之setter注入

4. 依赖注入之构造器注入

5. 特殊值处理

5.1 字面量赋值

5.2 null值

5.3 xml实体

5.4 CDATA节点

6. 为对象类型属性赋值

6.1 引用外部bean

6.2 内部bean

6.3 级联属性赋值

7. 为数组类型属性赋值

8. 为集合类型属性赋值

8.1 为List集合类型属性赋值

8.2 为Map集合类型属性赋值

8.3 引用集合类型的bean

9. p命名空间

10. 引入外部属性文件

11. bean的作用域

12. bean生命周期

12.1 配置初始化和销毁方法

13. bean的后置处理器

14. FactoryBean

15. 基于xml自动装配