java.lang.NullPointerException  at ......  at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)  at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62
 
)  at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)  at java.lang.reflect.Method.invoke(Method.java:497)

@CallerSensitivepublic Object invoke(Object obj, Object... args)    throws IllegalAccessException, IllegalArgumentException,       InvocationTargetException{    if (!override) {        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {            Class<?> caller = Reflection.getCallerClass();            checkAccess(caller, clazz, obj, modifiers);        }    }    MethodAccessor ma = methodAccessor;             // read volatile
 
    if (ma == null) {        ma = acquireMethodAccessor();    }    return ma.invoke(obj, args);}

@CallerSensitive    public static native Class<?> getCallerClass();

volatile Object securityCheckCache;    void checkAccess(Class<?> caller, Class<?> clazz, Object obj, int modifiers)        throws IllegalAccessException    {        if (caller == clazz) {  // 快速校驗            return;             // 許可權通過校驗        }        Object cache = securityCheckCache;  // read volatile        Class<?> targetClass = clazz;        if (obj != null            && Modifier.isProtected(modifiers)            && ((targetClass = obj.getClass()) != clazz)) {            // Must match a 2-list of { caller, targetClass }.            if (cache instanceof Class[]) {                Class<?>[] cache2 = (Class<?>[]) cache;                if (cache2[1] == targetClass &&                    cache2[0] == caller) {                    return;     // ACCESS IS OK                }                // (Test cache[1] first since range check for [1]                // subsumes range check for [0].)            }        } else if (cache == caller) {            // Non-protected case (or obj.class == this.clazz).            return;             // ACCESS IS OK        }        // If no return, fall through to the slow path.        slowCheckMemberAccess(caller, clazz, obj, modifiers, targetClass);    }

// Keep all this slow stuff out of line:void slowCheckMemberAccess(Class<?> caller, Class<?> clazz, Object obj, int modifiers,                           Class<?> targetClass)    throws IllegalAccessException{    Reflection.ensureMemberAccess(caller, clazz, obj, modifiers);    // Success: Update the cache.    Object cache = ((targetClass == clazz)                    ? caller                    : new Class<?>[] { caller, targetClass });    // Note:  The two cache elements are not volatile,    // but they are effectively final.  The Java memory model    // guarantees that the initializing stores for the cache    // elements will occur before the volatile write.    securityCheckCache = cache;         // write volatile}

private volatile MethodAccessor methodAccessor;// For sharing of MethodAccessors. This branching structure is// currently only two levels deep (i.e., one root Method and// potentially many Method objects pointing to it.)//// If this branching structure would ever contain cycles, deadlocks can// occur in annotation code.private Method  root;

/** This interface provides the declaration for    java.lang.reflect.Method.invoke(). Each Method object is    configured with a (possibly dynamically-generated) class which    implements this interface.*/  public interface MethodAccessor {    /** Matches specification in {@link java.lang.reflect.Method} */    public Object invoke(Object obj, Object[] args)        throws IllegalArgumentException, InvocationTargetException;}

// NOTE that there is no synchronization used here. It is correct// (though not efficient) to generate more than one MethodAccessor// for a given Method. However, avoiding synchronization will// probably make the implementation more scalable.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;}

// Reflection factory used by subclasses for creating field,// method, and constructor accessors. Note that this is called// very early in the bootstrapping process.static final ReflectionFactory reflectionFactory =    AccessController.doPrivileged(        new sun.reflect.ReflectionFactory.GetReflectionFactoryAction());

public class ReflectionFactory {    private static boolean initted = false;    private static Permission reflectionFactoryAccessPerm        = new RuntimePermission("reflectionFactoryAccess");    private static ReflectionFactory soleInstance = new ReflectionFactory();    // Provides access to package-private mechanisms in java.lang.reflect    private static volatile LangReflectAccess langReflectAccess;    // 這裡設計得非常巧妙    // "Inflation" mechanism. Loading bytecodes to implement    // Method.invoke() and Constructor.newInstance() currently costs    // 3-4x more than an invocation via native code for the first    // invocation (though subsequent invocations have been benchmarked    // to be over 20x faster). Unfortunately this cost increases    // startup time for certain applications that use reflection    // intensively (but only once per class) to bootstrap themselves.    // To avoid this penalty we reuse the existing JVM entry points    // for the first few invocations of Methods and Constructors and    // then switch to the bytecode-based implementations.    //    // Package-private to be accessible to NativeMethodAccessorImpl    // and NativeConstructorAccessorImpl    private static boolean noInflation        = false;    private static int     inflationThreshold = 15;    //......    //這是生成MethodAccessor的方法    public MethodAccessor newMethodAccessor(Method method) {        checkInitted();        if (noInflation && !ReflectUtil.isVMAnonymousClass(method.getDeclaringClass())) {            return new MethodAccessorGenerator().                generateMethod(method.getDeclaringClass(),                               method.getName(),                               method.getParameterTypes(),                               method.getReturnType(),                               method.getExceptionTypes(),                               method.getModifiers());        } else {            NativeMethodAccessorImpl acc =                new NativeMethodAccessorImpl(method);            DelegatingMethodAccessorImpl res =                new DelegatingMethodAccessorImpl(acc);            acc.setParent(res);            return res;        }    }    //......    /** We have to defer full initialization of this class until after    the static initializer is run since java.lang.reflect.Method's    static initializer (more properly, that for    java.lang.reflect.AccessibleObject) causes this class's to be    run, before the system properties are set up. */    private static void checkInitted() {        if (initted) return;        AccessController.doPrivileged(            new PrivilegedAction<Void>() {                public Void run() {                    // Tests to ensure the system properties table is fully                    // initialized. This is needed because reflection code is                    // called very early in the initialization process (before                    // command-line arguments have been parsed and therefore                    // these user-settable properties installed.) We assume that                    // if System.out is non-null then the System class has been                    // fully initialized and that the bulk of the startup code                    // has been run.                    if (System.out == null) {                        // java.lang.System not yet fully initialized                        return null;                    }                    String val = System.getProperty("sun.reflect.noInflation");                    if (val != null && val.equals("true")) {                        noInflation = true;                    }                    val = System.getProperty("sun.reflect.inflationThreshold");                    if (val != null) {                        try {                            inflationThreshold = Integer.parseInt(val);                        } catch (NumberFormatException e) {                            throw new RuntimeException("Unable to parse property sun.reflect.inflationThreshold", e);                        }                    }                    initted = true;                    return null;                }            });    }}

/** Delegates its invocation to another MethodAccessorImpl and can    change its delegate at run time. */class DelegatingMethodAccessorImpl extends MethodAccessorImpl {    private MethodAccessorImpl delegate;    DelegatingMethodAccessorImpl(MethodAccessorImpl delegate) {        setDelegate(delegate);    }    public Object invoke(Object obj, Object[] args)        throws IllegalArgumentException, InvocationTargetException    {        return delegate.invoke(obj, args);    }    void setDelegate(MethodAccessorImpl delegate) {        this.delegate = delegate;    }}

/** Used only for the first few invocations of a Method; afterward,    switches to bytecode-based implementation */class NativeMethodAccessorImpl extends MethodAccessorImpl {    private Method method;    private DelegatingMethodAccessorImpl parent;    private int numInvocations;    NativeMethodAccessorImpl(Method method) {        this.method = method;    }    public Object invoke(Object obj, Object[] args)        throws IllegalArgumentException, InvocationTargetException    {        // We can't inflate methods belonging to vm-anonymous classes because        // that kind of class can't be referred to by name, hence can't be        // found from the generated bytecode.        if (++numInvocations > ReflectionFactory.inflationThreshold()                && !ReflectUtil.isVMAnonymousClass(method.getDeclaringClass())) {            MethodAccessorImpl acc = (MethodAccessorImpl)                new MethodAccessorGenerator().                    generateMethod(method.getDeclaringClass(),                                   method.getName(),                                   method.getParameterTypes(),                                   method.getReturnType(),                                   method.getExceptionTypes(),                                   method.getModifiers());            parent.setDelegate(acc);        }        return invoke0(method, obj, args);    }    void setParent(DelegatingMethodAccessorImpl parent) {        this.parent = parent;    }    private static native Object invoke0(Method m, Object obj, Object[] args);}

/** Generator for sun.reflect.MethodAccessor and    sun.reflect.ConstructorAccessor objects using bytecodes to    implement reflection. A java.lang.reflect.Method or    java.lang.reflect.Constructor object can delegate its invoke or    newInstance method to an accessor using native code or to one    generated by this class. (Methods and Constructors were merged    together in this class to ensure maximum code sharing.) */

/** <P> MagicAccessorImpl (named for parity with FieldAccessorImpl and    others, not because it actually implements an interface) is a    marker class in the hierarchy. All subclasses of this class are    "magically" granted access by the VM to otherwise inaccessible    fields and methods of other classes. It is used to hold the code    for dynamically-generated FieldAccessorImpl and MethodAccessorImpl    subclasses. (Use of the word "unsafe" was avoided in this class's    name to avoid confusion with {@link sun.misc.Unsafe}.) </P>    <P> The bug fix for 4486457 also necessitated disabling    verification for this class and all subclasses, as opposed to just    SerializationConstructorAccessorImpl and subclasses, to avoid    having to indicate to the VM which of these dynamically-generated    stub classes were known to be able to pass the verifier. </P>    <P> Do not change the name of this class without also changing the    VM's code. </P> */class MagicAccessorImpl {}

/** * A method annotated @CallerSensitive is sensitive to its calling class, * via {@link sun.reflect.Reflection#getCallerClass Reflection.getCallerClass}, * or via some equivalent. * * @author John R. Rose */@Retention(RetentionPolicy.RUNTIME)@Target({METHOD})public @interface CallerSensitive {}