Spring执行流程和Bean的生命周期

1、Spring执行流程

Spring执行流程（Bean执行流程）：1、在启动类中遇到了ApplicationContext的时候就会启动 Spring 容器 -> 2、根据容器设置的配置文件，去找相应的配置文件； ->3、如果有base-package，那么就去base-package里循环找所有的类，看有没有五大类注解和方法注解； ->4、 如果有注解，进行初始化和属性依赖赋值

2、Bean的生命周期（重点）

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

Bean的生命周期可分为以下5大部分：

1. 实例化Bean：为Bean分配空间

2. **设置属性：**为Bean注入属性和装配属性

3. Bean初始化：

   • 实现各种通知方法：BeanNameAware、BeanFactoryAware、ApplicationContextAware的接口方法。

   • 执行前置方法(BeanPostProcessor接口)

   • 执行初始化方法（设置了才会执行）

     • 注解方式：@PostConstruct，依赖注入后被执行（优先级高，主流方式）
     • xml方式：init-method ⽅法

   • 执行后置方法(BeanPostProcessor接口)

4.使用Bean

5.销毁Bean：@PreDestroy、DisposableBean 接⼝⽅法、destroy-method。

图示化流程：

伪代码流程（xml方式）：

public class BeanLife implements BeanNameAware, BeanFactoryAware, BeanPostProcessor {
    /*
        各种通知
     */
    @Override
    public void setBeanName(String s) {
        //s 是设置的Bean名称
        System.out.println("执行了通知：BeanNameAware - > BeanName = "+s);
    }
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("执行了通知：BeanFactoryAware");
    }
    /*
        前置方法 ：默认情况不会显式调用
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行了前置方法：postProcessBeforeInitialization");
        return bean;
    }
    /*
        初始化
     */
    public void myInit(){
        System.out.println("执行了xml方式的初始化 - > init-method");
    }
    @PostConstruct
    public void doPostConstruct(){
        System.out.println("执行了注解的初始化 - > PostConstruct");
    }
    /*
        后置方法 ：默认情况不会显式调用
     */

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行了后置方法：postProcessAfterInitialization");
        return bean;
    }

    //使用Bean
    public void sayHi(){
        System.out.println("使用Bean -> sayHi()");
    }
    
    /*
        销毁方法
     */
    @PreDestroy
    public void doPreDestroy(){
        System.out.println("执行了销毁方法：PreDestroy");
    }


}

前置方法和后置方法： 默认不会显式调用

​ 1.可以把作用域改为prototype

xml配置：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:content="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 https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="beanLife" class="com.spring.demo.BeanLife" scope="prototype" init-method="myInit">bean>
beans>

启动类：

public class App {
    public static void main(String[] args) {
        //此处使用ClassPathXmlApplicationContext，因为ApplicationContext没有销毁方法
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.config.xml");
        BeanLife beanLife = context.getBean("beanLife",BeanLife.class);
       //使用bean
        beanLife.sayHi();
        //销毁容器(bean也就销毁了)
        context.destroy();
    }
}

执行结果：

2.1、实例化和初始化的区别

实例化和属性设置是java级别的系统“事件”，其操作过程不可人为干预和修改；而初始化是给开发者提供的，可以在实例化之后，类加载完成之前进行自定义“事件”处理。

2.2、为什么先设置属性再进行初始化呢？

因为在初始化阶段可能会用到bean的属性和方法；如果不先设置属性，先初始化，那么在初始化阶段使用属性，就报错了；因为属性此时还没装配呢。

@Controller
public class BController {
    @Autowired
    private User user1;//设置属性

    @PostConstruct//初始化
    public void say(){
        //再初始化中使用了user1里的属性
        System.out.println(user1.toString());
    }
}
vate User user1;//设置属性

    @PostConstruct//初始化
    public void say(){
        //再初始化中使用了user1里的属性
        System.out.println(user1.toString());
    }
}