SpringIOC

控制翻转，bean交由spring创建，那么spring是怎么创建bean的呢？

先说Bean的生命周期：

1. 将Bean的相关信息读取成BeanDefinition存放到BeanDefinitionMap

2. 执行BeanFactoryPostProcessor处理器（Bean工厂后置处理器），对BeanDefinition进行自定义处理

3. 实例化:new Class()

4. 依赖注入，这个环节存在循环依赖问题

5. 实现Aware接口，Aware相关接口辅助属性填充

6. 执行BeanPostProcessor前置处理

7. 调用bean指定的init()方法

   (1)指定init方法

   (2)实现InitializingBean接口

8. 执行BeanPostProcessor后置处理（Bean后置处理器），至此得到一个完整的Bean，存入SigletonObjects

9. 销毁

可以通过以下几段测试代码，进行验证

@Component  
public class TestBean2 implements BeanFactoryAware {
    /**  
    * 初始化方法的另一种实现方式
    */  
    //public class TestBean2 implements InitializingBean, BeanFactoryAware {  

    private String name;  
    private String age;  

    /**  
    * 测试bean的属性填充  
    */  
    @Resource  
    private TestBean2Properties testBean2Properties;  

    public TestBean2() {  
        System.out.println("<====== TestBean2 实例化 ======>");  
    }  

    /**  
    * 初始化方法  
    */  
    @PostConstruct  
    public void init() {  
        System.out.println("<====== TestBean2 init 初始化 ======>");  
    }  

    /**  
    * 销毁方法  
    */  
    @PreDestroy  
    public void destroy() {  
        System.out.println("<====== TestBean2 init 销毁 ======>");  
    }  

    public String getName() {  
        return name;  
    }  

    public void setName(String name) {  
        this.name = name;  
    }  

    public String getAge() {  
        return age;  
    }  

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

    /**  
    * 属性设置之后调用（实现InitializingBean初始化）  
    *  
    * @throws Exception  
    */  
    // @Override  
    // public void afterPropertiesSet() throws Exception {  
        // System.out.println("<====== TestBean2 初始化 ======>");  
    // }  

    @Override  
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {  
        System.out.println("<====== TestBean2 实现aware接口 ======>");  
    }  
}

@Component  
public class TestBean2Properties {  
    private String value1;  
    private String value2;  

    public TestBean2Properties() {  
        System.out.println("<====== TestBean2依赖注入 ======>");  
    }  
}

/**  
* Bean工厂后置处理器  
* bean生命周期那个环节起作用：  
* 在beanDefinitionMap填充完毕后回调该方法  
* 什么用：  
* 对需要自定义处理的beanDefinition进行增强（做处理）  
*/  
@Component  
//public class TestBeanFactoryProcessor implements BeanFactoryPostProcessor {  
public class TestBeanFactoryProcessor implements BeanDefinitionRegistryPostProcessor {  
  
  
/**  
* 通过这个方法对特定beanDefinition做一些处理  
*  
* @param beanFactory  
* @throws BeansException  
*/  
@Override  
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {  
boolean annotationPresent = TestBean2.class.isAnnotationPresent(Component.class);  
if (annotationPresent) {  
System.out.println("<====== TestBean2 ,经过了BeanFactoryPostProcessor处理 ======>");  
}  
}  
  
/**  
* BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子类  
* 这个方法是在beanDefinitionMap填充后再注入一些自定义的beanDefinition  
*  
* @param beanDefinitionRegistry  
* @throws BeansException  
*/  
@Override  
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {  
// RootBeanDefinition beanDefinition = new RootBeanDefinition();  
// beanDefinition.setBeanClassName("com.ppx.spring.bean.TestBeanDefinitionRegistryPostProcessorBean");  
// beanDefinitionRegistry.registerBeanDefinition("tbdrpb", beanDefinition);  
}  
}

/**  
* bean后置处理器  
*/  
@Component  
public class TestBeanPostProcessor implements BeanPostProcessor {  
  
/**  
* 前置处理  
*  
* @param bean  
* @param beanName  
* @return  
* @throws BeansException  
*/  
@Override  
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {  
  
if (bean instanceof TestBean2) {  
System.out.println("<====== testBean2 postProcessBeforeInitialization ======>");  
// TestBean2 bean2 = (TestBean2) bean;  
// bean2.setName("2B");  
return bean;  
} else {  
System.out.println("<------ " + beanName + " postProcessBeforeInitialization ------>");  
}  
return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);  
}  
  
/**  
* 后置处理  
*  
* @param bean  
* @param beanName  
* @return  
* @throws BeansException  
*/  
@Override  
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {  
  
if (bean instanceof TestBean2) {  
System.out.println("<====== testBean2 postProcessAfterInitialization ======>");  
// TestBean2 bean2 = (TestBean2) bean;  
// bean2.setAge("18");  
return bean;  
} else {  
System.out.println("<------ " + beanName + " postProcessAfterInitialization ------>");  
}  
return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);  
}  
}