spring初始化Bean
在spring 加载bean过程中，从BeanFactory或ApplicationContext取得的实例默认为Singleton， 当然可以设置为取Bean时都产生一个新的实例，
<bean id = "myBean" class = "com.feifei.MyBean" scope = "prototype"/>
这篇 关注 spring bean的加载过程 和 spring中循环依赖加载问题
spring bean的加载过程图
引用一张图
https://www.cnblogs.com/zrtqsk/p/3735273.html
bean的初始化demo
下面写一个bean的初始化demo验证下，
Bean实现 BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean
分别写实现类 实现 BeanPostProcessor，InstantiationAwareBeanPostProcessorAdapter，BeanFactoryPostProcessor
具体代码如下：
MyBeanPostProcessor
public class MyBeanPostProcessor implements BeanPostProcessor {
public MyBeanPostProcessor() {
super();
System.out.println("3 ==>这是BeanPostProcessor实现类构造器！！");
}
@Override
public Object postProcessBeforeInitialization(Object arg0, String arg1) throws BeansException {
System.out.println("12 ==>BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！");
return arg0;
}
@Override
public Object postProcessAfterInitialization(Object arg0, String arg1) throws BeansException {
System.out.println("15 ==>BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！");
return arg0;
}
}
MyBeanFactoryPostProcessor
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("1 ==>这是BeanFactoryPostProcessor实现类构造器！！");
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0) throws BeansException {
System.out.println("2 ==>BeanFactoryPostProcessor调用postProcessBeanFactory方法");
BeanDefinition bd = arg0.getBeanDefinition("person");
bd.getPropertyValues().addPropertyValue("phone", "110");
}
}
MyInstantiationAwareBeanPostProcessor
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("4 ==>这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！");
}
// 接口方法、实例化Bean之前调用
@Override
public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
System.out.println("5 ==>InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法");
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
System.out.println("7 ==>InstantiationAwareBeanPostProcessor调用postProcessAfterInstantiation方法");
return true;
}
// 接口方法、设置某个属性时调用
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean,
String beanName) throws BeansException {
System.out.println("8 ==>InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");
return pvs;
}
// 接口方法、实例化Bean之后调用
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("16 ==>InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法");
return bean;
}
}
Person Bean
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 int phone;
private BeanFactory beanFactory;
private String beanName;
public Person() {
System.out.println("6 ==>【构造器】调用Person的构造器实例化");
}
public int getPhone() {
return phone;
}
public void setPhone(int phone) {
System.out.println("9==>【注入属性】注入属性phone");
this.phone = phone;
}
// 这是BeanNameAware接口方法
@Override
public void setBeanName(String beanName) {
System.out.println("10 ==>【BeanNameAware接口】调用BeanNameAware.setBeanName()");
this.beanName = beanName;
}
@Override
public String toString() {
return "Person [phone=" + phone + ", beanFactory=" + beanFactory + ", beanName=" + beanName + "]";
}
// 这是BeanFactoryAware接口方法
@Override
public void setBeanFactory(BeanFactory arg0) throws BeansException {
System.out.println("11 ==>【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()");
this.beanFactory = arg0;
}
// 这是InitializingBean接口方法
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("13 ==>【InitializingBean接口】调用InitializingBean.afterPropertiesSet()");
}
// 通过<bean>的init-method属性指定的初始化方法
public void myInit() {
System.out.println("14 ==>【init-method】调用<bean>的init-method属性指定的初始化方法");
}
// 这是DiposibleBean接口方法
@Override
public void destroy() throws Exception {
System.out.println("18 ==>【DiposibleBean接口】调用DiposibleBean.destory()");
}
// 通过<bean>的destroy-method属性指定的初始化方法
public void myDestory() {
System.out.println("19 ==>【destroy-method】调用<bean>的destroy-method属性指定的初始化方法");
}
}
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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<bean id="person" class="feifei.test.beanCreate.Person"
init-method="myInit" destroy-method="myDestory" scope="singleton"
p:phone="15900000000" >
</bean>
<bean id="beanPostProcessor"
class="feifei.test.beanCreate.MyBeanPostProcessor">
</bean>
<bean id="beanFactoryPostProcessor"
class="feifei.test.beanCreate.MyBeanFactoryPostProcessor">
</bean>
<bean id="instantiationAwareBeanPostProcessor"
class="feifei.test.beanCreate.MyInstantiationAwareBeanPostProcessor">
</bean>
</beans>
main 方法
public static void main(String[] args) {
System.out.println("===>start 现在开始初始化容器");
ApplicationContext factory = new ClassPathXmlApplicationContext("classpath*:/context/bean.xml");
System.out.println("===>end 容器初始化成功");
//得到Preson，并使用
Person person = factory.getBean("person",Person.class);
System.out.println(person);
System.out.println("===>start 现在开始关闭容器！");
((ClassPathXmlApplicationContext)factory).registerShutdownHook();
}
验证结果
得到的结果为：
===>start 现在开始初始化容器
1 ==>这是BeanFactoryPostProcessor实现类构造器！！
2 ==>BeanFactoryPostProcessor调用postProcessBeanFactory方法。
3 ==>这是BeanPostProcessor实现类构造器！！
4 ==>这是MyInstantiationAwareBeanPostProcessor实现类构造器！！
5 ==>InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法
6 ==>【构造器】调用Person的构造器实例化
7 ==>InstantiationAwareBeanPostProcessor调用postProcessAfterInstantiation方法
8 ==>InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法
9 ==>【注入属性】注入属性phone
10 ==>【BeanNameAware接口】调用BeanNameAware.setBeanName()
11 ==>【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()
12 ==>BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！
13 ==>【InitializingBean接口】调用InitializingBean.afterPropertiesSet()
14 ==>【init-method】调用的init-method属性指定的初始化方法
15 ==>BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！
16 ==>InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法
===>end 容器初始化成功
===>start 现在开始关闭容器！
18 ==>【DiposibleBean接口】调用DiposibleBean.destory()
19 ==>【destroy-method】调用的destroy-method属性指定的初始化方法
循环依赖
最后讲下bean相互依赖的问题
相互依赖：A 依赖 B， B 依赖 A
当 A 创建的时候，会把 A 对应的 ObjectFactory 放在缓存中，当依赖注入的时候发现了 B 对象，调用 getBean() 方法获取 B 对象， 然后创建 B 对象，会把 B 对应的 ObjectFactory 放在缓存中。
此时 B 依赖 A ，然后再调用 getBean 获取 A 对象， 此时调用 AbstractBeanFactory#doGetBean 从缓存中获取到 A 对应的 ObjectFactory。
这样就避免了死循环，然后再创建成功之后删除 ObjectFactory 完成依赖注入。
思路：中间对象去解决循环依赖。
原文：https://blog.csdn.net/w1lgy/article/details/81086171