Spring源码之MethodIntrospector的原理解析与实际应用

冷不防 2022-12-27 01:46 18阅读 0赞

# 一、概述 #

## 1.1 说明 ##

从4.x版本开始，`MethodIntrospector`是`spring-core`中一个频繁使用的工具类。

该类通常用来：用于搜索与元数据相关的方法的算法，包括接口和父类，同时还处理参数化方法以及基于接口和基于类的代理遇到的常见情况。**通常（但不是必须）用于查找带注释的处理程序方法**。

# 二、源码解析 #

## 2.1 源码 ##

/** * Defines the algorithm for searching for metadata-associated methods exhaustively * including interfaces and parent classes while also dealing with parameterized methods * as well as common scenarios encountered with interface and class-based proxies. * * <p>Typically, but not necessarily, used for finding annotated handler methods. * * @author Juergen Hoeller * @author Rossen Stoyanchev * @since 4.2.3 */
    public final class MethodIntrospector { 
    
    	private MethodIntrospector() { 
    	}
    
    
    	/** * 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)) { 
    			specificHandlerType = ClassUtils.getUserClass(targetType);
    			handlerTypes.add(specificHandlerType);
    		}
    		handlerTypes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetType));
    
    		for (Class<?> currentHandlerType : handlerTypes) { 
    			final Class<?> targetClass = (specificHandlerType != null ? specificHandlerType : currentHandlerType);
    
    			ReflectionUtils.doWithMethods(currentHandlerType, method -> { 
    				Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
    				T result = metadataLookup.inspect(specificMethod);
    				if (result != null) { 
    					Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
    					if (bridgedMethod == specificMethod || metadataLookup.inspect(bridgedMethod) == null) { 
    						methodMap.put(specificMethod, result);
    					}
    				}
    			}, ReflectionUtils.USER_DECLARED_METHODS);
    		}
    
    		return methodMap;
    	}
    
    	/** * Select methods on the given target type based on a filter. * <p>Callers define methods of interest through the {@code MethodFilter} parameter. * @param targetType the target type to search methods on * @param methodFilter a {@code MethodFilter} to help * recognize handler methods of interest * @return the selected methods, or an empty set in case of no match */
    	public static Set<Method> selectMethods(Class<?> targetType, final ReflectionUtils.MethodFilter methodFilter) { 
    		return selectMethods(targetType,
    				(MetadataLookup<Boolean>) method -> (methodFilter.matches(method) ? Boolean.TRUE : null)).keySet();
    	}
    
    	/** * Select an invocable method on the target type: either the given method itself * if actually exposed on the target type, or otherwise a corresponding method * on one of the target type's interfaces or on the target type itself. * <p>Matches on user-declared interfaces will be preferred since they are likely * to contain relevant metadata that corresponds to the method on the target class. * @param method the method to check * @param targetType the target type to search methods on * (typically an interface-based JDK proxy) * @return a corresponding invocable method on the target type * @throws IllegalStateException if the given method is not invocable on the given * target type (typically due to a proxy mismatch) */
    	public static Method selectInvocableMethod(Method method, Class<?> targetType) { 
    		if (method.getDeclaringClass().isAssignableFrom(targetType)) { 
    			return method;
    		}
    		try { 
    			String methodName = method.getName();
    			Class<?>[] parameterTypes = method.getParameterTypes();
    			for (Class<?> ifc : targetType.getInterfaces()) { 
    				try { 
    					return ifc.getMethod(methodName, parameterTypes);
    				}
    				catch (NoSuchMethodException ex) { 
    					// Alright, not on this interface then...
    				}
    			}
    			// A final desperate attempt on the proxy class itself...
    			return targetType.getMethod(methodName, parameterTypes);
    		}
    		catch (NoSuchMethodException ex) { 
    			throw new IllegalStateException(String.format(
    					"Need to invoke method '%s' declared on target class '%s', " +
    					"but not found in any interface(s) of the exposed proxy type. " +
    					"Either pull the method up to an interface or switch to CGLIB " +
    					"proxies by enforcing proxy-target-class mode in your configuration.",
    					method.getName(), method.getDeclaringClass().getSimpleName()));
    		}
    	}
    
    
    	/** * 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);
    	}
    
    }

## 2.2 原理解析 ##

### 2.2.1 MetadataLookup ###

*在给定方法上用于元数据查找的回调接口。*

/** * A callback interface for metadata lookup on a given method. * @param <T> the type of metadata returned */
    	@FunctionalInterface
    	public interface MetadataLookup<T> { 
    
    		/** * 对给定的方法执行查找并返回关联的元数据（如果有） * @param method 需要檢查的方法 * @return 如果存在匹配项，则将非null元数据与方法关联；如果没有匹配项，则为null */
    		@Nullable
    		T inspect(Method method);
    	}

*经常结合其他工具类来实现该接口类。* 例如：查询方法上的第一个MyAnnotation注解并返回

/** * MyAnnotation注解 * * @author Leon * @date 2020-12-07 11:06 */
    public @interface MyAnnotation
    { 
    }
    
    /** * @MyAnnotation 注解的元数据查询类 * * @author Leon * @date 2020-12-07 11:05 */
    public class MyAnnotationLookup implements MethodIntrospector.MetadataLookup<MyAnnotation>
    { 
    
    	/** * 查询该方法上的第一个的MyAnnotation注解并返回 */
    	@Override
    	public MyAnnotation inspect(Method method)
    	{ 
    		return AnnotatedElementUtils.findMergedAnnotation(method, MyAnnotation.class);
    	}
    }

### 2.2.2 selectMethods(Class, MetadataLookup) ###

根据相关联的元数据查找选择给定目标类型上的方法。

调用者通过自定义`MetadataLookup`参数定义感兴趣的方法，从而可以将关联的元数据收集到结果集中去。

/** * 根据自定义的metadataLookup参数在指定类上查询符合要求的method结果集作为结果返回 * * targetType： 方法搜索所基于的目标类的类型 * metadataLookup： 自定义的metadataLookup参数。如果存在匹配，则返回要与给定方法关联的非空元数据，如果没有匹配，则返回null */
    	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)) { 
    			// 如果是代理类，找到实际的类型
    			specificHandlerType = ClassUtils.getUserClass(targetType);
    			handlerTypes.add(specificHandlerType);
    		}
    		handlerTypes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetType));
    
    		// 遍历所有找到的class对象:包括当前类自身、其父类、其实现的接口
    		for (Class<?> currentHandlerType : handlerTypes) { 
    			final Class<?> targetClass = (specificHandlerType != null ? specificHandlerType : currentHandlerType);
    
    			ReflectionUtils.doWithMethods(currentHandlerType, method -> { 
    				Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
    				// 获取方法关联的元数据，这里实际是指注解
    				T result = metadataLookup.inspect(specificMethod);
    				if (result != null) { 
    					// 找到所提供的Method的原始方法
    					Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
    					if (bridgedMethod == specificMethod || metadataLookup.inspect(bridgedMethod) == null) { 
    						methodMap.put(specificMethod, result);
    					}
    				}
    			}, ReflectionUtils.USER_DECLARED_METHODS);
    		}
    
    		return methodMap;
    	}

