反射调用重载方法（由入参决定还是获取方法时决定）

古城微笑少年丶 2021-06-22 15:38 802阅读 0赞

#### 反射 ####

反射可以在运行时动态获取类与类成员的定义，以及读取方法。不管类中字段方法如何变动，我们都可以以相同的规则来读取。因此，几乎所有的ORM（对象关系映射）、对象映射、MVC 框架都使用了反射。也是事件委托模式中实现的基础。

#### 当反射遇上重载 ####

定义重载方法，名字都为age，参数一个为Integer，一个为int

public class ReflectionApplication { 
    	private static final Logger LOGGER = LoggerFactory.getLogger(ReflectionApplication.class);
    	public void age(Integer age) { 
    		LOGGER.info("Integer age:{}", age);
    	}
    	public void age(int age) { 
    		LOGGER.info("int age:{}", age);
    	}
    }

通过反射调用两个方法：

@Test
    	public void testReflection() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { 
    		ReflectionApplication reflectionApplication = new ReflectionApplication();
    		// 通过类的反射获取到的方法，不管传的是int还是Integer，执行的都是int参数的方法。
    		ReflectionApplication.class.getDeclaredMethod("age",Integer.class).invoke(reflectionApplication, 15);
    		ReflectionApplication.class.getDeclaredMethod("age",Integer.class).invoke(reflectionApplication, Integer.valueOf(15));
    
    		ReflectionApplication.class.getDeclaredMethod("age",Integer.TYPE).invoke(reflectionApplication, 15);
    		ReflectionApplication.class.getDeclaredMethod("age",Integer.TYPE).invoke(reflectionApplication, Integer.valueOf(15));
    
    	}

执行结果：

[INFO ][2020/09/09 10:03:05][main] - Integer age:15
    [INFO ][2020/09/09 10:03:05][main] - Integer age:15
    [INFO ][2020/09/09 10:03:05][main] - int age:15
    [INFO ][2020/09/09 10:03:05][main] - int age:15

有结果看出，不管最终执行方法的入参是Integer还是int，执行的方法都是一样的。区别在于获取方法的入参。  
如果传的是Integer.TYPE，那么获取到的就是int入参的方法。因为：

public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

而传的如果是Integer.class，获取到的才是Integer入参的方法。

#### 源码 ####

看一下getDeclaredMethod的源码：

@CallerSensitive
        public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
            throws NoSuchMethodException, SecurityException { 
            checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
            // 搜索方法
            Method method = searchMethods(privateGetDeclaredMethods(false), name, parameterTypes);
            if (method == null) { 
                throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
            }
            return method;
        }

private static Method searchMethods(Method[] methods,
                                            String name,
                                            Class<?>[] parameterTypes)
        { 
            Method res = null;
            String internedName = name.intern();
            for (int i = 0; i < methods.length; i++) { 
            	// 对每个方法进行比较
                Method m = methods[i];
                // 方法名相同，方法入参相同 && （还未找到 || 看返回类型，找返回类型一样的）
                // A.class.isAssignableFrom(B.class) 是看A是不是B的子类或子接口
                if (m.getName() == internedName
                    && arrayContentsEq(parameterTypes, m.getParameterTypes())
                    && (res == null
                        || res.getReturnType().isAssignableFrom(m.getReturnType())))
                    res = m;
            }
    
            return (res == null ? res : getReflectionFactory().copyMethod(res));
        }

private static boolean arrayContentsEq(Object[] a1, Object[] a2) { 
            if (a1 == null) { 
                return a2 == null || a2.length == 0;
            }
            if (a2 == null) { 
                return a1.length == 0;
            }
            if (a1.length != a2.length) { 
                return false;
            }
            for (int i = 0; i < a1.length; i++) { 
                if (a1[i] != a2[i]) { 
                    return false;
                }
            }
            return true;
        }