spring--12--基于注解的事件监听原理

矫情吗；* 2022-10-27 00:28 706阅读 0赞

# spring–基于注解的事件监听原理 #

### 文章目录 ###

*  spring--基于注解的事件监听原理
 *  1 \`EventListenerMethodProcessor\`（处理\`@EventListener\`注解）
 *  2 \`postProcessBeanFactory()\`方法（\`BeanFactoryPostProcessor\`接口的唯一方法）
 *  3 \`afterSingletonsInstantiated()\`方法（\`SmartInitializingSingleton\`接口的唯一方法）
 *   *  3.1 判断是否使用了作用域代理模式
     *  3.2 获取给定\`beanName\`对应的\`bean\`的类型
     *  3.3 处理\`@EventListener\`注解
     *   *  3.3.1 \`AnnotationUtils.isCandidateClass(targetType, EventListener.class)\`方法，判断指定类是不是可以承载指定注解的候选类
         *  3.3.2 \`isSpringContainerClass()\`方法，判断指定类是不是\`spring\`框架的类
         *  3.3.3 \`MethodIntrospector.selectMethods()\`方法， 内省遍历指定类的方法，得到有\`@EventListener\`注解的方法对象和注解信息对象
         *  3.3.4 \`MetadataLookup\`接口
         *  3.3.5 \`EventListenerFactory\`
 *  4 \`ApplicationListenerMethodAdapter\`（监听方法的监听器适配器）
 *   *  4.1 构造方法
     *  4.2 \`supportsEventType()\`方法（是否支持处理当前事件）
     *  4.3 \`supportsSourceType()\`方法（是否支持处理当前事件源对象）
     *  4.4 \`onApplicationEvent()\`方法（处理监听到的事件的方法）
     *   *  4.4.1 \`resolveArguments(ApplicationEvent event)\`方法，解析得到监听方法的参数值
         *  4.4.2 \`shouldHandle(ApplicationEvent event, @Nullable Object\[\] args)\`方法，判断监听方法是否允许处理事件
         *  4.4.3 \`doInvoke(Object... args) \`方法，反射执行监听方法
         *  4.4.4 \`handleResult(Object result)\`方法，处理监听方法执行之后的结果

上一篇文章讲的基于 `XML`配置的监听器，需要实现对应的 `ApplicationListener`接口，这样和 `spring`的耦合很大，而注解方式配置监听器，就只需要一个方法，并添加 `@EventListener`注解即可。这篇文章，我们就来看看注解方式的事件监听原理。

# 1 `EventListenerMethodProcessor`（处理`@EventListener`注解） #

首先我们得知道`spring`通过`EventListenerMethodProcessor`处理`@EventListener`注解，下面我们来看一下它的类图。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center]

>  *  很明显，它是一个`BeanFactoryPostProcessor`，它会在工厂创建之后，容器其它`bean`实例化之前被调用，增强工厂.
>  *  除此之外，它还实现了`SmartInitializingSingleton`接口，这个接口的调用时机我们也知道，容器中所有单例的非懒加载的`bean`完成初始化后，才会开始调用该接口。

# 2 `postProcessBeanFactory()`方法（`BeanFactoryPostProcessor`接口的唯一方法） #

@Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { 
        this.beanFactory = beanFactory;
    
        //获取容器中所有类型为EventListenerFactory的bean
        Map<String, EventListenerFactory> beans = beanFactory.getBeansOfType(EventListenerFactory.class, false, false);
        List<EventListenerFactory> factories = new ArrayList<>(beans.values());
        //排序（@Order注解）
        AnnotationAwareOrderComparator.sort(factories);
        this.eventListenerFactories = factories;
    }

`getBeansOfType()`方法（获取容器中所有类型为`EventListenerFactory`的`bean`）

@Override
    @SuppressWarnings("unchecked")
    public <T> Map<String, T> getBeansOfType(
        @Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit) throws BeansException { 
    
        /** * getBeanNamesForType()方法：获取容器中type类型的所有bean的名字 * 这个方法在系列文章`spring--1--探究spring的启动流程`的3.5.4章节查看过源码 * 想了解源码的直接移步那篇文章即可 */
        String[] beanNames = getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
        Map<String, T> result = new LinkedHashMap<>(beanNames.length);
        //遍历，调用getBean()方法实例化
        for (String beanName : beanNames) { 
            try { 
                Object beanInstance = getBean(beanName);
                if (!(beanInstance instanceof NullBean)) { 
                    result.put(beanName, (T) beanInstance);
                }
            }
            catch (BeanCreationException ex) { 
                Throwable rootCause = ex.getMostSpecificCause();
                if (rootCause instanceof BeanCurrentlyInCreationException) { 
                    BeanCreationException bce = (BeanCreationException) rootCause;
                    String exBeanName = bce.getBeanName();
                    if (exBeanName != null && isCurrentlyInCreation(exBeanName)) { 
                        if (logger.isTraceEnabled()) { 
                            logger.trace("Ignoring match to currently created bean '" + exBeanName + "': " +
                                         ex.getMessage());
                        }
                        onSuppressedException(ex);
                        // Ignore: indicates a circular reference when autowiring constructors.
                        // We want to find matches other than the currently created bean itself.
                        continue;
                    }
                }
                throw ex;
            }
        }
        return result;
    }

> 总结：
> 
> `postProcessBeanFactory()`方法只是获取并实例化容器中`EventListenerFactory`类型的对象，记录当前`EventListenerMethodProcessor`中。

# 3 `afterSingletonsInstantiated()`方法（`SmartInitializingSingleton`接口的唯一方法） #

> 待容器中所有非懒加载的单例`bean`初始化完成后，便开始执行这个方法

@Override
    public void afterSingletonsInstantiated() { 
        ConfigurableListableBeanFactory beanFactory = this.beanFactory;
        Assert.state(this.beanFactory != null, "No ConfigurableListableBeanFactory set");
        /** * 获取容器中所有类型为Object的bean的名字,实际上就是获取所有被spring管理的bean的名字 * 这个方法在系列文章`spring--1--探究spring的启动流程`的3.5.4章节查看过源码 */
        String[] beanNames = beanFactory.getBeanNamesForType(Object.class);
        for (String beanName : beanNames) { 
            //未使用作用域代理，见3.1
            if (!ScopedProxyUtils.isScopedTarget(beanName)) { 
                Class<?> type = null;
                try { 
                    //获取给定beanName对应的bean的类型，见3.2
                    type = AutoProxyUtils.determineTargetClass(beanFactory, beanName);
                }
                catch (Throwable ex) { 
                    // An unresolvable bean type, probably from a lazy bean - let's ignore it.
                    if (logger.isDebugEnabled()) { 
                        logger.debug("Could not resolve target class for bean with name '" + beanName + "'", ex);
                    }
                }
                if (type != null) { 
                    if (ScopedObject.class.isAssignableFrom(type)) { 
                        try { 
                            Class<?> targetClass = AutoProxyUtils.determineTargetClass(
                                beanFactory, ScopedProxyUtils.getTargetBeanName(beanName));
                            if (targetClass != null) { 
                                type = targetClass;
                            }
                        }
                        catch (Throwable ex) { 
                            // An invalid scoped proxy arrangement - let's ignore it.
                            if (logger.isDebugEnabled()) { 
                                logger.debug("Could not resolve target bean for scoped proxy '" + beanName + "'", ex);
                            }
                        }
                    }
                    try { 
                        //处理@EventListener注解，见3.3
                        processBean(beanName, type);
                    }
                    catch (Throwable ex) { 
                        throw new BeanInitializationException("Failed to process @EventListener " +
                                                              "annotation on bean with name '" + beanName + "'", ex);
                    }
                }
            }
        }
    }

## 3.1 判断是否使用了作用域代理模式 ##

private static final String TARGET_NAME_PREFIX = "scopedTarget.";
    
    /** * Determine if the {@code beanName} is the name of a bean that references * the target bean within a scoped proxy. * @since 4.1.4 */
    public static boolean isScopedTarget(@Nullable String beanName) { 
        return (beanName != null && beanName.startsWith(TARGET_NAME_PREFIX));
    }

> 我们可以看到，这个方法将就是检查`beanName`是不是以`scopedTarget.`开头的，那么这个以`scopedTarget.`开头的`bean`是什么呢？
> 
> 这个在系列文章`spring--6--之ConfigurationClassPostProcessor源码解析`的`2.3.3.5（5-7）`章节提到过，这章节主要讲的是`spring`处理`@Scope`注解的过程。
> 
> `@Scope`注解有两个用途：
> 
>  *  指定`bean`的作用域，`Singleton`，`Prototype`等
>  *  指定`bean`的作用域代理模式，`ScopedProxyMode.DEFAULT`、`ScopedProxyMode.INTERFACES`、`ScopedProxyMode.TARGET_CLASS`
> 
> 如果我们指定了作用域代理模式为`ScopedProxyMode.INTERFACES`、`ScopedProxyMode.TARGET_CLASS`，`spring`会自动为我们创建代理，代理`bean`的名字就以`scopedTarget.`开头。

## 3.2 获取给定`beanName`对应的`bean`的类型 ##

/** * Determine the original target class for the specified bean, if possible, * otherwise falling back to a regular {@code getType} lookup. * @param beanFactory the containing ConfigurableListableBeanFactory * @param beanName the name of the bean * @return the original target class as stored in the bean definition, if any * @since 4.2.3 * @see org.springframework.beans.factory.BeanFactory#getType(String) */
    @Nullable
    public static Class<?> determineTargetClass(
        ConfigurableListableBeanFactory beanFactory, @Nullable String beanName) { 
    
        if (beanName == null) { 
            return null;
        }
        //容器中有该beanName对应的BeanDefinition
        if (beanFactory.containsBeanDefinition(beanName)) { 
            //获取该beanName合并的BeanDefinition
            BeanDefinition bd = beanFactory.getMergedBeanDefinition(beanName);
            /** * ORIGINAL_TARGET_CLASS_ATTRIBUTE= * org.springframework.aop.framework.autoproxy.AutoProxyUtils.originalTargetClass * 获取attribute属性中保存的bean的原始clazz对象 */
            Class<?> targetClass = (Class<?>) bd.getAttribute(ORIGINAL_TARGET_CLASS_ATTRIBUTE);
            if (targetClass != null) { 
                return targetClass;
            }
        }
        /** * 属性中没有就直接getType()方法获取beanName对应的clazz对象 * 这个方法在系列文章`spring--1--探究spring的启动流程`的3.5.5章节查看过源码 */
        return beanFactory.getType(beanName);
    }

## 3.3 处理`@EventListener`注解 ##

private void processBean(final String beanName, final Class<?> targetType) { 
        /** * isCandidateClass()方法判断targetType类是不是可以标注@EventListener注解，见3.3.1 * !isSpringContainerClass()方法，就是判定完全相反，非spring框架的类， * 且必须有@Component注解，见3.3.2 */
        if (!this.nonAnnotatedClasses.contains(targetType) &&
            AnnotationUtils.isCandidateClass(targetType, EventListener.class) &&
            !isSpringContainerClass(targetType)) { 
    
            Map<Method, EventListener> annotatedMethods = null;
            try { 
                //内省，得到targetType类中有@EventListener注解的方法信息，见3.3.3和3.3.4
                annotatedMethods = MethodIntrospector.selectMethods(targetType,
                                                                    (MethodIntrospector.MetadataLookup<EventListener>) method ->
                                                                    AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));
            }
            catch (Throwable ex) { 
                // An unresolvable type in a method signature, probably from a lazy bean - let's ignore it.
                if (logger.isDebugEnabled()) { 
                    logger.debug("Could not resolve methods for bean with name '" + beanName + "'", ex);
                }
            }
    
            //targetType类上没有@EventListener注解，记录下来
            if (CollectionUtils.isEmpty(annotatedMethods)) { 
                this.nonAnnotatedClasses.add(targetType);
                if (logger.isTraceEnabled()) { 
                    logger.trace("No @EventListener annotations found on bean class: " + targetType.getName());
                }
            }
            //targetType类上有@EventListener注解,现在需要将方法适配为一个监听器对象，方便多播器统一处理
            else { 
                // Non-empty set of methods
                ConfigurableApplicationContext context = this.applicationContext;
                Assert.state(context != null, "No ApplicationContext set");
                List<EventListenerFactory> factories = this.eventListenerFactories;
                Assert.state(factories != null, "EventListenerFactory List not initialized");
                //先遍历所有有@EventListener注解的方法
                for (Method method : annotatedMethods.keySet()) { 
                    //再遍历所有的EventListenerFactory事件监听器工厂
                    for (EventListenerFactory factory : factories) { 
                        //EventListenerFactory事件监听器工厂支持处理这个方法,见3.3.5
                        if (factory.supportsMethod(method)) { 
                            Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
                            /** * 使用EventListenerFactory事件监听器工厂将方法适配为一个监听器 * 适配的类型为ApplicationListenerMethodAdapter，见4 */
                            ApplicationListener<?> applicationListener =
                                factory.createApplicationListener(beanName, targetType, methodToUse);
                            if (applicationListener instanceof ApplicationListenerMethodAdapter) { 
                                //初始化方法监听器适配器
                                ((ApplicationListenerMethodAdapter) applicationListener).init(context, this.evaluator);
                            }
                            //将适配的方法监听器对象放入上下文和事件多播器中
                            context.addApplicationListener(applicationListener);
                            break;
                        }
                    }
                }
                if (logger.isDebugEnabled()) { 
                    logger.debug(annotatedMethods.size() + " @EventListener methods processed on bean '" +
                                 beanName + "': " + annotatedMethods);
                }
            }
        }
    }

### 3.3.1 `AnnotationUtils.isCandidateClass(targetType, EventListener.class)`方法，判断指定类是不是可以承载指定注解的候选类 ###

/** * Determine whether the given class is a candidate for carrying the specified annotation * (at type, method or field level). * @param clazz the class to introspect * @param annotationType the searchable annotation type * @return {@code false} if the class is known to have no such annotations at any level; * {@code true} otherwise. Callers will usually perform full method/field introspection * if {@code true} is being returned here. * @since 5.2 * @see #isCandidateClass(Class, String) */
    public static boolean isCandidateClass(Class<?> clazz, Class<? extends Annotation> annotationType) { 
        return isCandidateClass(clazz, annotationType.getName());
    }
    
    
    public static boolean isCandidateClass(Class<?> clazz, String annotationName) { 
        //以java.开头的注解直接返回true
        if (annotationName.startsWith("java.")) { 
            return true;
        }
        /** * return (type.getName().startsWith("java.") || type == Ordered.class); * 这个方法的逻辑很简单，判断给定的类型是不是JDK中的类，或者是Ordered类（不是注解） */
        if (AnnotationsScanner.hasPlainJavaAnnotationsOnly(clazz)) { 
            return false;
        }
        return true;
    }

> 什么样的类是可以承载指定注解的候选类呢？
> 
>  *  `java.`开头的注解，所有的类都能承载
>  *  给定类不能以`java.`开头，也就是说`JDK`中的类都不行
>  *  给定类也不能是`Ordered`类

### 3.3.2 `isSpringContainerClass()`方法，判断指定类是不是`spring`框架的类 ###

/** * Determine whether the given class is an {@code org.springframework} * bean class that is not annotated as a user or test {@link Component}... * which indicates that there is no {@link EventListener} to be found there. * @since 5.1 */
    private static boolean isSpringContainerClass(Class<?> clazz) { 
        /** * 以org.springframework.开头 * 类上没有Component注解 */
        return (clazz.getName().startsWith("org.springframework.") &&
                !AnnotatedElementUtils.isAnnotated(ClassUtils.getUserClass(clazz), Component.class));
    }

> 实际就是`spring`框架的类，且没有`@Component`注解

### 3.3.3 `MethodIntrospector.selectMethods()`方法， 内省遍历指定类的方法，得到有`@EventListener`注解的方法对象和注解信息对象 ###

/** * Select methods on the given target type based on the lookup of associated metadata. * <p>Callers define methods of interest through the {@link MetadataLookup} parameter, * allowing to collect the associated metadata into the result map. * @param targetType the target type to search methods on * @param metadataLookup a {@link MetadataLookup} callback to inspect methods of interest, * returning non-null metadata to be associated with a given method if there is a match, * or {@code null} for no match * @return the selected methods associated with their metadata (in the order of retrieval), * or an empty map in case of no match */
    public static <T> Map<Method, T> selectMethods(Class<?> targetType, final MetadataLookup<T> metadataLookup) { 
        final Map<Method, T> methodMap = new LinkedHashMap<>();
        Set<Class<?>> handlerTypes = new LinkedHashSet<>();
        Class<?> specificHandlerType = null;
    
        //非代理类
        if (!Proxy.isProxyClass(targetType)) { 
            //获取给定类的用户类，通常就是给定类，但在CGLIB子类的情况下返回原始类
            specificHandlerType = ClassUtils.getUserClass(targetType);
            handlerTypes.add(specificHandlerType);
        }
        //除了检查当前类，还需要检查它所有接口信息
        handlerTypes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetType));
    
        for (Class<?> currentHandlerType : handlerTypes) { 
            //目标类类型
            final Class<?> targetClass = (specificHandlerType != null ? specificHandlerType : currentHandlerType);
    
            /** * 反射遍历currentHandlerType类的所有方法 * ReflectionUtils.USER_DECLARED_METHODS这是一个方法过滤器，表明只需要用户声明的方法 */
            ReflectionUtils.doWithMethods(currentHandlerType, method -> { 
                //找到method在targetClass类（就是当前bean）中重写的方法对象，没有就返回原method对象
                Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
                /** * 调用MetadataLookup接口的inspect方法判断方法上是否包含@EventListener注解 * 包含就直接返回@EventListener注解信息 * 否则返回null * 见3.3.4 */
                T result = metadataLookup.inspect(specificMethod);
                //该方法有@EventListener注解
                if (result != null) { 
                    //获取指定方法的桥接方法
                    Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
                    /** * 桥接方法和原方法相同 * 桥接方法上没有@EventListener注解 */
                    if (bridgedMethod == specificMethod || metadataLookup.inspect(bridgedMethod) == null) { 
                        //存入map集合中
                        methodMap.put(specificMethod, result);
                    }
                }
            }, ReflectionUtils.USER_DECLARED_METHODS);
        }
    
        return methodMap;
    }

### 3.3.4 `MetadataLookup`接口 ###

/** * A callback interface for metadata lookup on a given method. * @param <T> the type of metadata returned */
    @FunctionalInterface
    public interface MetadataLookup<T> { 
    
        /** * Perform a lookup on the given method and return associated metadata, if any. * @param method the method to inspect * @return non-null metadata to be associated with a method if there is a match, * or {@code null} for no match */
        @Nullable
        T inspect(Method method);
    }

> 这是`MethodIntrospector`类中定义的一个内部接口，仅有一个`inspect`方法。

MethodIntrospector.selectMethods(targetType,
                                     (MethodIntrospector.MetadataLookup<EventListener>) method ->
                                     AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));

>  *  很明显，这个是`JAVA8`中的函数式编程，匿名内部类的简写方式。
>  *  `AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class)`方法也很容易理解，就是获取该方法上的`@EventListener`注解信息。

### 3.3.5 `EventListenerFactory` ###

public interface EventListenerFactory { 
    
        /** * Specify if this factory supports the specified {@link Method}. * @param method an {@link EventListener} annotated method * @return {@code true} if this factory supports the specified method */
        boolean supportsMethod(Method method);
    
        /** * Create an {@link ApplicationListener} for the specified method. * @param beanName the name of the bean * @param type the target type of the instance * @param method the {@link EventListener} annotated method * @return an application listener, suitable to invoke the specified method */
        ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method);

> 这个接口就两个方法
> 
>  *  `supportsMethod()`方法判断该`EventListenerFactory`是否支持将该方法对象适配为监听器对象
>  *  `createApplicationListener()`方法将方法对象适配为监听器对象

`spring`提供了一个默认实现`DefaultEventListenerFactory`，下面是这个类的源码

public class DefaultEventListenerFactory implements EventListenerFactory, Ordered { 
    
        private int order = LOWEST_PRECEDENCE;
    
    
        public void setOrder(int order) { 
            this.order = order;
        }
    
        @Override
        public int getOrder() { 
            return this.order;
        }
    
    
        //直接返回true，也就是说，所有方法都支持
        @Override
        public boolean supportsMethod(Method method) { 
            return true;
        }
    
        
        //创建一个ApplicationListenerMethodAdapter，监听方法的监听器适配器
        @Override
        public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) { 
            return new ApplicationListenerMethodAdapter(beanName, type, method);
        }
    
    }

# 4 `ApplicationListenerMethodAdapter`（监听方法的监听器适配器） #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center 1]

该类实现了`GenericApplicationListener`接口，所以我们重点关注该接口的中`supportsEventType()`方法、`supportsSourceType()`方法、`onApplicationEvent()`方法和它自身的构造方法。

## 4.1 构造方法 ##

public class ApplicationListenerMethodAdapter implements GenericApplicationListener { 
    
        //监听方法所属的bean的名字
        private final String beanName;
    
        //监听方法的桥接方法对象
        private final Method method;
    
        //监听方法原对象
        private final Method targetMethod;
    
        private final AnnotatedElementKey methodKey;
    
        //能够监听的事件的类型
        private final List<ResolvableType> declaredEventTypes;
    
        //监听的条件（使用SpEL表达式）
        @Nullable
        private final String condition;
    
        //监听器的顺序
        private final int order;
    
        @Nullable
        private ApplicationContext applicationContext;
    
        @Nullable
        private EventExpressionEvaluator evaluator;
    
    
        public ApplicationListenerMethodAdapter(String beanName, Class<?> targetClass, Method method) { 
            //监听方法所属的bean的名字
            this.beanName = beanName;
            //当前方法的桥接方法对象
            this.method = BridgeMethodResolver.findBridgedMethod(method);
            /** * 如果是非代理类，那么就获取method在targetClass类上重写的方法对象 * 如果是代理类，那就直接使用当前桥接方法对象 * 在3.3.3中已经调用过getMostSpecificMethod方法，它会获取method在指定bean上的方法对象 */
            this.targetMethod = (!Proxy.isProxyClass(targetClass) ?
                                 AopUtils.getMostSpecificMethod(method, targetClass) : this.method);
            this.methodKey = new AnnotatedElementKey(this.targetMethod, targetClass);
    
            //获取目标方法上的@EventListener注解信息
            EventListener ann = AnnotatedElementUtils.findMergedAnnotation(this.targetMethod, EventListener.class);
            //解析该注解上声明的监听的事件类型
            this.declaredEventTypes = resolveDeclaredEventTypes(method, ann);
            //获取@EventListener注解的condition属性
            this.condition = (ann != null ? ann.condition() : null);
            //解析监听方法上标注的@Order注解
            this.order = resolveOrder(this.targetMethod);
        }
    
        /********************解析@EventListener注解上声明的监听事件的类型**********************/
        private static List<ResolvableType> resolveDeclaredEventTypes(Method method, @Nullable EventListener ann) { 
            //监听方法的参数只能为一个
            int count = method.getParameterCount();
            if (count > 1) { 
                throw new IllegalStateException(
                    "Maximum one parameter is allowed for event listener method: " + method);
            }
    
            if (ann != null) { 
                //获取用户在@EventListener注解的classes属性中指定的clazz对象
                Class<?>[] classes = ann.classes();
                if (classes.length > 0) { 
                    List<ResolvableType> types = new ArrayList<>(classes.length);
                    for (Class<?> eventType : classes) { 
                        //ResolvableType.forClass()的到对应类的ResolvableType类型
                        types.add(ResolvableType.forClass(eventType));
                    }
                    return types;
                }
            }
    
            if (count == 0) { 
                throw new IllegalStateException(
                    "Event parameter is mandatory for event listener method: " + method);
            }
            /** * ResolvableType.forMethodParameter(method, 0) * 获取方法索引为0的参数的ResolvableType类型 */
            return Collections.singletonList(ResolvableType.forMethodParameter(method, 0));
        }
    
    
        /****************************解析监听方法上标注的@Order注解***************************/
        private static int resolveOrder(Method method) { 
            Order ann = AnnotatedElementUtils.findMergedAnnotation(method, Order.class);
            return (ann != null ? ann.value() : 0);
        }
    }

## 4.2 `supportsEventType()`方法（是否支持处理当前事件） ##

@Override
    public boolean supportsEventType(ResolvableType eventType) { 
        
        for (ResolvableType declaredEventType : this.declaredEventTypes) { 
            //@EventListener注解上声明事件类型是当前事件的父类或相同，则支持处理该事件
            if (declaredEventType.isAssignableFrom(eventType)) { 
                return true;
            }
            /** * PayloadApplicationEvent是适配事件，当用户自定义的事件为实现ApplicationEvent接口时 * spring在发布事件时会自动将该事件适配为PayloadApplicationEvent */
            if (PayloadApplicationEvent.class.isAssignableFrom(eventType.toClass())) { 
                //获取适配事件的泛型信息，实际就是用户自定义事件的类型
                ResolvableType payloadType = eventType.as(PayloadApplicationEvent.class).getGeneric();
                if (declaredEventType.isAssignableFrom(payloadType)) { 
                    return true;
                }
            }
        }
        //判断当前事件对象中是否包含不可解析的泛型
        return eventType.hasUnresolvableGenerics();
    }

## 4.3 `supportsSourceType()`方法（是否支持处理当前事件源对象） ##

@Override
    public boolean supportsSourceType(@Nullable Class<?> sourceType) { 
       return true;
    }

## 4.4 `onApplicationEvent()`方法（处理监听到的事件的方法） ##

@Override
    public void onApplicationEvent(ApplicationEvent event) { 
        processEvent(event);
    }
    
    
    /** * Process the specified {@link ApplicationEvent}, checking if the condition * matches and handling a non-null result, if any. */
    public void processEvent(ApplicationEvent event) { 
        //解析得到监听方法的参数值，方便通过反射直接调用方法监听方法，见4.4.1
        Object[] args = resolveArguments(event);
        //监听方法允许处理事件，见4.4.2
        if (shouldHandle(event, args)) { 
            //反射执行监听方法，见4.4.3
            Object result = doInvoke(args);
            if (result != null) { 
                handleResult(result);
            }
            else { 
                logger.trace("No result object given - no result to handle");
            }
        }
    }

### 4.4.1 `resolveArguments(ApplicationEvent event)`方法，解析得到监听方法的参数值 ###

/** * Resolve the method arguments to use for the specified {@link ApplicationEvent}. * <p>These arguments will be used to invoke the method handled by this instance. * Can return {@code null} to indicate that no suitable arguments could be resolved * and therefore the method should not be invoked at all for the specified event. */
    @Nullable
    protected Object[] resolveArguments(ApplicationEvent event) { 
        //获取该事件在@EventListener注解中声明支持处理的ResolvableType类型
        ResolvableType declaredEventType = getResolvableType(event);
        //不支持处理该事件
        if (declaredEventType == null) { 
            return null;
        }
        //监听方法的参数个数为0，不需要参数
        if (this.method.getParameterCount() == 0) { 
            return new Object[0];
        }
        //事件的clazz对象
        Class<?> declaredEventClass = declaredEventType.toClass();
        //用户自定义的未实现ApplicationEvent接口的事件
        if (!ApplicationEvent.class.isAssignableFrom(declaredEventClass) &&
            event instanceof PayloadApplicationEvent) { 
            //获取原始的事件对象
            Object payload = ((PayloadApplicationEvent<?>) event).getPayload();
            if (declaredEventClass.isInstance(payload)) { 
                return new Object[] { payload};
            }
        }
        //实现了ApplicationEvent接口的事件
        return new Object[] { event};
    }
    
    
    /*********************************解析事件类型*************************************/
    @Nullable
    private ResolvableType getResolvableType(ApplicationEvent event) { 
        ResolvableType payloadType = null;
        //当前事件是用户自定义的未实现ApplicationEvent接口的事件
        if (event instanceof PayloadApplicationEvent) { 
            PayloadApplicationEvent<?> payloadEvent = (PayloadApplicationEvent<?>) event;
            ResolvableType eventType = payloadEvent.getResolvableType();
            if (eventType != null) { 
                //获取用户自定义事件的真实类型
                payloadType = eventType.as(PayloadApplicationEvent.class).getGeneric();
            }
        }
        //遍历用户在@EventListener注解上声明的可监听的事件类型
        for (ResolvableType declaredEventType : this.declaredEventTypes) { 
            //获取可监听的事件的clazz对象
            Class<?> eventClass = declaredEventType.toClass();
            /** * 如果声明的可监听的事件类型中包含用户自定义的事件类型 * 那么就返回声明的类型 */
            if (!ApplicationEvent.class.isAssignableFrom(eventClass) &&
                payloadType != null && declaredEventType.isAssignableFrom(payloadType)) { 
                return declaredEventType;
            }
            /** * 如果当前事件对象是声明的可监听的事件类型的一个实例 * 那么就返回声明的类型 */
            if (eventClass.isInstance(event)) { 
                return declaredEventType;
            }
        }
        return null;
    }

> 这个方法主要是得到监听方法的参数值

### 4.4.2 `shouldHandle(ApplicationEvent event, @Nullable Object[] args)`方法，判断监听方法是否允许处理事件 ###

private boolean shouldHandle(ApplicationEvent event, @Nullable Object[] args) { 
        if (args == null) { 
            return false;
        }
        //获取@EventListener注解上指定的SpEL表达式
        String condition = getCondition();
        //用户指定了SpEL表达式
        if (StringUtils.hasText(condition)) { 
            Assert.notNull(this.evaluator, "EventExpressionEvaluator must not be null");
            //计算SpEL表达式的结果
            return this.evaluator.condition(
                condition, event, this.targetMethod, this.methodKey, args, this.applicationContext);
        }
        //用户未指定SpEL表达式，允许处理事件
        return true;
    }
    
    
    /** * Return the condition to use. * <p>Matches the {@code condition} attribute of the {@link EventListener} * annotation or any matching attribute on a composed annotation that * is meta-annotated with {@code @EventListener}. */
    @Nullable
    protected String getCondition() { 
        /** * 构造ApplicationListenerMethodAdapter对象的时候，就解析@EventListener注解 * 得到了condition属性信息 */
        return this.condition;
    }

### 4.4.3 `doInvoke(Object... args)`方法，反射执行监听方法 ###

/** * Invoke the event listener method with the given argument values. */
    @Nullable
    protected Object doInvoke(Object... args) { 
        //从容器中获取监听方法所在类的对象
        Object bean = getTargetBean();
        // Detect package-protected NullBean instance through equals(null) check
        if (bean.equals(null)) { 
            return null;
        }
    
        //允许监听方法强制执行
        ReflectionUtils.makeAccessible(this.method);
        try { 
            //反射执行监听方法
            return this.method.invoke(bean, args);
        }
        catch (IllegalArgumentException ex) { 
            assertTargetBean(this.method, bean, args);
            throw new IllegalStateException(getInvocationErrorMessage(bean, ex.getMessage(), args), ex);
        }
        catch (IllegalAccessException ex) { 
            throw new IllegalStateException(getInvocationErrorMessage(bean, ex.getMessage(), args), ex);
        }
        catch (InvocationTargetException ex) { 
            // Throw underlying exception
            Throwable targetException = ex.getTargetException();
            if (targetException instanceof RuntimeException) { 
                throw (RuntimeException) targetException;
            }
            else { 
                String msg = getInvocationErrorMessage(bean, "Failed to invoke event listener method", args);
                throw new UndeclaredThrowableException(targetException, msg);
            }
        }
    }
    
    
    /** * Return the target bean instance to use. */
    protected Object getTargetBean() { 
        Assert.notNull(this.applicationContext, "ApplicationContext must no be null");
        //从容器中获取beanName的对象
        return this.applicationContext.getBean(this.beanName);
    }

### 4.4.4 `handleResult(Object result)`方法，处理监听方法执行之后的结果 ###

protected void handleResult(Object result) { 
        if (reactiveStreamsPresent && new ReactiveResultHandler().subscribeToPublisher(result)) { 
            if (logger.isTraceEnabled()) { 
                logger.trace("Adapted to reactive result: " + result);
            }
        }
        else if (result instanceof CompletionStage) { 
            ((CompletionStage<?>) result).whenComplete((event, ex) -> { 
                if (ex != null) { 
                    handleAsyncError(ex);
                }
                else if (event != null) { 
                    publishEvent(event);
                }
            });
        }
        else if (result instanceof ListenableFuture) { 
            ((ListenableFuture<?>) result).addCallback(this::publishEvents, this::handleAsyncError);
        }
        else { 
            publishEvents(result);
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/a453c989543b44c8b9ab003df9b05092.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221024/6d710057364f42e0a9734776743284d6.png