Spring5入门学习三——IOC（XML）

1、什么是 IOC

（1）控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理

（2）使用 IOC 目的：为了耦合度降低

（3）入门案例就是 IOC 实现

2、IOC 底层原理

xml 解析、工厂模式、反射

3、BeanFactory 接口

3.1 IOC 思想基于IOC容器完成，IOC容器底层就是对象工厂

3.2 Spring 提供IOC容器实现两种方式：（两个接口）

• BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用（加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象）
• ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用（加载配置文件时候就会把配置文件中配置的对象进行创建） 

3.3 ApplicationContext 接口的实现类

• ClassPathXmlApplicationContext
• FileSystemXmlApplicationContext

4、什么是 Bean 管理

Bean 管理指的是两个操作：
（1）创建对象
（2）注入属性

5、Bean 管理操作有两种方式

（1）基于 xml 配置文件方式实现
（2）基于注解方式实现

6、基于 xml 方式

6.1 创建对象

    <!--配置User对象创建-->
    <bean id="user" class="com.cui.User"></bean>

（1）在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建
（2）在 bean 标签有很多属性，介绍常用的属性
         * id 属性：唯一标识
         * class 属性：类全路径（包类路径）
（3）创建对象时候，默认执行无参数构造方法完成对象创建

6.2 注入属性

DI：依赖注入（是IOC中一种具体实现）

6.3 第一种注入方式：使用 set 方法进行注入

（1）创建类，定义属性和对应的 set 方法

/**
* 演示使用 set 方法进行注入属性
*/
public class Book {
    //创建属性
    private String bname;
    private String bauthor;

    //创建属性对应的 set 方法
    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }

}

（2）在 spring 配置文件配置对象创建，配置属性注入

<!--set 方法注入属性-->
<bean id="book" class="com.cui.Book">
    <!--使用 property 完成属性注入 
        name：类里面属性名称 
        value：向属性注入的值-->
    <property name="bname" value="天龙八部"></property>
    <property name="bauthor" value="金庸"></property>
</bean>

6.4 第二种注入方式：使用有参数构造进行注入

（1）创建类，定义属性，创建属性对应有参数构造方法

/**
* 使用有参数构造注入
*/
public class Orders {
    //属性
    private String oname;
    private String address;

    //有参数构造
    public Orders(String oname,String address) {
        his.oname = oname;
        this.address = address;
    }
}

（2）在 spring 配置文件中进行配置

<!--有参数构造注入属性-->
<bean id="orders" class="com.cui.Orders">
    <constructor-arg name="oname" value="电脑"></constructor-arg>
    <constructor-arg name="address" value="China"></constructor-arg>
</bean>

6.5 p 名称空间注入（了解）

使用 p 名称空间注入，可以简化基于 xml 配置方式

• 第一步 添加 p 名称空间在配置文件中
• 第二步 进行属性注入，在 bean 标签里面进行操作

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

    <!--注入属性-->
    <bean id="book" class="com.cui.Book" p:bname="天龙八部" p:bauthor="金庸"></bean>
</beans>

6.6 注入其他类型属性

• 字面量

（1）null 值

<!--null 值-->
<property name="address">
    <null/>
</property>

（2）属性值包含特殊符号

<!--属性值包含特殊符号
 1 把<>进行转义 &lt; &gt;
 2 把带特殊符号内容写到 CDATA
-->
<property name="address">
    <value><![CDATA[<<南京>>]]></value>
</property>

• 注入属性-外部 bean

（1）创建两个类 service 类和 dao 类

（2）在 service 调用 dao 里面的方法

（3）在 spring 配置文件中进行配置

public interface UserDao {
    public void update();

}

public class UserDaoImpl implements UserDao{
    @Override
    public void update() {
        System.out.println("dao update......");
    }
}

public class UserService {
    //创建 UserDao 类型属性，生成 set 方法
    private UserDao userDao;

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

    public void add() {
        System.out.println("service add...............");
        userDao.update();
    }
}

