class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("=======BeanPostProcessor的postProcessBeforeInitialization=========");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("=======BeanPostProcessor的postProcessAfterInitialization=========");
return bean;
}
}
public class Tester implements InitializingBean, DisposableBean, BeanNameAware {
private String p;
public Tester() {
System.out.println("---构造方法---");
System.out.println("p===" + p);
}
public void setP(String p) {
this.p = p;
}
@Override
public void setBeanName(String name) {
System.out.println("p===" + p);
System.out.println("---BeanNameAware接口setBeanName---");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("---InitializingBean接口afterPropertiesSet---");
}
public void initMethod() {
System.out.println("---指定的InitMethod---");
}
@Override
public void destroy() throws Exception {
System.out.println("---DisposableBean的destroy方法---");
}
public void destroyMethod() {
System.out.println("--指定的Destroy方法---");
}
@Override
public String toString() {
return "toString+++"+p;
}
public static void main(String[] args) throws Exception {
//创建一个BeanFactory
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
factory.addBeanPostProcessor(new MyBeanPostProcessor());
//构造一个BeanDefinition
RootBeanDefinition definition = new RootBeanDefinition(Tester.class);
definition.setInitMethodName("initMethod");
definition.setDestroyMethodName("destroyMethod");
//设置这个bean的属性
Map<String, Object> map = new HashMap<>();
map.put("p", "jack");
definition.setPropertyValues(new MutablePropertyValues(map));
//注册BeanDefinition
factory.registerBeanDefinition("tester", definition);
//执行获取和销毁bean的方法
factory.getBean("tester");
factory.destroySingleton("tester");
}
}
去掉多余日志,输出如下:
---构造方法---
p===null
p===jack
---BeanNameAware接口setBeanName---
=======BeanPostProcessor的postProcessBeforeInitialization=========
---InitializingBean接口afterPropertiesSet---
---指定的InitMethod---
=======BeanPostProcessor的postProcessAfterInitialization=========
---DisposableBean的destroy方法---
--指定的Destroy方法---
我们可以得到实例化bean的大致过程~
1:调用Bean的默认构造方法(当然也可以是指定的其它构造方法),生成bean实例。
2:检查BeanDefinition中是否注入了Bean的属性值,如果有注入,则在bean实例的基础上对其属性进行注入。
3 : 调用Aware相关接口的方法
4 :postProcessBeforeInitialization
5:检查Bean是否实现了InitializingBean接口,如果实现了此接口,则调用afterPropertiesSet()方法。
6:检查Bean配置文件中是否指定了initMethodName属性,如果已指定,则调用此属性对应方法。
7 : postProcessAfterInitialization
销毁过程
1:检查Bean是否实现了DisposableBean 接口,如果实现了此接口,则调用destroy()方法。
2:检查Bean配置文件中是否指定了destroyMethodName属性,如果已指定,则调用此属性对应方法
二、AbstractBeanFactory#doGetBean(..)源码
无论以何种方式获取Bean,都会调用AbstractBeanFactory#doGetBean(..)方法。
去除了这个方法的非重点代码, 保留了部分重要的代码,如下:
protected <T> T doGetBean( String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly) {
final String beanName = transformedBeanName(name);
Object bean;
Object sharedInstance = getSingleton(beanName);//是否已经创建过Bean
if (sharedInstance != null && args == null) {
//1.查找手动注册的Bean实例 或者已经创建过的Bean实例
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 2.检查父容器是否含有这个Bean,有则返回
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
String nameToLookup = originalBeanName(name);
if (args != null) {
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
//3.获取MergedLocalBeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 初始化指定的依赖Bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
registerDependentBean(dependsOnBean, beanName);
getBean(dependsOnBean);
}
}
//********************重点*******************
// 创建单实例Bean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return createBean(beanName, mbd, args);
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//***************************************
//创建多实例Bean
else if (mbd.isPrototype()) {
//.....
}
}
// 根据指定的类型进行转换
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
return (T) bean;
}
1.查找手动注册的Bean实例 或者已经创建过的Bean实例
获取DefaultSingletonBeanRegistry中保存的Bean
2.
代码中 //***之间就是创建Bean的主要代码。下面将针对这部分进行讲解。
三 ,创建Bean重点代码
//********************重点*******************
// 创建单实例Bean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return createBean(beanName, mbd, args); //1
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//***************************************
1中进入匿名类ObjectFactory的createBean部分,他实际调用AbstractAutowireCapableBeanFactory#createBean(..)方法
AbstractAutowireCapableBeanFactory#createBean(..)方法
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) {
RootBeanDefinition mbdToUse = mbd;
//设置RootBeanDefinition的BeanClass
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
mbdToUse.prepareMethodOverrides();
// 允许BeanPostProcessors返回一个代理代替Bean实例
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
//实际生成Bean的方法,调用AbstractAutowireCapableBeanFactory#doCreateBean(..)
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
}
AbstractAutowireCapableBeanFactory#doCreateBean(..)
重点代码如下:
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
// 创建BeanWrapper
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
Object exposedObject = bean;
//设置Bean的属性值
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
//***************重点***************
//处理Bean(Aware接口相关方法,前处理器,初始化方法,后处理器)
exposedObject = initializeBean(beanName, exposedObject, mbd);
//调用的是AbstractAutowireCapableBeanFactory#initializeBean(..)方法
//**********************************
}
// Register bean as disposable.
registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
}
调用的是AbstractAutowireCapableBeanFactory#initializeBean(..)方法
这个方法代码简化如下
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
//调用Aware相关接口的方法
invokeAwareMethods(beanName, bean);
Object wrappedBean = bean;
//Bean前处理器
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
//调用指定的InitMethod方法
invokeInitMethods(beanName, wrappedBean, mbd);
//调用Bean后处理器
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
return wrappedBean;
}