1. IOC操作Bean管理（FactoryBean）

1. Spring有两种类型bean，一种是普通bean，另一种是工厂bean

2. 普通bean：在配置文件中定义bean类型就是返回类型

3. 工厂bean：配置文件定义bean类型可以和返回类型不一样

1. 创建类，让这个类作为工厂 bean，实现接口 FactoryBean
2. 实现接口里面的方法，在实现的方法中定义返回的 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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

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

</beans>

package com.fickler.spring5.factorybean;

import com.fickler.spring5.Course;
import org.springframework.beans.factory.FactoryBean;

/**
 * @author dell
 * @version 1.0
 */
public class MyBean implements FactoryBean<Course> {


    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setName("abc");
        return course;
    }

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

3. 测试输出

2. IOC操作Bean管理（bean作用域）

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

    @Test
    public void testCollection1(){

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean6.xml");

        Book book1 = applicationContext.getBean("book", Book.class);
        Book book2 = applicationContext.getBean("book", Book.class);
//        book.test();
        System.out.println(book1);
        System.out.println(book2);

    }

两次输出的地址相同，说明默认情况下是单实例对象

2. 如何设置单实例还是多实例

1. 在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例
2. scope 属性值
   默认值，singleton，表示是单实例对象
   prototype，表示是多实例对象

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

地址不再相同，说明是多实例对象

3. singleton 和 prototype 区别
   • sing’leton ：加载 spring 配置文件时候就会创建单实例对象
   • prototype ：不是在加载 spring 配置文件时候创建对象，而是在调用 getBean 方法时候创建多实例对象

3. IOC操作Bean管理（bean生命周期）

1. 声明周期

从对象创建到对象销毁的过程

2. bean声明周期

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

3. 演示bean生命周期

package com.fickler.spring5.bean;

/**
 * @author dell
 * @version 1.0
 */
public class Orders {

    private String name;

    public Orders() {
        System.out.println("第一步 执行无参数构造创建 bean 实例");
    }

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

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

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

<?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 id="orders" class="com.fickler.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="手机"></property>
    </bean>

</beans>

    @Test
    public void testBean3(){

        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("bean8.xml");

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

    }

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

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

package com.fickler.spring5.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.lang.Nullable;

/**
 * @author dell
 * @version 1.0
 */
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.fickler.spring5.bean.MyBeanPost"></bean>