if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass(1);


            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    MethodAccessor ma = methodAccessor;             // read volatile
if (ma == null) {
    ma = acquireMethodAccessor();
}
return ma.invoke(obj, args);

invoke()方法中主要分为两部分：访问控制检查和调用MethodAccessor.invoke()实现方法执行。


首先看一下访问控制检查这一块的逻辑。第一眼看到这里的逻辑的时候，很容易搞不清楚是干嘛的。通俗来讲就是通过方法的修饰符(public/protected/private/package)，来判断方法的调用者是否可以访问该方法。这是java的基础内容，不过用代码写出来，一下子不容易想到。访问控制检查分为3步：


1.  检查override，如果override为true，跳过检查；否则继续；
2.  快速检查，判断该方法的修饰符modifiers是否为public，如果是跳过检查；否则继续；
3.  详细检查，通过方法的(protected/private/package)修饰符或方法的声明类（例如子类可以访问父类的protected方法）与调用者caller之间的关系，判断caller是否有权限访问该方法。


override属性是Method的父类AccessibleObject中声明的变量，使得程序可以控制是否跳过访问权限的检查。另外，Method的实例对象中，override属性的初始值设置为false。

    SecurityManager sm = System.getSecurityManager();
    if (sm != null) sm.checkPermission(ACCESS_PERMISSION);
    setAccessible0(this, flag);
}


private static void setAccessible0(AccessibleObject obj, boolean flag)
    throws SecurityException
{
    if (obj instanceof Constructor && flag == true) {
        Constructor<?> c = (Constructor<?>)obj;
        if (c.getDeclaringClass() == Class.class) {
            throw new SecurityException("Can not make a java.lang.Class" +
                                    " constructor accessible");
    }
}
obj.override = flag;

多说一句，Field同样继承了AccessibleObject，且Field的override也是初始化为false的，也就是说并没有按照变量的修饰符去初始化不同的值。但是我们在调用Field.set(Object obj, Object value)时，如果该Field是private修饰的，会因没有访问权限而抛出异常，因此必须调用setAccessible(true)。此处非常容易理解为因为变量是public的，所以override就被初始化为true。


invoke()方法中，访问控制检查之后，就是通过MethodAccessor.invoke()调用方法。再来看一下代码：

ma = acquireMethodAccessor();

这里的逻辑很简单，首先将变量methodAccessor赋值给ma，在方法栈中保存一个可以直接引用的本地变量，如果methodAccessor不存在，调用acquireMethodAccessor()方法创建一个。

private Method root;


private MethodAccessor acquireMethodAccessor() {
    // First check to see if one has been created yet, and take it
    // if so
    MethodAccessor tmp = null;
    if (root != null) tmp = root.getMethodAccessor();
    if (tmp != null) {
        methodAccessor = tmp;
    } else {
        // Otherwise fabricate one and propagate it up to the root
        tmp = reflectionFactory.newMethodAccessor(this);
        setMethodAccessor(tmp);
    }


    return tmp;
}


void setMethodAccessor(MethodAccessor accessor) {
    methodAccessor = accessor;
    // Propagate up
    if (root != null) {
        root.setMethodAccessor(accessor);
    }
}


Method copy() {
    Method res = new Method(clazz, name, parameterTypes, returnType,
                            exceptionTypes, modifiers, slot, signature,
                            annotations, parameterAnnotations, annotationDefault);
    res.root = this;
    res.methodAccessor = methodAccessor;
    return res;
}

综合acquireMethodAccessor(),setMethodAccessor()以及copy()这三个方法，可以看到一个Method实例对象维护了一个root引用。当调用Method.copy()进行方法拷贝时，root指向了被拷贝的对象。那么当一个Method被多次拷贝后，调用一次setMethodAccessor()方法，就会将root引用所指向的Method的methodAccessor变量同样赋值。例如：D -> C -> B -> A，其中X-> Y表示X = Y.copy()， 当C对象调用setMethodAccessor()时，B和A都会传播赋值methodAccessor， 而D的methodAccessor还是null。紧接着，当D需要获取methodAccessor而调用acquireMethodAccessor()时，D获取root的methodAccessor， 那么D将和ABC持有相同的methodAccessor。


虽然Method中，通过维护root引用意图使相同的方法始终保持只有一个methodAccessor实例，但是上述方法仍然无法保证相同的方法只有一个methodAccessor实例。例如通过copy()使ABCD保持关系：D -> C -> B -> A，?当B对象调用setMethodAccessor()时，B和A都会赋值methodAccessor， 而C、D的methodAccessor还是null。这时D调用acquireMethodAccessor()时，D获取root也就是C的methodAccessor，发现为空，然后就新创建了一个。从而出现了相同的方法中出现了两个methodAccessor实例对象的现象。


在Class.getMethod()、Class.getDeclaredMethod()以及Class.getDeclaredMethod(String name, Class<?>... parameterTypes)方法中最终都会调用copy()方法来保障Method使用的安全性。?在比较极端加巧合的情况下，可能会引起类膨胀的问题，这就是接下来要讲到的MethodAccessor的实现机制。


![](https://static001.geekbang.org/infoq/76/7661cd345bac66cb950448bb7b202baf.png)


在前面代码中，MethodAccessor的创建是通过反射工厂ReflectionFactory的newMethodAccessor(Method)方法来创建的。

    checkInitted();