Spring Bean 的声明周期

Bean 的生命周期：

第一步：实例化bean(也就是调用无参构造)

第二步：赋值Bean,也就是给Bean的属性赋值(调用Bean中的set方法)

              --执行"Bean处理器"的before 方法！

第三步：初始化bean(也就是调用Bean中的init方法：注意这个方法需要自己编写，自己配)

              --执行"Bean处理器"的after 方法 第四步：使用bean

第五步：销毁bean(调用Bean中的destroy方法：注意这个方法需要自己编写，)

Bean 的生命周期的十步：

点位1 ： 在"Bean后处理器"的before方法之前执行 :
        会检查Bean是否实现了Aware的相关接口，如果实现了接口则会调用这些接口中的方法，
        然后调用这些方法的目的时为了给你传递一些数据，让你更加方便的使用 Aware相关的接口包括 BeanNameAware :
        当Bean实现了BeanNameAware ，Spring会将Bean的名字传递给Bean 
        BeanClassLoaderAware : 会将加载该Bean的类加载器传递给Bean         
        BeanFactoryAware : 会将Bean工长对象传递给Bean

点位2 ： 在"Bean后处理器"的before方法之后执行 :
        检查Bean是否实现了InitializingBean这个接口，如果实现了，则调用这个接口中的方法! 

点位3 ： 在使用bean之后 或者 销毁bean 之前执行  :
        检查Bean是否实现了DisposableBean这个接口，如果实现了，则调用这个接口中的方法!

添加这三个点位的特点：都是在检查这个Bean是否实现了某些特定的接口，如果实现了这些接口，则Spring容器会调用这个接口中的方法！Spring提供这些点位的目的就是为了灵活

相关的代码实现如下：

public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {

    private String name;

    public void setName(String name) {
        System.out.println("第二步：赋值Bean,也就是给Bean的属性赋值(调用set方法)");
        this.name = name;
    }

    public User() {
        System.out.println("第一步：实例化bean(也就是无参构造)");
    }

    public void init() {
        System.out.println("第三步：初始化bean(也就是调用Bean中的init方法：注意这个方法需要自己编写，自己配)");
    }

    public void Mydestroy() {
        System.out.println("第五步：销毁bean(调用Bean中的destroy方法：注意这个方法需要自己编写，)");
    }

    /*下面方法只做了一件事 --会检查Bean是否实现了Aware的相关接口 */
    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("BeanClassLoaderAware中的方法, Bean这个类的类加载器" + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryAware中的方法,生产这个Bean的工厂对象是" + beanFactory);
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("BeanNameAware中的方法,这个Bean的名字是" + name);
    }

    /*检查Bean是否实现了InitializingBean这个接口，如果实现了，则调用这个接口中的方法! */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("检查Bean是否实现了InitializingBean这个接口，如果实现了，则调用这个接口中的方法!");
    }

    /*检查Bean是否实现了DisposableBean这个接口，如果实现了，则调用这个接口中的方法!*/
    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean中的destroy方法会先被调用");
    }
}

/*写好之后还需要对其进行配置 */
public class LongBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行Bean后处理器的before方法");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    /**
     * @param bean  刚创建的bean 对象
     * @param beanName  bean 的名字
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行Bean后处理器的after方法");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

<!-- 在Spring的xml文件中声明Bean-->
<!--    需要手动自定初始化方法和销毁方法  -->
    <bean id="user" class="com.xiaofan.Model.User" init-method="init" destroy-method="Mydestroy" >
        <property name="name" value="张三"></property>
    </bean>
<!--    配置Bean的后处理器，它将作用于整个配置文件中所有的bean ;但是它只作用于当前的配置文件-->
    <bean class="com.xiaofan.Model.LongBeanPostProcessor" />

测试:

/* 对Spring的Bean 进行测试 */
	@Test
    public void TextUserBean(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("Spring.xml");
        User user = applicationContext.getBean("user", User.class);
        System.out.println("第四步：使用bean:"+user);
        //注意：必须要手动关闭Spring容器 ，这样Spring才会销毁Bean
        ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
        context.close();
    }