SpringBean生命周期管理系列之三Spring创建对象的流程框架

　　Spring Bean与Java Bean相比较，就是由Spring IOC容器负责实例化、组装、管理，而Java Bean需要用户自己创建、管理和使用，其基本流程是创建对象（new一个对象），使用对象，使用完成之后JVM自动进行垃圾回收。Spring Bean在整个生命周期，提供了很多的切入点，用户可以根据实际的情况进行干预，在确定主线的前提下，最大化的提供灵活性。
　　在一边Spring跟源码，一边分析之后，画出了Spring Bean的生命周期如下图所示：
　　Spring Bean创建流程框架Spring Bean创建流程框架
　　根据上图，可以看出启动Java程序，首先启动JVM，然后找到main入口类，开始Spring Bean的生命周期。
　　第一，进行Spring容器的准备工作，创建容器工厂，创建Spring容器，创建BeanFactory；
　　第二，扫描XML和注解，把Bean包装成BeanDefinition放在beanDefinitionMap中；
　　第三，调用BeanFactoryPostProcessor的后置处理器方法；
　　第四，进行对象实例化之前，可以调用InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation方法；
　　第五，实例化，根据构造函数创建对象；
　　第六，实例化之后，调用InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation方法；
　　第七，实例化之后，调用InstantiationAwareBeanPostProcessor.postProcessProperties方法；
　　第八，设置对象的属性，通过Spring的依赖注入实现；
　　第九，如果实现了Aware接口，则引入相对应的对象作为类的变量；
　　第十，对象初始化之前，调用Bean后置处理器postProcessBeforeInitialization方法；
　　第十一，对象初始化，即调用InitializingBean.afterPropertiesSet方法或调用init-method方法；
　　第十三，对象初始化之后，调用Bean后置处理器postProcessAfterInitialization方法；
　　第十四，如果生成的对象为singleton类型，则存放入Spring容器，供程序使用，使用完成之后，会调用DisposableBean.destroy方法，调用destroy-method方法；如果生成的对象为prototype类型，则用户自己管理，重新向Spring容器获取对象时，会重新创建一个新对象。职责划分
　　弄清楚Spring Bean的生命周期，尤其是可以干预点，特别的重要，因为Spring的重要特性都是通过这些切入点完成的，比如AOP、IOC等。其实从整个过程来看，我们简单从层次的角度做一下划分。
　　第一层，是JVM层，Java程序要运行必须要先启动JVM，JVM的启动流程和原理这里就不展开了；
　　第二层，是Spring工厂层，这一层主要通过BeanFactoryProcessor，及其子接口来实现；
　　第三层，是Spring容器类，是Spring的重点，主要是InstantiationAwareBeanPostProcessor、BeanPostProcessor等后置处理器，这些处理器对于所有Spring容器的Bean都起作用，这一点特别重要 。
　　第四层，类自身的方法，比如构造函数、getter和setter函数、实现的InitializingBean, BeanNameAware, DisposableBean,ApplicationContextAware等接口。代码实现
　　Listen类：@Component public class Listen implements InitializingBean, BeanNameAware, DisposableBean,ApplicationContextAware {     private String who;     private String how;     private String when;      public  Listen()     {      }     public Listen(String who,String how,String when){         this.who = who;         this.how = how ;         this.when = when;         System.out.println(＂======Listen 调用构造函数＂);     }      public String getWho() {         return who;     }     @Value(＂${english.listen.who}＂)     public void setWho(String who) {         this.who = who;         System.out.println(＂======Listen 调用属性注入{who}＂);     }      public String getHow() {         return how;     }      @Value(＂${english.listen.how}＂)     public void setHow(String how) {         this.how = how;         System.out.println(＂======Listen 调用属性注入{how}＂);     }      public String getWhen() {         return when;     }      @Value(＂${english.listen.when}＂)     public void setWhen(String when) {         this.when = when;         System.out.println(＂======Listen 调用属性注入{when}＂);     }      public void myInit(){         System.out.println(＂======Listen 调用init-method方法＂);     }      public void myDestroy(){         System.out.println(＂======Listen 调用destroy-method方法＂);     }      @Override     public void setBeanName(String name) {         System.out.println(＂======Listen 调用BeanNameAware.setBeanName方法＂);     }      @Override     public void destroy() throws Exception {         System.out.println(＂======Listen 调用DisposableBean.destroy方法＂);     }      @Override     public void afterPropertiesSet() throws Exception {         System.out.println(＂======Listen 调用InitializingBean.afterPropertiesSet方法＂);     }      @Override     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {         System.out.println(＂======Listen 调用ApplicationContextAware.ApplicationContextAware方法＂);     } }
　　TestBeanFactoryPostProcessor类：@Component public class TestBeanFactoryPostProcessor implements BeanFactoryPostProcessor {     @Override     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {         System.out.println(＂======TestBeanFactoryPostProcessor 调用BeanFactoryPostProcessor.postProcessBeanFactory方法＂);     } }
　　TestBeanPostProcessor类：@Component public class TestBeanPostProcessor implements BeanPostProcessor, InstantiationAwareBeanPostProcessor {     public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {         System.out.println(＂======TestBeanPostProcessor 调用InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation: beanName = ＂+beanName);         return null;     }      public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {         System.out.println(＂======TestBeanPostProcessor 调用InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation: beanName = ＂+beanName);         return true;     }      public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)             throws BeansException {         System.out.println(＂======TestBeanPostProcessor 调用InstantiationAwareBeanPostProcessor.postProcessProperties: beanName = ＂+beanName);         return null;     }        @Nullable     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {         System.out.println(＂======TestBeanPostProcessor 调用BeanPostProcessor.postProcessBeforeInitialization方法: beanName = ＂+beanName);         return bean;     }      @Nullable     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {         System.out.println(＂======TestBeanPostProcessor 调用BeanPostProcessor.postProcessAfterInitialization方法: beanName = ＂+beanName);         return bean;     } }
　　MyEnglishMain入口函数：这里采用单独加载特定类的方式，以减少干扰信息。public class MyEnglishMain {     public static void main(String[] args) {         ApplicationContext applicationContext = new ClassPathXmlApplicationContext(＂TestBean.xml＂);         Listen listen =(Listen) applicationContext.getBean(＂listen＂);         ((AbstractApplicationContext)applicationContext) .close();     } }
　　TestBean.xml配置文件<?xml version=＂1.0＂ encoding=＂UTF-8＂?>                                                                                                   
　　执行结果：这里删除了其他无关信息
　　执行结果特殊说明
　　1、如果一个类实现了InitializingBean, BeanNameAware, DisposableBean,ApplicationContextAware，也实现了BeanFactoryPostProcessor、BeanPostProcessor、InstantiationAwareBeanPostProcessor接口，Spring会首先构造实现BeanFactoryPostProcessor、BeanPostProcessor、InstantiationAwareBeanPostProcessor接口的类，导致BeanNameAware、InitializingBean在前执行。
　　2、一定要自己去跟代码，你想获得比单纯看博客文章多得多的知识，和更深的理解。同时也要去看博客，建立一个框架，然后跟源码，不停的调整框架，形成自己的独有的认知框架。