# 三、实际应用 #

在`xxl_job`开源组件就有使用到这个类，做一些初始化的工作。具体详见，我们以后自己做第三组件的时候也可以考虑该类实现关联的功能。

public class XxlJobSpringExecutor extends XxlJobExecutor implements ApplicationContextAware, SmartInitializingSingleton, DisposableBean { 
        private static final Logger logger = LoggerFactory.getLogger(XxlJobSpringExecutor.class);
    
    
        // start
        @Override
        public void afterSingletonsInstantiated() { 
    
            // init JobHandler Repository
            /*initJobHandlerRepository(applicationContext);*/
    
            // init JobHandler Repository (for method)
            initJobHandlerMethodRepository(applicationContext);
    
            // refresh GlueFactory
            GlueFactory.refreshInstance(1);
    
            // super start
            try { 
                super.start();
            } catch (Exception e) { 
                throw new RuntimeException(e);
            }
        }
    
        // destroy
        @Override
        public void destroy() { 
            super.destroy();
        }
    
    
        /*private void initJobHandlerRepository(ApplicationContext applicationContext) { if (applicationContext == null) { return; } // init job handler action Map<String, Object> serviceBeanMap = applicationContext.getBeansWithAnnotation(JobHandler.class); if (serviceBeanMap != null && serviceBeanMap.size() > 0) { for (Object serviceBean : serviceBeanMap.values()) { if (serviceBean instanceof IJobHandler) { String name = serviceBean.getClass().getAnnotation(JobHandler.class).value(); IJobHandler handler = (IJobHandler) serviceBean; if (loadJobHandler(name) != null) { throw new RuntimeException("xxl-job jobhandler[" + name + "] naming conflicts."); } registJobHandler(name, handler); } } } }*/
    
