【Spring源码学习】Spring Bean实例化过程-初始化
【Spring源码学习】Spring Bean实例化过程-初始化
- 一、调用Aware方法
-
- 1.InitializeBean()
- 2.invokeAwareMethods()
- 二、InitializingBean接口，afterPropertiesSet，init-method属性调用
-
- 1.初始化前置处理
-
- 1.1.Aware接口方法的调用
- 1.2.@PostConstruct注解方法调用
- 2.初始化
- 3.初始化后置处理
-
- 3.1.代理实例注入
上一章讲完了populateBean的过程，这一章，我们来跟一下bean初始化的流程，主要分为这么几个步骤：
- 调用Aware方法
- InitializingBean接口，afterPropertiesSet，init-method属性调用
一、调用Aware方法
1.InitializeBean()
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
//1.调用Aware方法
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//前置处理
//对类中某些特殊方法的调用，比如@PostConstruct，Aware接口，非常重要 重要程度 ：5
//ApplicationContextAwareProcessor 对Aware接口的调用如：
//EnvironmentAware EmbeddedValueResolverAware ResourceLoaderAware ApplicationEventPublisherAware MessageSourceAware ApplicationContextAware
//ImportAwareBeanPostProcessor 对ImportAware的支持
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//2.InitializingBean接口，afterPropertiesSet，init-method属性调用,非常重要，重要程度：5
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//3.后置处理，这个地方可能生出代理实例，是aop的入口
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
2.invokeAwareMethods()
这个方法主要是设置beanName，beanClassLoader，beanFactory，但前提是这个bean实现了对应Aware的接口
private void invokeAwareMethods(String beanName, Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
二、InitializingBean接口，afterPropertiesSet，init-method属性调用
初始化的调用又可分为三个步骤：
- 初始化前置处理：applyBeanPostProcessorsBeforeInitialization()
- 初始化：afterPropertiesSet，init-method属性调用
- 初始化后置处理：applyBeanPostProcessorsAfterInitialization()
1.初始化前置处理
在【Spring源码学习】Spring Bean实例化过程-创建Bean实例6.2.1节，我们已经完成了@PostConstruct注解扫描，这一步就是调用相关的过程了，依然采用beanPostProcessor调用的方式。当然不止这些注解，还包括Aware接口的调用，ImportAware的支持处理等。
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
//循环处理
/*
*着重看这几个：
* 1.ApplicationContextAwareProcessor 对某个Aware接口方法的调用
* 2.InitDestroyAnnotationBeanPostProcessor @PostConstruct注解方法的调用
* 3.ImportAwareBeanPostProcessor 对ImportAware类型实例setImportMetadata 调用（SpringBoot）
*/
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
1.1.Aware接口方法的调用
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
return bean;
}
AccessControlContext acc = null;
if (System.getSecurityManager() != null) {
acc = this.applicationContext.getBeanFactory().getAccessControlContext();
}
if (acc != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareInterfaces(bean);
return null;
}, acc);
}
else {
invokeAwareInterfaces(bean);
}
return bean;
}
1.2.@PostConstruct注解方法调用
//InitDestroyAnnotationBeanPostProcessor
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
try {
//调用@PostConstruct注解的方法
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, "Failed to invoke init method", ex);
}
return bean;
}
2.初始化
前置处理完毕，接下来就是InitializingBean 接口和init-method 属性调用过程，实现了InitializingBean 接口的类就必然会调用到afterPropertiesSet 方法，而Init-method 属性调用是在afterPropertiesSet 之后，对应的方法为invokeCustomInitMethod。
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
//是否是实现了InitializingBean的类
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((InitializingBean) bean).afterPropertiesSet();
return null;
}, getAccessControlContext());
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
//调用实现了InitializingBean接口的方法
((InitializingBean) bean).afterPropertiesSet();
}
}
//init-method反射调用
if (mbd != null && bean.getClass() != NullBean.class) {
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
//调用init-method配置的方法
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
afterPropertiesSet 和Init-method 和有@PostConstruct 注解的方法其实核心功能都是一样的，只是调用
时序不一样而已，都是在该类实例化和IOC 做完后调用的，我们可以在这些方法中做一些在spring 或者servlet 容器启动的时候的初始化工作。比如缓存预热，比如缓存数据加载到内存，比如配置解析，等等初始化工作调用顺序为先调用@PostConstruct(注解使用)、然后是afterPropertiesSet、InitMethod(xml 配置)方法。
3.初始化后置处理
bean对象初始化后，还会进行一些后置处理，比如后续我们将要重点跟踪的AOP动态代理，这里做个预热。我们先看看动态代理的初始化后置处理是怎样的，看个大概，不做深入讨论。
3.1.代理实例注入
//AbstractAutoProxyCreator
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
//上一章节，提到过这个缓存容器，还有印象咩?
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
//创建当前bean的代理，如果这个bean有advice的话，重点看，重要程度5
// Create proxy if we have advice.
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
//如果有切面，则生成该bean的代理
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
//把被代理对象bean实例封装到SingletonTargetSource对象中
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
bean的创建过程跟玩咯，休息一下，后面简单跟下bean销毁的注册过程。^_^