<!--1 service 和 dao 对象创建-->
<bean id="userService" class="com.cui.service.UserService">
    <!--注入 userDao 对象
        name 属性：类里面属性名称
        ref 属性：创建 userDao 对象 bean 标签 id 值
    -->
    <property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.cui.dao.UserDaoImpl"></bean>

• 注入属性-内部 bean

（1）一对多关系：部门和员工

一个部门有多个员工，一个员工属于一个部门；部门是一，员工是多

（2）在实体类之间表示一对多关系，员工和所属部门，使用对象类型属性进行表示

//部门类
public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }

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

//员工类
public class Emp {
    private String ename;
    private String gender;

    //员工属于某一个部门，使用对象形式表示
    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "ename='" + ename + '\'' +
                ", gender='" + gender + '\'' +
                ", dept=" + dept +
                '}';
    }
}

（3）在 spring 配置文件中进行配置

    <!--内部 bean-->
    <bean id="emp" class="com.cui.bean.Emp">
        <property name="ename" value="Lucy"></property>
        <property name="gender" value="女"></property>

        <property name="dept">
            <bean id="dept" class="com.cui.bean.Dept">
                <property name="dname" value="安保部"></property>
            </bean>
        </property>
    </bean>

• 注入属性-级联赋值

继续使用内部bean中员工和部门的例子

（1）第一种

    <!--级联赋值  第一种写法-->
    <bean id="emp" class="com.cui.bean.Emp">
        <property name="ename" value="Lucy"></property>
        <property name="gender" value="女"></property>

        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="com.cui.bean.Dept">
        <property name="dname" value="安保部"></property>
    </bean>

（2）第二种

员工类中生成部门的get方法

public Dept getDept() {
        return dept;
    }

    <!--级联赋值  第二种写法-->
    <bean id="emp" class="com.cui.bean.Emp">
        <property name="ename" value="Lucy"></property>
        <property name="gender" value="女"></property>

        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="技术部"></property>
    </bean>
    <bean id="dept" class="com.cui.bean.Dept">
        <property name="dname" value="安保部"></property>
    </bean>

6.7 xml 注入集合属性

• 注入数组类型属性
• 注入 List 集合类型属性
• 注入 Map 集合类型属性

（1）创建类，定义数组、list、map、set 类型属性，生成对应 set 方法

public class Student {

    private String[] courses;

    private List<String> list;

    private Map<String,String> maps;

    private Set<String> sets;

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    @Override
    public String toString() {
        return "Student{" +
                "courses=" + Arrays.toString(courses) +
                ",\n list=" + list +
                ",\n maps=" + maps +
                ",\n sets=" + sets +
                ",\n courseList=" + courseList +
                '}';
    }
}

（2）在 spring 配置文件进行配置

    <bean id="student" class="com.cui.collectiontype.Student">
        <!--数组类型属性注入-->
        <property name="courses">
            <array>
                <value>Java课程</value>
                <value>数据库课程</value>
                <value>Spring课程</value>
                <value>Mybatis课程</value>
            </array>
        </property>
        <!--list 类型属性注入-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>李四</value>
            </list>
        </property>
        <!--map 类型属性注入-->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>
        <!--set 类型属性注入-->
        <property name="sets">
            <set>
                <value>MySQL</value>
                <value>Redis</value>
            </set>
        </property>
    </bean>

• 在集合里面设置对象类型值

Student类中添加属性以及对应的set方法

private List<Course> courseList;

public void setCourseList(List<Course> courseList) {
    this.courseList = courseList;
}

    <bean id="student" class="com.cui.collectiontype.Student">
        
        <!--注入 list 集合类型，值是对象-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>

    </bean>

    <!--创建多个 course 对象-->
    <bean id="course1" class="com.cui.collectiontype.Course">
        <property name="cname" value="Spring5框架"></property>
    </bean>
    <bean id="course2" class="com.cui.collectiontype.Course">
        <property name="cname" value="MyBatis框架"></property>
    </bean>

• 把集合注入部分提取出来

（1）在 spring 配置文件中引入名称空间 util

（2）使用 util 标签完成 list 集合注入提取

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

    <!--1 提取 list 集合类型属性注入-->
    <util:list id="booklist">
        <value>天龙八部</value>
        <value>水浒传</value>
        <value>射雕英雄传</value>
    </util:list>

    <bean id="book" class="com.cui.collectiontype.Book">
        <property name="list" ref="booklist"></property>
    </bean>
