使用spring时,在某个Class被初始化之后再执行一些代码,可以
- 用
@PostConstruct
注解方法,如:
package org.dhframework;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
@Component
public class Test4 {
@PostConstruct
public void pc1() {
System.out.println("Test4.postConstruct()");
}
}
@PostConstruct应用场景:
在生成对象时候做一些初始化操作,而这些初始化操作又依赖于依赖注入(populateBean
),那么就无法在构造函数中实现。这时,可以使用@PostConstruct注解一个方法来完成初始化,@PostConstruct注解的方法将会在依赖注入完成后被自动调用。
题外话:为何构造函数中无法使用依赖注入的属性呢?
因为在做doCreateBean时,大致的步骤是这样的
- 实例化bean,这里会调用构造方法
- 填充属性,就是依赖注入
- 初始化bean,
- 调用后置处理器,其中会执行@PostConstruct注解方法
- 执行bean的生命周期中的初始化回调方法,也就是InitializingBean接口的afterPropertiesSet()方法
那么,显然在构造方法执行的时候,属性填充还没有开始,所以 构造函数中无法使用依赖注入的属性
- 也可以让该Class实现
InitializingBean
接口,重写public void afterPropertiesSet() throws Exception{ ... }
方法,如:
package org.dhframework;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
@Component
public class Test4 implements InitializingBean {
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("Test4 InitializingBean.afterPropertiesSet()");
}
}
这两种方式,在源码上,都是在doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
方法中,populateBean(beanName, mbd, instanceWrapper)
填充属性(依赖注入)完成后的initializeBean(beanName, exposedObject, mbd)
方法里完成的。
看下方法的代码:
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 1. 第七次调用后置处理器,执行bean初始化之前需要被执行的方法,如@PostConstruct注解的方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 2. 执行InitializingBean接口的afterPropertiesSet()方法
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()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
@PostConstruct注解方法的执行
上面代码,第一处注释,第七次调用后置处理器,
在后置处理器CommonAnnotationBeanPostProcessor
的父类InitDestroyAnnotationBeanPostProcessor
的postProcessBeforeInitialization(Object bean, String beanName)
方法里进行@PostConstruct注解方法的处理
注意metadata里面,initMethods与checkedInitMethods的值。(这两个属性是何时赋值的,请看spring(碎片001), @PostConstruct相关,metadata里的initMethods何时被赋值
)
接下来执行
metadata.invokeInitMethods(bean, beanName);
public void invokeInitMethods(Object target, String beanName) throws Throwable {
// 通过checkedInitMethods得到initMethodsToIterate
Collection<LifecycleElement> checkedInitMethods = this.checkedInitMethods;
Collection<LifecycleElement> initMethodsToIterate =
(checkedInitMethods != null ? checkedInitMethods : this.initMethods);
if (!initMethodsToIterate.isEmpty()) {
for (LifecycleElement element : initMethodsToIterate) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking init method on bean '" + beanName + "': " + element.getMethod());
}
// 接下来调用下面的invoke方法反射执行@PostConstruct注解的方法
element.invoke(target);
}
}
}
public void invoke(Object target) throws Throwable {
ReflectionUtils.makeAccessible(this.method);
this.method.invoke(target, (Object[]) null);
}
至此,@PostConstruct注解方法执行完毕
下面来看InitializingBean
接口的afterPropertiesSet()
方法,
由下图可以看到,invokeInitMethods()
方法的执行是紧接着后置处理器的执行
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
// 第一处注释:如果实现了InitializingBean,就会执行afterPropertiesSet()方法
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 {
// 第二处注释:执行afterPropertiesSet()
((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)) {
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
上面的第一处,第二处两处注释已经很好的说明了afterPropertiesSet()的执行步骤了。首先判断当前bean是否实现了InitializingBean
接口,然后去执行afterPropertiesSet()
方法
再来看看第三住注释:这里是调用init-method指定的方法
protected void invokeCustomInitMethod(String beanName, final Object bean, RootBeanDefinition mbd)
throws Throwable {
// 先来一顿操作猛如虎
String initMethodName = mbd.getInitMethodName();
Assert.state(initMethodName != null, "No init method set");
Method initMethod = (mbd.isNonPublicAccessAllowed() ?
BeanUtils.findMethod(bean.getClass(), initMethodName) :
ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));
if (initMethod == null) {
if (mbd.isEnforceInitMethod()) {
throw new BeanDefinitionValidationException("Could not find an init method named '" +
initMethodName + "' on bean with name '" + beanName + "'");
}
else {
if (logger.isTraceEnabled()) {
logger.trace("No default init method named '" + initMethodName +
"' found on bean with name '" + beanName + "'");
}
// Ignore non-existent default lifecycle methods.
return;
}
}
if (logger.isTraceEnabled()) {
logger.trace("Invoking init method '" + initMethodName + "' on bean with name '" + beanName + "'");
}
Method methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod);
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
ReflectionUtils.makeAccessible(methodToInvoke);
return null;
});
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
methodToInvoke.invoke(bean), getAccessControlContext());
}
catch (PrivilegedActionException pae) {
InvocationTargetException ex = (InvocationTargetException) pae.getException();
throw ex.getTargetException();
}
}
else {
try {
ReflectionUtils.makeAccessible(methodToInvoke);
// 这里就调用init-method了
methodToInvoke.invoke(bean);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
}