        private void initJobHandlerMethodRepository(ApplicationContext applicationContext) { 
            if (applicationContext == null) { 
                return;
            }
            // init job handler from method
            String[] beanDefinitionNames = applicationContext.getBeanNamesForType(Object.class, false, true);
            for (String beanDefinitionName : beanDefinitionNames) { 
                Object bean = applicationContext.getBean(beanDefinitionName);
    
                Map<Method, XxlJob> annotatedMethods = null;   // referred to ：org.springframework.context.event.EventListenerMethodProcessor.processBean
                try { 
                	// 含义解释：
                	// 在当前bean的类中，寻找上标有@XxlJob注解的方法。可能存在0个、1个或多个Method。将结果集以Map<Method, XxlJob>的形式返回。
                    annotatedMethods = MethodIntrospector.selectMethods(bean.getClass(),
                            new MethodIntrospector.MetadataLookup<XxlJob>() { 
                                @Override
                                public XxlJob inspect(Method method) { 
                                    return AnnotatedElementUtils.findMergedAnnotation(method, XxlJob.class);
                                }
                            });
                } catch (Throwable ex) { 
                    logger.error("xxl-job method-jobhandler resolve error for bean[" + beanDefinitionName + "].", ex);
                }
                if (annotatedMethods==null || annotatedMethods.isEmpty()) { 
                    continue;
                }
    
                for (Map.Entry<Method, XxlJob> methodXxlJobEntry : annotatedMethods.entrySet()) { 
                    Method method = methodXxlJobEntry.getKey();
                    XxlJob xxlJob = methodXxlJobEntry.getValue();
                    if (xxlJob == null) { 
                        continue;
                    }
    
                    String name = xxlJob.value();
                    if (name.trim().length() == 0) { 
                        throw new RuntimeException("xxl-job method-jobhandler name invalid, for[" + bean.getClass() + "#" + method.getName() + "] .");
                    }
                    if (loadJobHandler(name) != null) { 
                        throw new RuntimeException("xxl-job jobhandler[" + name + "] naming conflicts.");
                    }
    
                    // execute method
                    if (!(method.getParameterTypes().length == 1 && method.getParameterTypes()[0].isAssignableFrom(String.class))) { 
                        throw new RuntimeException("xxl-job method-jobhandler param-classtype invalid, for[" + bean.getClass() + "#" + method.getName() + "] , " +
                                "The correct method format like \" public ReturnT<String> execute(String param) \" .");
                    }
                    if (!method.getReturnType().isAssignableFrom(ReturnT.class)) { 
                        throw new RuntimeException("xxl-job method-jobhandler return-classtype invalid, for[" + bean.getClass() + "#" + method.getName() + "] , " +
                                "The correct method format like \" public ReturnT<String> execute(String param) \" .");
                    }
                    method.setAccessible(true);
    
                    // init and destory
                    Method initMethod = null;
                    Method destroyMethod = null;
    
                    if (xxlJob.init().trim().length() > 0) { 
                        try { 
                            initMethod = bean.getClass().getDeclaredMethod(xxlJob.init());
                            initMethod.setAccessible(true);
                        } catch (NoSuchMethodException e) { 
                            throw new RuntimeException("xxl-job method-jobhandler initMethod invalid, for[" + bean.getClass() + "#" + method.getName() + "] .");
                        }
                    }
                    if (xxlJob.destroy().trim().length() > 0) { 
                        try { 
                            destroyMethod = bean.getClass().getDeclaredMethod(xxlJob.destroy());
                            destroyMethod.setAccessible(true);
                        } catch (NoSuchMethodException e) { 
                            throw new RuntimeException("xxl-job method-jobhandler destroyMethod invalid, for[" + bean.getClass() + "#" + method.getName() + "] .");
                        }
                    }
    
                    // registry jobhandler
                    registJobHandler(name, new MethodJobHandler(bean, method, initMethod, destroyMethod));
                }
            }
    
        }
    
        // ---------------------- applicationContext ----------------------
        private static ApplicationContext applicationContext;
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { 
            this.applicationContext = applicationContext;
        }
    
        public static ApplicationContext getApplicationContext() { 
            return applicationContext;
        }
    
    }