问题来源：
有一个bean为 A，一个bean为B。想要A在容器实例化的时候的一个属性name赋值为B的一个方法funB的返回值。
如果只是在A里单纯的写着：
private B b;
private String name = b.funb();
会报错说nullpointException，因为这个时候b还没被set进来，所以为null。
解决办法为如下代码，同时学习下spring中 InitializingBean ，对象 构造方法 ， init-method 的执行顺序。
public class A implements InitializingBean {
private B b;
private String name; // = b.funb();
public void setB(B b) {
System.out.println("A.setB initialed");
this.b = b;
}
public A() {
System.out.println("A initialed");
}
public void init() {
System.out.println("init");
this.name = b.funb();
}
@Override
public String toString() {
return super.toString() + this.name;
}
public void afterPropertiesSet() throws Exception {
//其实放在这里也可以
//this.name = b.funb();
System.out.println("afterPropertiesSet");
}
}
public class B {
public String funb() {
System.out.println("funb");
return "B.funb";
}
public B() {
System.out.println("B initialed");
}
}
spring配置文件
<beans default->
<bean id="a" class="testspring.A" init-method="init">
</bean>
<bean id="b" class="testspring.B">
</bean>
</beans>
测试代码：
public static void main(String[] args) {
ApplicationContext context = new FileSystemXmlApplicationContext(
"src/testspring/bean.xml");
A a = (A) context.getBean("a");
System.out.println(a);
}
程序输出为：
A initialed
B initialed
A.setB initialed
afterPropertiesSet
init
funb
从这里看到A的name属性在bean加载完成的时候也被成功设置为B的funB方法的返回值了，要点就是用init-method来实现。
加载顺序也可以看到为：
先构造函数——>然后是b的set方法注入—— >InitializingBean 的afterPropertiesSet方法——>init- method方法
总结为：
以下内容是从书中摘录 来的,但是我发现即使摘录一遍,对其内容的理解也会更加深入!
一、Spring装配Bean的过程
1. 实例化;
2. 设置属性值;
3. 如果实现了BeanNameAware接口,调用setBeanName设置Bean的ID或者Name;
4. 如果实现BeanFactoryAware接口,调用setBeanFactory 设置BeanFactory;
5. 如果实现ApplicationContextAware,调用setApplicationContext设置ApplicationContext
6. 调用BeanPostProcessor的预先初始化方法;
7. 调用InitializingBean的afterPropertiesSet()方法;
8. 调用定制init-method方法；
9. 调用BeanPostProcessor的后初始化方法;
Spring容器关闭过程
1. 调用DisposableBean的destroy();
2. 调用定制的destroy-method方法;
==========================
spring InitializingBean init-method postConstruct 执行顺序：
Spring 容器中的 Bean 是有生命周期的，Spring 允许在 Bean 在初始化完成后以及 Bean 销毁前执行特定的操作，常用的设定方式有以下三种：
通过实现 InitializingBean/DisposableBean 接口来定制初始化之后/销毁之前的操作方法；
通过 元素的 init-method/destroy-method属性指定初始化之后 /销毁之前调用的操作方法；
在指定方法上加上@PostConstruct 或@PreDestroy注解来制定该方法是在初始化之后还是销毁之前调用。
这是我们就有个疑问，这三种方式是完全等同的吗，孰先孰后？
下面我们将带着这个疑问，试图通过测试代码以及分析Spring源码找到答案。
首先，我们还是编写一个简单的测试代码：
Java代码 复制代码 收藏代码
public class InitSequenceBean implements InitializingBean {
public InitSequenceBean() {
System.out.println("InitSequenceBean: constructor");
}
@PostConstruct
public void postConstruct() {
System.out.println("InitSequenceBean: postConstruct");
}
public void initMethod() {
System.out.println("InitSequenceBean: init-method");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("InitSequenceBean: afterPropertiesSet");
}
}
并且在配置文件中添加如下Bean定义：
好了，我们启动Spring容器，观察输出结果，就可知道三者的先后顺序了：
InitSequenceBean: constructor
InitSequenceBean: postConstruct
InitSequenceBean: afterPropertiesSet
InitSequenceBean: init-method
通过上述输出结果，三者的先后顺序也就一目了然了：
Constructor > @PostConstruct > InitializingBean > init-method
先大致分析下为什么会出现这些的结果：构造器（Constructor）被率先调用毋庸置疑，InitializingBean先于init-method我们也可以理解（在也谈Spring容器的生命周期中已经讨论过），但是PostConstruct为何率先于InitializingBean执行呢？
我们再次带着这个疑问去查看Spring源代码来一探究竟。
通过Debug并查看调用栈，我们发现了这个类org.springframework.context.annotation.CommonAnnotationBeanPostProcessor，从命名上，我们就可以得到某些信息——这是一个BeanPostProcessor。想到了什么？在也谈Spring容器的生命周期中，我们提到过BeanPostProcessor的postProcessBeforeInitialization是在Bean生命周期中afterPropertiesSet和init-method之前执被调用的。
再次观察CommonAnnotationBeanPostProcessor这个类，它继承自InitDestroyAnnotationBeanPostProcessor。InitDestroyAnnotationBeanPostProcessor顾名思义，就是在Bean初始化和销毁的时候所作的一个前置/后置处理器。
通过查看InitDestroyAnnotationBeanPostProcessor类下的postProcessBeforeInitialization方法：
Java代码 复制代码 收藏代码
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
try {
metadata.invokeInitMethods(bean, beanName);
}
catch (InvocationTargetException ex) {
throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Couldn't invoke init method", ex);
}
return bean;
}
查看findLifecycleMetadata方法，继而我们跟踪到buildLifecycleMetadata这个方法体中，看下buildLifecycleMetadata这个方法体的内容：
Java代码 复制代码 收藏代码
private LifecycleMetadata buildLifecycleMetadata(final Class clazz) {
final LifecycleMetadata newMetadata = new LifecycleMetadata();
final boolean debug = logger.isDebugEnabled();
ReflectionUtils.doWithMethods(clazz, new ReflectionUtils.MethodCallback() {
public void doWith(Method method) {
if (initAnnotationType != null) {
if (method.getAnnotation(initAnnotationType) != null) {
newMetadata.addInitMethod(method);
if (debug) {
logger.debug("Found init method on class [" + clazz.getName() + "]: " + method);
}
}
}
if (destroyAnnotationType != null) {
if (method.getAnnotation(destroyAnnotationType) != null) {
newMetadata.addDestroyMethod(method);
if (debug) {
logger.debug("Found destroy method on class [" + clazz.getName() + "]: " + method);
}
}
}
}
});
return newMetadata;
}
分析这段代码发现，在这里会去判断某方法有没有被initAnnotationType/destroyAnnotationType注释，如果有，则添加到init/destroy队列中，后续一一执行。
initAnnotationType/destroyAnnotationType注释是什么呢，我们在CommonAnnotationBeanPostProcessor的构造函数中看到下面这段代码：
Java代码 复制代码 收藏代码
public CommonAnnotationBeanPostProcessor() {
setOrder(Ordered.LOWEST_PRECEDENCE - 3);
setInitAnnotationType(PostConstruct.class);
setDestroyAnnotationType(PreDestroy.class);
ignoreResourceType("javax.xml.ws.WebServiceContext");
}
一切都清晰了吧。一言以蔽之，@PostConstruct注解后的方法在BeanPostProcessor前置处理器中就被执行了，所以当然要先于InitializingBean和init-method执行了。
最后，给出本文的结论，Bean在实例化的过程中：
Constructor > @PostConstruct > InitializingBean > init-method
