作用
1.注解@PostConstruct可以添加在类的方法上面，如果这个类被IOC容器托管，那么在对Bean进行初始化前的时候会调用被这个注解修饰的方法
被定义在哪里？
1.被定义在了CommonAnnotationBeanPostProcessor类，这个类是InitDestroyAnnotationBeanPostProcessor类的子类，也实现了InstantiationAwareBeanPostProcessor接口（BeanDefinition的后置处理接口）。代码展示：
public CommonAnnotationBeanPostProcessor() {
setOrder(Ordered.LOWEST_PRECEDENCE - 3);
setInitAnnotationType(PostConstruct.class);
setDestroyAnnotationType(PreDestroy.class);
ignoreResourceType("javax.xml.ws.WebServiceContext");
}
2.故在这个CommonAnnotationBeanPostProcessor类实例化的时候注解就会被定义下来。
在何处被扫描？
1.在BeanDefinition的后置处理时调用 postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName)进行扫描
2.在初始化前中调用处理器InitDestroyAnnotationBeanPostProcessor的postProcessBeforeInitialization方法进行扫描
汇总：
两处扫描的本质都是调用了 LifecycleMetadata findLifecycleMetadata(Class<?> clazz)方法（位于InitDestroyAnnotationBeanPostProcessor类里面），
扫描方法分析
1.findLifecycleMetadata方法分析：
说明：
1）判断缓存有没有构建，没有构建则调用构建Metadata对象的方法
2）缓存构建了，就去缓存里面寻找，没找到就调用构建Metadata对象的方法，把拿回来的对象存入缓存中
代码展示：
private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
if (this.lifecycleMetadataCache == null) {
return buildLifecycleMetadata(clazz);
}
LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
if (metadata == null) {
synchronized (this.lifecycleMetadataCache) {
metadata = this.lifecycleMetadataCache.get(clazz);
if (metadata == null) {
metadata = buildLifecycleMetadata(clazz);
this.lifecycleMetadataCache.put(clazz, metadata);
}
return metadata;
}
}
return metadata;
}
2.buildLifecycleMetadata方法分析：
说明：
1）主要应用类反射机制的概念，doWithLocalMethods通过类获取所有方法，然后利用反射机制构建调用对象
2）LifecycleMetadata对象便是包含了该类的所有的初始化方法和销毁方法
代码展示：
private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
List<LifecycleElement> initMethods = new ArrayList<>();
List<LifecycleElement> destroyMethods = new ArrayList<>();
Class<?> targetClass = clazz;
do {
final List<LifecycleElement> currInitMethods = new ArrayList<>();
final List<LifecycleElement> currDestroyMethods = new ArrayList<>();
//doWithLocalMethods，深入源码其实可知是通过类对象取出所有的方法，逐一进行调用lambda表达式的方法
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
//判断初始化方法
if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
LifecycleElement element = new LifecycleElement(method);
currInitMethods.add(element);
}
//判断销毁方法
if (this.destroyAnnotationType != null && method.isAnnotationPresent(this.destroyAnnotationType)) {
currDestroyMethods.add(new LifecycleElement(method));
}
});
//根据继承关系故会有父类要比子类先构造，子类要比父类先销毁
//所以这里采用头插法
initMethods.addAll(0, currInitMethods);
//这里会往末尾存放
destroyMethods.addAll(currDestroyMethods);
//寻找父类
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
return new LifecycleMetadata(clazz, initMethods, destroyMethods);
}
在何处被调用？（过程分析）
1.既然是在初始化前的处理器中调用，而且源于InitDestroyAnnotationBeanPostProcessor这个处理器会在初始化前这个步骤中执行@PostConstruct的方法
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
//这一步是寻找
LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
try {
//这一步是调用
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.基于反射机制调用方法对象来调用类对象的方法：
public void invokeInitMethods(Object target, String beanName) throws Throwable {
Collection<LifecycleElement> checkedInitMethods = this.checkedInitMethods;
Collection<LifecycleElement> initMethodsToIterate = (checkedInitMethods != null ? checkedInitMethods : this.initMethods);
if (!initMethodsToIterate.isEmpty()) {
for (LifecycleElement element : initMethodsToIterate) {
element.invoke(target);
}
}
}
postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName)
