spring中BeanPostProcessor之三：InitDestroyAnnotationBeanPostProcessor（01）

在《spring中BeanPostProcessor之二：CommonAnnotationBeanPostProcessor（01）》一文中，分析到在調用CommonAnnotationBeanPostProcessor類的postProcessMeredBeanDefinition方法時會先調用其父類的postProcessMeredBeanDefinition方法，下面就來分析CommonAnnotationBeanPostProcessor類的父類InitDestroyAnnoatationBeanPostProcessor。

1、概述

咱們先看下CommonAnnotationAnnotationBeanPostProcessor類，上篇中介紹到該類有一個靜態代碼塊會在類初始化的時候調用，在該類中還有一個默認的構造函數，

public CommonAnnotationBeanPostProcessor() {
        setOrder(Ordered.LOWEST_PRECEDENCE - 3);
        //@PostConstruct註解，做用在方法上
        setInitAnnotationType(PostConstruct.class);
        //@PreDestroy註解，做用在方法上
        setDestroyAnnotationType(PreDestroy.class);
        ignoreResourceType("javax.xml.ws.WebServiceContext");
    }

該構造函數中分別調用了setInitAnnotationType和setDestroyAnnotationType方法，兩個方法分別調用其父類的方法，

/**
     * Specify the init annotation to check for, indicating initialization
     * methods to call after configuration of a bean.
     * <p>Any custom annotation can be used, since there are no required
     * annotation attributes. There is no default, although a typical choice
     * is the JSR-250 {@link javax.annotation.PostConstruct} annotation.
     */
    public void setInitAnnotationType(Class<? extends Annotation> initAnnotationType) {
        this.initAnnotationType = initAnnotationType;
    }

    /**
     * Specify the destroy annotation to check for, indicating destruction
     * methods to call when the context is shutting down.
     * <p>Any custom annotation can be used, since there are no required
     * annotation attributes. There is no default, although a typical choice
     * is the JSR-250 {@link javax.annotation.PreDestroy} annotation.
     */
    public void setDestroyAnnotationType(Class<? extends Annotation> destroyAnnotationType) {
        this.destroyAnnotationType = destroyAnnotationType;
    }

 分別給的InitDestroyAnnotationBeanPostProcessor的initAnnotationType和destroyAnnotationType賦值@PostConstruct和@PreDestroy註解。

2、詳述

上面提到在調用CommonAnnotationBeanPostProcessor類的postProcessMeredBeanDefinition方法時會先調用父類的方法，下面看CommonAnnotationBeanPostProcessor的方法，

@Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
        InjectionMetadata metadata = findResourceMetadata(beanName, beanType, null);
        metadata.checkConfigMembers(beanDefinition);
    }

上面是CommonAnnotationBeanPostProcessor的postProcessMergedBeanDefinition方法，能夠看到調用了父類的postProcessMergedBeanDefinition方法，其餘的方法在上篇博客中已經分析，來重點分析InitDestroyAnnotationBeanPostProcessor的postProcessMergedBeanDefinition方法，

@Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        LifecycleMetadata metadata = findLifecycleMetadata(beanType);
        metadata.checkConfigMembers(beanDefinition);
    }

在方法中調用了findLifecycleMetadata和checkConfigMembers方法，

private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
        //判斷lifecycleMetadataCache是否爲空
        if (this.lifecycleMetadataCache == null) {
            // Happens after deserialization, during destruction...
            return buildLifecycleMetadata(clazz);
        }
        // Quick check on the concurrent map first, with minimal locking.
        //從lifecycleMetadataCache中取，若是存在則直接返回，不存在則生成一個LifecycleMetadata對象並返回
        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;
    }

在findLifecycleMetadata方法中主要調用的是buildLifecycleMetadata方法，改方法的返回值是LifecycleMetadata對象，以後把該對象放到lifecycleMetadataCache中，那麼這裏lifecycleMetadata應該是Map類型的，

@Nullable
    private final transient Map<Class<?>, LifecycleMetadata> lifecycleMetadataCache = new ConcurrentHashMap<>(256);

buildLifecycleMetadataf方法以下，

private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
        if (!AnnotationUtils.isCandidateClass(clazz, Arrays.asList(this.initAnnotationType, this.destroyAnnotationType))) {
            return this.emptyLifecycleMetadata;
        }

        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<>();

            //判斷方法上是否存在initAnnotationType的註解，這裏指的就是@PostConstruct註解
            ReflectionUtils.doWithLocalMethods(targetClass, method -> {
                if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
                    LifecycleElement element = new LifecycleElement(method);
                    currInitMethods.add(element);
                    if (logger.isTraceEnabled()) {
                        logger.trace("Found init method on class [" + clazz.getName() + "]: " + method);
                    }
                }
                //判斷方法上是否存在destroyAnnotationType的註解，這裏指的就是@PreDestroy註解
                if (this.destroyAnnotationType != null && method.isAnnotationPresent(this.destroyAnnotationType)) {
                    currDestroyMethods.add(new LifecycleElement(method));
                    if (logger.isTraceEnabled()) {
                        logger.trace("Found destroy method on class [" + clazz.getName() + "]: " + method);
                    }
                }
            });

            initMethods.addAll(0, currInitMethods);
            destroyMethods.addAll(currDestroyMethods);
            targetClass = targetClass.getSuperclass();
        }
        while (targetClass != null && targetClass != Object.class);

        return (initMethods.isEmpty() && destroyMethods.isEmpty() ? this.emptyLifecycleMetadata :
                new LifecycleMetadata(clazz, initMethods, destroyMethods));
    }

從上面的分析，能夠知道InitDestroyAnnotationBeanPostProcessor的postProcessMergedBeanDefinition方法完成的功能就是把類中含有@PostConstrunct和@PreDestroy註解的方法信息緩存到lifecycleMetadataCache中。也就是說在一個被spring管理的類中容許定義被這兩個註解修飾的方法，那方法有那些要求那，看上面的new LifecycleElement這裏，看LifecycleElement類

public LifecycleElement(Method method) {
            if (method.getParameterCount() != 0) {
                throw new IllegalStateException("Lifecycle method annotation requires a no-arg method: " + method);
            }
            this.method = method;
            this.identifier = (Modifier.isPrivate(method.getModifiers()) ?
                    ClassUtils.getQualifiedMethodName(method) : method.getName());
        }

看上面的異常，意思是不容許此類方法有方法參數，若是有參數則會拋異常。

3、使用場景

上面分析了InitDestroyAnnotationBeanPostProcessor類中postProcessMergedBeanDefinition方法的做用，就是把類中有@PostConstruct、@PreDestroy兩個註解的方法信息進行緩存，至於這兩個註解的做用及被這兩個註解標記的方法什麼時候調用後面會繼續分析。

 

原創不易，有不正之處歡迎指正。