Spring ReflectionUtils

public abstract class ReflectionUtils {

/**
 * Naming prefix for CGLIB-renamed methods.
 *
 * CGLIB 函数前缀
 * @see #isCglibRenamedMethod
 */
private static final String CGLIB_RENAMED_METHOD_PREFIX = "CGLIB$";

private static final Class<?>[] EMPTY_CLASS_ARRAY = new Class<?>[0];

private static final Method[] EMPTY_METHOD_ARRAY = new Method[0];

private static final Field[] EMPTY_FIELD_ARRAY = new Field[0];

private static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];


/**
 * Cache for {@link Class#getDeclaredMethods()} plus equivalent default methods
 * from Java 8 based interfaces, allowing for fast iteration.
 *
 * 类的函数缓存
 *
 * class => method 列表
 */
private static final Map<Class<?>, Method[]> declaredMethodsCache = new ConcurrentReferenceHashMap<>(256);

/**
 * Cache for {@link Class#getDeclaredFields()}, allowing for fast iteration.
 * 类的字段缓存
 * class => field 列表
 */
private static final Map<Class<?>, Field[]> declaredFieldsCache = new ConcurrentReferenceHashMap<>(256);
    
}

/**
 * Pre-built MethodFilter that matches all non-bridge non-synthetic methods
 * which are not declared on {@code java.lang.Object}.
 *
 * method 过滤器
 * @since 3.0.5
 */
public static final MethodFilter USER_DECLARED_METHODS =
      (method -> !method.isBridge() && !method.isSynthetic());

/**
 * Pre-built FieldFilter that matches all non-static, non-final fields.
 *
 * 字段过滤器
 */
public static final FieldFilter COPYABLE_FIELDS =
      (field -> !(Modifier.isStatic(field.getModifiers()) || Modifier.isFinal(field.getModifiers())));

public static void handleReflectionException(Exception ex) {
   if (ex instanceof NoSuchMethodException) {
      throw new IllegalStateException("Method not found: " + ex.getMessage());
   }
   if (ex instanceof IllegalAccessException) {
      throw new IllegalStateException("Could not access method or field: " + ex.getMessage());
   }
   if (ex instanceof InvocationTargetException) {
      handleInvocationTargetException((InvocationTargetException) ex);
   }
   if (ex instanceof RuntimeException) {
      throw (RuntimeException) ex;
   }
   throw new UndeclaredThrowableException(ex);
}

@SuppressWarnings("deprecation")  // on JDK 9
public static void makeAccessible(Constructor<?> ctor) {
   if ((!Modifier.isPublic(ctor.getModifiers()) ||
         !Modifier.isPublic(ctor.getDeclaringClass().getModifiers())) && !ctor.isAccessible()) {
      ctor.setAccessible(true);
   }
}

@Nullable
public static Method findMethod(Class<?> clazz, String name, @Nullable Class<?>... paramTypes) {
   Assert.notNull(clazz, "Class must not be null");
   Assert.notNull(name, "Method name must not be null");
   Class<?> searchType = clazz;
   while (searchType != null) {
      // 找出 searchType 的所有 method
      Method[] methods = (searchType.isInterface() ? searchType.getMethods() :
            getDeclaredMethods(searchType, false));
      for (Method method : methods) {
         // 1. method 名称相同
         // 2. 参数类型相同
         if (name.equals(method.getName()) && (paramTypes == null || hasSameParams(method, paramTypes))) {
            return method;
         }
      }
      // 查询父类 递归
      searchType = searchType.getSuperclass();
   }
   return null;
}

/**
 * 判断 method 的参数类型和 该方法的参数是否相同
 */
private static boolean hasSameParams(Method method, Class<?>[] paramTypes) {
   return (paramTypes.length == method.getParameterCount() &&
         Arrays.equals(paramTypes, method.getParameterTypes()));
}

@Nullable
public static Object invokeMethod(Method method, @Nullable Object target) {
   return invokeMethod(method, target, EMPTY_OBJECT_ARRAY);
}

/**
 * Invoke the specified {@link Method} against the supplied target object with the
 * supplied arguments. The target object can be {@code null} when invoking a
 * static {@link Method}.
 * <p>Thrown exceptions are handled via a call to {@link #handleReflectionException}.
 * @param method the method to invoke
 * @param target the target object to invoke the method on
 * @param args the invocation arguments (may be {@code null})
 * @return the invocation result, if any
 */