</beans>

7、FactoryBean

Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）

7.1 普通 bean

在配置文件中定义 的bean 类型就是返回类型

7.2 工厂 bean：

在配置文件定义 的bean 类型可以和返回类型不一样

• 第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean
• 第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型

public class MyBean implements FactoryBean<Course> {

    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course=new Course();
        course.setCname("abc");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

<bean id="myBean" class="com.cui.factorybean.MyBean"></bean>

测试：

    @Test
    public void test3(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean3.xml");

        Course myBean = context.getBean("myBean", Course.class);

        System.out.println(myBean);
    }

8、bean 作用域

在 Spring 里面，设置创建 bean 实例是单实例还是多实例？

8.1 在 Spring 里面，默认情况下，bean 是单实例对象

    @Test
    public void test2(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean2.xml");

        Book book1 = context.getBean("book", Book.class);
        Book book2 = context.getBean("book", Book.class);
        System.out.println(book1.equals(book2));
    }

测试结果：

8.2 如何设置单实例还是多实例？

（1）在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例

（2）scope 属性值：默认值，singleton，表示是单实例对象； prototype，表示是多实例对象

    <bean id="book" class="com.cui.collectiontype.Book" scope="prototype">
        <property name="list" ref="booklist"></property>
    </bean>

测试结果：

（3）singleton 和 prototype 区别

• 设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象
• 设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象，而是在调用getBean 方法时候创建多实例对象

9、bean 生命周期

9.1 bean 生命周期

生命周期是指从对象创建到对象销毁的过程。

• （1）通过构造器创建 bean 实例（无参数构造）
• （2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
• （3）调用 bean 的初始化的方法（需要进行配置初始化的方法）
• （4）bean 可以使用了（对象获取到了）
• （5）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

9.2 演示 bean 生命周期

public class Orders {

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步，调用set方法设置属性值");
    }

    public Orders() {
        System.out.println("第一步，无参构造");
    }

    public void initMethod(){
        System.out.println("第三步，执行初始化方法");
    }

    public void destroyMethod(){
        System.out.println("第五步 执行销毁方法");
    }
}

    <bean id="orders" class="com.cui.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oname" value="手机"></property>
    </bean>

测试

    @Test
    public void test4(){
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean4.xml");

        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("第四步 获取bean实例对象");
        System.out.println(orders);

        context.close();
    }

结果：

9.3 bean 的后置处理器，bean 生命周期有七步

• （1）通过构造器创建 bean 实例（无参数构造）
• （2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
• （3）把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization 
• （4）调用 bean 的初始化的方法（需要进行配置初始化的方法）
• （5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
• （6）bean 可以使用了（对象获取到了）
• （7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

9.4 演示添加后置处理器效果

public class MyBeanPost implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化后执行的方法");
        return bean;
    }
}

    <!--配置后置处理器-->
    <bean id="myBeanPost" class="com.cui.bean.MyBeanPost"></bean>

再次执行步骤6.3的测试方法test3()：

10、xml自动装配

10.1 什么是自动装配

根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入

10.2 演示自动装配过程

（1）根据属性名称自动注入

    <!--实现自动装配
        bean 标签属性 autowire，配置自动装配
        autowire 属性常用两个值：
        byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
        byType 根据属性类型注入
    -->
    <bean id="emp" class="com.cui.autowrite.Emp" autowire="byName">
        <!--        <property name="dept" ref="dept"></property>-->
    </bean>

    <bean id="dept" class="com.cui.autowrite.Dept"></bean>

（2）根据属性类型自动注入 

    <!--实现自动装配
        bean 标签属性 autowire，配置自动装配
        autowire 属性常用两个值：
        byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
        byType 根据属性类型注入
    -->
    <bean id="emp" class="com.cui.autowrite.Emp" autowire="byType">
        <!--        <property name="dept" ref="dept"></property>-->
    </bean>

    <bean id="dept" class="com.cui.autowrite.Dept"></bean>