java来源于生活的一点点积累，记性是有限的，记不住那么多的知识点，所以好记性不如烂笔头，一点点的做笔记
spring是java后台开发者最常用的框架，包括springmvc，springboot 都是在Java 上做的扩展。spring的核心为主键Bean 也就是IOC和DI，因此了解springBean的生命周期 我觉得是有必要的。若是本文有什么不合理或者不到位的地方敬请原谅，小白一枚，研究的不深。
接着直接上代码吧，第一张图表现的用来实验的Bean对象
package com.zr.springbean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
*
* Date: 2018年5月31日 下午3:42:45 <br/>
*
* @author zr
*
*/
/**
* 1.初始化bean,调用SpringBeanCycle的构造器
*
* 2.给属性赋值即属性注入
*
* 3.如果bean实现了BeanNameAware接口 执行setBeanName 方法。
*
* 4.如果bean实现了BeanFactoryAware或ApplicationContextAware;二者取其一(ApplicationContext是BeanFactory的子类相对说功能更强大)
*
* 5.如果有其他相关的bean实现了BeanPostProcesser(后处理bean),执行postProcessBeforeInitialization
*
* 6.如果实现InitializingBean，则执行afterPropertiesSet
*
* 7.调用自定义的init-method方法
*
* 8.如果存在类实现BeanPostProcessor(处理Bean),执行postProcessAfterInitialization
*
* 9.执行业务处理
*
* 10.如果Bean实现DisposableBean执行destroy
*
* 11.调用自定义的destroy-method
*/
public class SpringBeanCycle
implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {
private String life;
public SpringBeanCycle() {
super();
System.out.println("第一步：SpringBeanCycle的构造器执行");
}
public String getLife() {
return life;
}
public void setLife(String life) {
this.life = life;
System.out.println("第二步：属性注入 life:" + life);
}
@Override
public void setBeanName(String name) {
// name 为你定义的bean的ID<bean id="xxx"></bean>
System.out.println("第三步：BeanNameAware.setBeanName");
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("第四步：执行BeanFactoryAware.setBeanFactory");
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("第四步:ApplicationContextAware.setApplicationContext");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("第六步：执行InitializingBean.afterPropertiesSet");
}
@Override
public void destroy() throws Exception {
System.out.println("第十步：DisposableBean.destroy");
}
public void MyInit() {
System.out.println("第七步：自定义的myinit方法");
}
public void speakHello() {
System.out.println("第九步 业务代码 ：Hello world !!!");
}
public void MyDestroy() {
System.out.println("第十一步：自定义mydestroy执行");
}
}
图中ApplicationContextAware和BeanNameAware二者只留其一，Applicationcontext是BeanFactory的子类，在BeanFactory的基础上有更多的功能，也就是BeanFactory能做的Applicationcontext也能实现，二者的区别可以查看
spring中的BeanFactory与ApplicationContext的作用和区别？spring中的BeanFactory与ApplicationContext的作用和区别？
接着是BeanPostProcessor接口的实现，这一步的意思是你的spring容器中有其他类实现了这个接口，那么他会得到执行
package com.zr.springbean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
* ClassName:MyBeanPostProcessor <br/>
* Date: 2018年5月31日 下午4:19:04 <br/>
*
* @author zr
*/
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("第五步：执行BeanPostProcessor.postProcessBeforeInitialization");
return bean;// 注意这边返回的bean为当前bean对象一定要返回,作为实例化依据 beanName为当前传入的bean的名字
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("第八步：执行BeanPostProcessor.postProcessBeforeInitialization");
System.out.println("bean 基本可以调用了");
return bean;
}
}
接着是xml 的配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="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
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="springbeancycle"
class="com.zr.springbean.SpringBeanCycle" init-method="MyInit"
destroy-method="MyDestroy" scope="singleton"><!-- 注意使用prototype时,bean的销毁不再由spring容器处理，因此 注意:destroy-method只对scope=singleton有效果。-->
<property name="life" value="100岁"/>
</bean>
<bean id ="mybeanpostprocessor" class="com.zr.springbean.MyBeanPostProcessor"/>
</beans>
接着我们测试一下
package com.zr.test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.zr.springbean.SpringBeanCycle;
public class test1 {
public static void main(String[] args) {
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-main.xml");
SpringBeanCycle bean = (SpringBeanCycle) applicationContext.getBean("springbeancycle");
bean.speakHello();
applicationContext.close();
}
}
得到如下结果
第一步：SpringBeanCycle的构造器执行 第二步：属性注入 life:100岁 第三步：BeanNameAware.setBeanName 第四步：执行BeanFactoryAware.setBeanFactory 第四步:ApplicationContextAware.setApplicationContext 第五步：执行BeanPostProcessor.postProcessBeforeInitialization 第六步：执行InitializingBean.afterPropertiesSet 第七步：自定义的myinit方法 第八步：执行BeanPostProcessor.postProcessBeforeInitialization bean 基本可以调用了 第九步 业务代码 ：Hello world !!! 第十步：DisposableBean.destroy 第十一步：自定义mydestroy执行
更详细的介绍可参考钱书康
1、对于bean的生命周期方法:第三步与第四步是让Bean了解spring容器。
2、第五步与第八步 可以针对指定的Bean进行处理
3、第七步和第十一步可以用来进行初始化和销毁工作，无耦合出现。