@Nullable
public static Object invokeMethod(Method method, @Nullable Object target, @Nullable Object... args) {
   try {
      return method.invoke(target, args);
   }
   catch (Exception ex) {
      handleReflectionException(ex);
   }
   throw new IllegalStateException("Should never get here");
}

public static boolean declaresException(Method method, Class<?> exceptionType) {
   Assert.notNull(method, "Method must not be null");
   // 获取异常说明列表
   Class<?>[] declaredExceptions = method.getExceptionTypes();
   for (Class<?> declaredException : declaredExceptions) {
      if (declaredException.isAssignableFrom(exceptionType)) {
         return true;
      }
   }
   return false;
}

private static Method[] getDeclaredMethods(Class<?> clazz, boolean defensive) {
   Assert.notNull(clazz, "Class must not be null");
   // 从缓存中获取
   Method[] result = declaredMethodsCache.get(clazz);
   if (result == null) {
      try {
         Method[] declaredMethods = clazz.getDeclaredMethods();
         // 查询接口的方法.
         List<Method> defaultMethods = findConcreteMethodsOnInterfaces(clazz);
         if (defaultMethods != null) {
            result = new Method[declaredMethods.length + defaultMethods.size()];
            System.arraycopy(declaredMethods, 0, result, 0, declaredMethods.length);
            int index = declaredMethods.length;
            for (Method defaultMethod : defaultMethods) {
               result[index] = defaultMethod;
               index++;
            }
         }
         else {
            result = declaredMethods;
         }
         declaredMethodsCache.put(clazz, (result.length == 0 ? EMPTY_METHOD_ARRAY : result));
      }
      catch (Throwable ex) {
         throw new IllegalStateException("Failed to introspect Class [" + clazz.getName() +
               "] from ClassLoader [" + clazz.getClassLoader() + "]", ex);
      }
   }
   return (result.length == 0 || !defensive) ? result : result.clone();
}

@Nullable
private static List<Method> findConcreteMethodsOnInterfaces(Class<?> clazz) {
   List<Method> result = null;
   // 接口类
   for (Class<?> ifc : clazz.getInterfaces()) {
      // 接口的函数列表
      for (Method ifcMethod : ifc.getMethods()) {
         // 非 abstract 方法
         if (!Modifier.isAbstract(ifcMethod.getModifiers())) {
            if (result == null) {
               result = new ArrayList<>();
            }
            result.add(ifcMethod);
         }
      }
   }
   return result;
}

	public static Method[] getUniqueDeclaredMethods(Class<?> leafClass, @Nullable MethodFilter mf) {
		final List<Method> methods = new ArrayList<>(32);
		doWithMethods(leafClass, method -> {
			boolean knownSignature = false;
			Method methodBeingOverriddenWithCovariantReturnType = null;
			for (Method existingMethod : methods) {
				if (method.getName().equals(existingMethod.getName()) &&
						method.getParameterCount() == existingMethod.getParameterCount() &&
						Arrays.equals(method.getParameterTypes(), existingMethod.getParameterTypes())) {
					// Is this a covariant return type situation?
					if (existingMethod.getReturnType() != method.getReturnType() &&
							existingMethod.getReturnType().isAssignableFrom(method.getReturnType())) {
						methodBeingOverriddenWithCovariantReturnType = existingMethod;
					}
					else {
						knownSignature = true;
					}
					break;
				}
			}
			if (methodBeingOverriddenWithCovariantReturnType != null) {
				methods.remove(methodBeingOverriddenWithCovariantReturnType);
			}
			if (!knownSignature && !isCglibRenamedMethod(method)) {
				methods.add(method);
			}
		}, mf);
		return methods.toArray(EMPTY_METHOD_ARRAY);
	}

	@Nullable
	public static Field findField(Class<?> clazz, @Nullable String name, @Nullable Class<?> type) {
		Assert.notNull(clazz, "Class must not be null");
		Assert.isTrue(name != null || type != null, "Either name or type of the field must be specified");
		Class<?> searchType = clazz;
		while (Object.class != searchType && searchType != null) {
			Field[] fields = getDeclaredFields(searchType);
			for (Field field : fields) {
				// 属性名称是否相同
				// 属性类型是否相同
				if ((name == null || name.equals(field.getName())) &&
						(type == null || type.equals(field.getType()))) {
					return field;
				}
			}
			searchType = searchType.getSuperclass();
		}
		return null;
	}

</details>