可参考文章：
Spring开闭原则的表现-BeanPostProcessor扩展点-1
容器启动时：
最先调用
BeanFactoryPostProcessor
->postProcessBeanFactory()
getBean时：
实例化之后调用：
InstantiationAwareBeanPostProcessor
->postProcessPropertyValues()
初始化时：
属性注入（setter）
BeanNameAware
->setBeanName()
BeanFactoryAware
->setBeanFactory()
ApplicationContextAware
->setApplicationContext()
BeanPostProcessor
->postProcessBeforeInitialization()
InitializingBean
->afterPropertiesSet()
init-method属性
BeanPostProcessor
->postProcessAfterInitialization()
DiposibleBean
->destory()
destroy-method属性
BeanFactoryPostProcessor
//Spring IoC容器允许BeanFactoryPostProcessor在容器实际实例化任何其它的bean之前读取配置元数据，并有可能修改它。
//同时BeanFactoryPostProcessor的回调比BeanPostProcessor要早
void postProcessBeanFactory(ConfigurableListableBeanFactory arg)
InstantiationAwareBeanPostProcessorAdapter
其适配器类：InstantiationAwareBeanPostProcessor
//实例化Bean之前调用 （Bean构造函数前）
Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
//实例化Bean之后调用
boolean postProcessAfterInstantiation(Object bean, String beanName)
PropertyValues postProcessPropertyValues(PropertyValues pvs,
PropertyDescriptor[] pds, Object bean, String beanName)
BeanPostProcessor
//实例化、依赖注入完毕，在初始化之前调用，完成一些定制的初始化任务
Object postProcessBeforeInitialization(Object bean, String beanName)
//实例化、依赖注入、初始化完毕时执行
Object postProcessAfterInitialization(Object bean, String beanName)
BeanFactoryPostProcessor和BeanPostProcessor都是Spring初始化bean的扩展点。两个接口非常相似。
BeanFactoryPostProcessor可以在postProcessBeanFactory()中对bean的定义（配置元数据）进行处理，而BeanPostProcessor不可以。
同时BeanFactoryPostProcessor的回调比BeanPostProcessor要早。
http://blog.csdn.net/mn11201117/article/details/24986325
http://blog.csdn.net/xiao_jun_0820/article/details/7242379
实例1：
百度文库：
实例2（重要）：
Bean的完整生命周期经历了各种方法调用，这些方法可以划分为以下几类：
1、Bean自身的方法：
这个包括了Bean本身调用的方法和通过配置文件中<bean>的init-method和destroy-method指定的方法
2、Bean级生命周期接口方法：
这个包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法
3、容器级生命周期接口方法：
这个包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为“后处理器”。
4、工厂后处理器接口方法：
这个包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工厂后处理器 接口的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。
我们用一个简单的Spring Bean来演示一下Spring Bean的生命周期。
1、首先是一个简单的Spring Bean，调用Bean自身的方法和Bean级生命周期接口方法，
为了方便演示，它实现了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这4个接口，
【对于BeanFactoryAware和BeanNameAware接口，第一个接口让bean感知容器（即BeanFactory实例，从而以此获取该容器配置的其他bean对象），而后者让bean获得配置文件中对应的配置名称。在一般情况下用户不需要关心这两个接口。如果bean希望获得容器中的其他bean，可以通过属性注入的方式引用这些bean。如果bean希望在运行期获知在配置文件中的Bean名称，可以简单的将名称作为属性注入
综上所述，我们认为除非编写一个基于spring之上的扩展框架插件或者子项目之类的东西，否则用户完全可以抛开以上4个bean生命周期的接口类
但BeanPostProcessor接口却不一样，它不要求bean去继承它，它可以完全像插件一样注册到spring容器中，为容器提供额外的功能。spring充分利用了BeanPostProcessor对bean进行加工处理（SpringAOP以此为基础)】
同时有2个方法，对应配置文件中<bean>的init-method和destroy-method。如下：
package springBeanTest;
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;
public class Person implements BeanFactoryAware, BeanNameAware,
InitializingBean, DisposableBean {
private String name;
private String address;
private int phone;
private BeanFactory beanFactory;
private String beanName;
public Person() {
System.out.println("【构造器】调用Person的构造器实例化");
}
public String getName() {
return name;
}
public void setName(String name) {
System.out.println("【注入属性】注入属性name");
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
System.out.println("【注入属性】注入属性address");
this.address = address;
}
public int getPhone() {
return phone;
}
public void setPhone(int phone) {
System.out.println("【注入属性】注入属性phone");
this.phone = phone;
}
@Override
public String toString() {
return "Person [address=" + address + ", name=" + name + ", phone="
+ phone + "]";
}
// 这是BeanFactoryAware接口方法
@Override
public void setBeanFactory(BeanFactory arg) throws BeansException {
System.out
.println("【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()");
this.beanFactory = arg;
}
// 这是BeanNameAware接口方法
@Override
public void setBeanName(String arg) {
System.out.println("【BeanNameAware接口】调用BeanNameAware.setBeanName()");
this.beanName = arg;
}
// 这是InitializingBean接口方法
@Override
public void afterPropertiesSet() throws Exception {
System.out
.println("【InitializingBean接口】调用InitializingBean.afterPropertiesSet()");
}
// 这是DiposibleBean接口方法
@Override
public void destroy() throws Exception {
System.out.println("【DiposibleBean接口】调用DiposibleBean.destory()");
}
// 通过<bean>的init-method属性指定的初始化方法
public void myInit() {
System.out.println("【init-method】调用<bean>的init-method属性指定的初始化方法");
}
// 通过<bean>的destroy-method属性指定的初始化方法
public void myDestory() {
System.out.println("【destroy-method】调用<bean>的destroy-method属性指定的初始化方法");
}
}
2、接下来是演示BeanPostProcessor接口的方法，如下：
package springBeanTest;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanPostProcessor implements BeanPostProcessor {
public MyBeanPostProcessor() {
super();
System.out.println("这是BeanPostProcessor实现类构造器！！");
}
@Override
public Object postProcessAfterInitialization(Object arg, String arg)
throws BeansException {
System.out.println("BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！");
return arg;
}
@Override
public Object postProcessBeforeInitialization(Object arg, String arg)
throws BeansException {
System.out.println("BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！");
return arg;
}
}
如上，BeanPostProcessor接口包括2个方法postProcessAfterInitialization和postProcessBeforeInitialization，这两个方法的第一个参数都是要处理的Bean对象，第二个参数都是Bean的name。返回值也都是要处理的Bean对象。这里要注意。
3、InstantiationAwareBeanPostProcessor 接口本质是BeanPostProcessor的子接口，一般我们继承Spring为其提供的适配器类InstantiationAwareBeanPostProcessorAdapter来使用它，如下：
package springBeanTest;
import java.beans.PropertyDescriptor;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
public class MyInstantiationAwareBeanPostProcessor extends
InstantiationAwareBeanPostProcessorAdapter {
public MyInstantiationAwareBeanPostProcessor() {
super();
System.out.println("这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！");
}
// 接口方法、实例化Bean之前调用
@Override
public Object postProcessBeforeInstantiation(Class beanClass,
String beanName) throws BeansException {
System.out.println("InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法");
return null;
}
// 接口方法、实例化Bean之后调用
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法");
return bean;
}
// 接口方法、设置某个属性时调用
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs,
PropertyDescriptor[] pds, Object bean, String beanName)
throws BeansException {
System.out.println("InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");
return pvs;
}
}
这个有3个方法，其中第二个方法postProcessAfterInitialization就是重写了BeanPostProcessor的方法。第三个方法postProcessPropertyValues用来操作属性，返回值也应该是PropertyValues对象。
4、演示工厂后处理器接口方法，如下：
package springBeanTest;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public MyBeanFactoryPostProcessor() {
super();
System.out.println("这是BeanFactoryPostProcessor实现类构造器！！");
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory arg)
throws BeansException {
System.out
.println("BeanFactoryPostProcessor调用postProcessBeanFactory方法");
BeanDefinition bd = arg.getBeanDefinition("person");
bd.getPropertyValues().addPropertyValue("phone", "");
}
}
5、配置文件如下beans.xml，很简单，使用ApplicationContext,处理器不用手动注册：
<?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:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<bean id="beanPostProcessor" class="springBeanTest.MyBeanPostProcessor"></bean>
<bean id="instantiationAwareBeanPostProcessor" class="springBeanTest.MyInstantiationAwareBeanPostProcessor"></bean>
<bean id="beanFactoryPostProcessor" class="springBeanTest.MyBeanFactoryPostProcessor">
</bean>
<bean id="person" class="springBeanTest.Person" init-method="myInit"
destroy-method="myDestory" scope="singleton" p:name="张三" p:address="广州"
p:phone="15900000000" />
</beans>
6.测试
package springBeanTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BeanLifeCycle {
public static void main(String[] args) {
System.out.println("现在开始初始化容器");
ApplicationContext ctx = new ClassPathXmlApplicationContext("springBeanTest/beans.xml");
System.out.println("容器初始化成功");
//得到Preson，并使用
Person person = ctx.getBean("person",Person.class);
System.out.println(person);
System.out.println("现在开始关闭容器！");
((ClassPathXmlApplicationContext)ctx).registerShutdownHook();
}
}
结果如下：
现在开始初始化容器
2014-5-18 15:46:20 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@19a0c7c: startup date [Sun May 18 15:46:20 CST 2014]; root of context hierarchy
2014-5-18 15:46:20 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [springBeanTest/beans.xml]
这是BeanFactoryPostProcessor实现类构造器!
BeanFactoryPostProcessor调用postProcessBeanFactory方法
这是BeanPostProcessor实现类构造器!!
这是InstantiationAwareBeanPostProcessorAdapter实现类构造器!!
2014-5-18 15:46:20 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@9934d4: defining beans [beanPostProcessor,instantiationAwareBeanPostProcessor,beanFactoryPostProcessor,person]; root of factory hierarchy
InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法
【构造器】调用Person的构造器实例化
InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法
【注入属性】注入属性address
【注入属性】注入属性name
【注入属性】注入属性phone
【BeanNameAware接口】调用BeanNameAware.setBeanName()
【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()
BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改!
【InitializingBean接口】调用InitializingBean.afterPropertiesSet()
【init-method】调用<bean>的init-method属性指定的初始化方法
BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改!
InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法（这个位置感觉有问题，待解决）
容器初始化成功
Person [address=广州, name=张三, phone=110]
现在开始关闭容器!
【DiposibleBean接口】调用DiposibleBean.destory()
【destroy-method】调用<bean>的destroy-method属性指定的初始化方法
图示如下：
相关推荐
Spring Bean的初始化和销毁是Spring框架中一个非常重要的概念，它们都是Bean生命周期中不可或缺的一部分。在Spring框架中，我们可以使用多种方式来控制Bean的初始化和销毁，以下就Spring Bean的初始化和销毁进行详细...
3、通过spring的xml bean配置或bean注解指定初始化方法，如下面实例的initMethod方法通过@bean注解指定。 销毁的时候实现的方法 1、通过java提供的@PreDestroy注释； 2、通过实现spring提供的DisposableBean接口，并...
在Spring框架中，Bean的初始化是一个关键的概念，它涉及到Bean的生命周期管理以及Spring容器如何创建、配置和管理这些Bean。本文将深入探讨Spring容器中Bean的初始化过程。 首先，Spring容器根据XML配置文件（如`...
在本篇文章中，我们将深入探讨Spring源码中关于Bean初始化的过程，特别是`finishBeanFactoryInitialization()`方法和`preInstantiateSingletons()`方法。 首先，`finishBeanFactoryInitialization(Confi...
Spring Bean 加载过程是 Spring 框架中最核心的部分之一，涉及到 ApplicationContext 的初始化、Bean 的加载和注册等过程。在 Spring Boot 应用程序中，SpringApplication 负责加载和管理 Bean。 SpringApplication...
Spring中的Bean是指由Spring容器初始化、装配和管理的对象。它们通常是应用程序中的业务逻辑组件，例如服务层接口的实现类。Spring容器通过XML、Java配置或者基于注解的方式管理Bean的生命周期，包括创建、初始化、...
一旦XML配置加载到Spring容器中，容器将根据配置创建Bean实例，并按照定义进行初始化、依赖注入，最后完成Bean的生命周期管理。 10. **实践操作**： 在实际开发中，我们可以使用Eclipse的Spring插件来简化Bean...
Spring Bean是Spring IoC容器管理的对象，这些对象的生命周期、依赖关系以及初始化行为由Spring容器控制。实例化Spring Bean的方式多种多样，包括XML配置、注解配置以及Java配置等。而工厂方法是其中一种自定义实例...
首先，我们需要从 beanDefinitionMap 中通过 beanName 获得 BeanDefinition，然后从 BeanDefinition 中获得 beanClassName，最后通过反射初始化 beanClassName 的实例 instance。构造函数从 BeanDefinition 的 ...
在整个生命周期中，Spring提供了多种方式来实现Bean的初始化，例如使用init-method参数、InitializingBean接口等。 二、Bean的作用域 Bean的作用域是指Bean的生命周期和可用性。Spring框架提供了多种作用域，例如 ...
1. **初始化**：当Spring容器加载Bean定义时，它会创建Bean的实例。这通常通过无参构造函数完成。如果Bean定义中包含了工厂方法，那么会使用该方法来创建Bean。 2. **属性注入**：接着，Spring会根据Bean定义中的...
对于 prototype 作用域的 bean，有一点非常重要，那就是 Spring 不能对一个 prototype bean 的整个生命周期负责，容器在初始化、配置、装饰或者是装配完一个 prototype 实例后，将它交给客户端，随后就对该 ...
在Spring容器初始化时，它会读取配置文件（如XML或Java配置），解析Bean定义，包括其依赖关系、初始化方法、作用域等属性。这个阶段不涉及Bean的实际实例化，而是构建Bean的元数据。 2. **Bean实例化** 实例化是...
4. **容器回调**：在Bean初始化之后，Spring容器可能会调用自己的回调方法，如`BeanPostProcessor`接口实现的`postProcessBeforeInitialization()`和`postProcessAfterInitialization()`方法，允许自定义逻辑进一步...
Bean 的生命周期包括实例化、装配、初始化、使用和销毁等阶段。在 Spring 中，Bean 的生命周期是由容器管理的。 Bean 的作用域 Bean 的作用域是指 Bean 对象的生命周期范围。Spring 中的 Bean 可以有多种作用域，...
3. 加载 bean：Spring 会加载 bean，并将其实例化。 4. 获取 bean：应用程序可以从容器中获取 bean 并使用它。 在加载 bean 的过程中，Spring 会使用 Resource 对象来表示 XML 文件，然后使用 ...
Spring 延迟实例化
这两个方法在Bean初始化前后执行，可以用于额外的处理，比如AOP代理的创建。 5. **初始化方法**：Bean可能实现`InitializingBean`接口，Spring会调用`afterPropertiesSet()`方法。另外，也可以通过`init-method`...
此外，Spring还提供了`BeanPostProcessor`接口，它允许自定义在Bean初始化前后进行的额外处理。该接口包含两个方法：`postProcessBeforeInitialization()`和`postProcessAfterInitialization()`，这两个方法会在Bean...
在初始化方法被调用前后，Spring将把每个Bean实例分别传递给上述接口的以下两个方法：postProcessBeforeInitialization(Object, String)和postProcessAfterInitialization(Object, String)。 在添加Bean后置处理器...