Java反射源码解析

- 日理万妓 2022-12-11 12:24 198阅读 0赞

> Java反射机制带给Java无限的想象空间，那么Java反射的底层是如何实现的？

> https://www.cnblogs.com/yougewe/p/10125073.html

### 1. 先上栗子 ###

public class MyReflect { 
        String message;
    
        public void hello(String msg) { 
            this.message = msg;
            System.out.println("Hello Reflect" + " " + message);
        }
    
        public static void main(String[] args) { 
            try { 
                //方式一：通过calss.forName获取类对象
                MyReflect instance = (MyReflect) Class.forName("com.wf.MyReflect").newInstance();
                instance.hello("你好,反射");
    
            } catch (InstantiationException e) { 
                e.printStackTrace();
            } catch (IllegalAccessException e) { 
                e.printStackTrace();
            } catch (ClassNotFoundException e) { 
                e.printStackTrace();
            }
        }
    }

运行得到结果为  
![在这里插入图片描述][20200930210648540.png_pic_center]

### 2. 源码执行流程 ###

关键代码是Class.forName（）

@CallerSensitive
        public static Class<?> forName(String className)
                    throws ClassNotFoundException { 
            Class<?> caller = Reflection.getCallerClass();
            return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
        }

其中Reflection.getCallerClass()是静态方法，获取类信息

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

/** Called after security check for system loader access checks have been made. */
        private static native Class<?> forName0(String name, boolean initialize,
                                                ClassLoader loader,
                                                Class<?> caller)
            throws ClassNotFoundException;

调用了获取类加载器方法

// Returns the class's class loader, or null if none.
        static ClassLoader getClassLoader(Class<?> caller) { 
            // This can be null if the VM is requesting it
            if (caller == null) { 
                return null;
            }
            // Circumvent security check since this is package-private
            return caller.getClassLoader0();
        }

返回一个类加载器

// Package-private to allow ClassLoader access
        ClassLoader getClassLoader0() {  return classLoader; }

// Initialized in JVM not by private constructor
        // This field is filtered from reflection access, i.e. getDeclaredField
        // will throw NoSuchFieldException
        private final ClassLoader classLoader;

调用类加载器的loadClass方法

public Class<?> loadClass(String name) throws ClassNotFoundException { 
            return loadClass(name, false);
        }

protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
        { 
        	//类加载器是线程安全的，就是因为这里加了synchronized关键字进行代码块同步加锁
            synchronized (getClassLoadingLock(name)) { 
                // First, check if the class has already been loaded
                Class<?> c = findLoadedClass(name);
                if (c == null) { 
                    long t0 = System.nanoTime();
                    try { 
                        if (parent != null) { 
                        	 // 双亲委托加载
                            c = parent.loadClass(name, false);
                        } else { 
                            c = findBootstrapClassOrNull(name);
                        }
                    } catch (ClassNotFoundException e) { 
                        // ClassNotFoundException thrown if class not found
                        // from the non-null parent class loader
                    }
    				// 父类没有加载到时，再自己加载
                    if (c == null) { 
                        // If still not found, then invoke findClass in order
                        // to find the class.
                        long t1 = System.nanoTime();
                        c = findClass(name);
    
                        // this is the defining class loader; record the stats
                        sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                        sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                        sun.misc.PerfCounter.getFindClasses().increment();
                    }
                }
                if (resolve) { 
                    resolveClass(c);
                }
                return c;
            }
        }

可以看到上述类加载方法使用了synchronized关键字进行代码块同步，其中获取锁的方法是getClassLoadingLock(name)，

private final ConcurrentHashMap<String, Object> parallelLockMap;

protected Object getClassLoadingLock(String className) { 
            Object lock = this;
            // 使用 ConcurrentHashMap来保存锁
            if (parallelLockMap != null) { 
                Object newLock = new Object();
                lock = parallelLockMap.putIfAbsent(className, newLock);
                if (lock == null) { 
                    lock = newLock;
                }
            }
            return lock;
        }

至此，类加载完成！！

### 3. 从以上加载得到的类对象获取对象实例 ###

即newInstance() 方法

//Class.newInstance
        @CallerSensitive
        public T newInstance()
            throws InstantiationException, IllegalAccessException
        { 
            if (System.getSecurityManager() != null) { 
                checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
            }
    
            // NOTE: the following code may not be strictly correct under
            // the current Java memory model.
    
            // Constructor lookup
             // newInstance() 其实相当于调用类的无参构造函数，所以，首先要找到其无参构造器
            if (cachedConstructor == null) { 
                if (this == Class.class) { 
                    throw new IllegalAccessException(
                    	// 不允许调用 Class 的 newInstance() 方法
                        "Can not call newInstance() on the Class for java.lang.Class"
                    );
                }
                try { 
                    Class<?>[] empty = { };
                    // 获取无参构造器
                    final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
                    // Disable accessibility checks on the constructor
                    // since we have to do the security check here anyway
                    // (the stack depth is wrong for the Constructor's
                    // security check to work)
                    java.security.AccessController.doPrivileged(
                        new java.security.PrivilegedAction<Void>() { 
                            public Void run() { 
                                    c.setAccessible(true);
                                    return null;
                                }
                            });
                    cachedConstructor = c;
                } catch (NoSuchMethodException e) { 
                    throw (InstantiationException)
                        new InstantiationException(getName()).initCause(e);
                }
            }
            Constructor<T> tmpConstructor = cachedConstructor;
            // Security check (same as in java.lang.reflect.Constructor)
            int modifiers = tmpConstructor.getModifiers();
            if (!Reflection.quickCheckMemberAccess(this, modifiers)) { 
                Class<?> caller = Reflection.getCallerClass();
                if (newInstanceCallerCache != caller) { 
                    Reflection.ensureMemberAccess(caller, this, null, modifiers);
                    newInstanceCallerCache = caller;
                }
            }
            // Run constructor
            try { 
            	// 调用无参构造器，构建类实例
                return tmpConstructor.newInstance((Object[])null);
            } catch (InvocationTargetException e) { 
                Unsafe.getUnsafe().throwException(e.getTargetException());
                // Not reached
                return null;
            }
        }

总结以下，拢共做了三件事：

*  权限检测，如果不通过直接抛出异常；
 *  查找无参构造器，并将其缓存起来；
 *  调用具体方法的无参构造方法，生成实例并返回；

获取构造器的方法为

private Constructor<T> getConstructor0(Class<?>[] parameterTypes,
                                            int which) throws NoSuchMethodException
        { 
        	// 获取所有构造器
            Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC));
            for (Constructor<T> constructor : constructors) { 
                if (arrayContentsEq(parameterTypes,
                                    constructor.getParameterTypes())) { 
                    return getReflectionFactory().copyConstructor(constructor);
                }
            }
            throw new NoSuchMethodException(getName() + ".<init>" + argumentTypesToString(parameterTypes));
        }

getConstructor0() 为获取匹配的构造方器；分三步：  
　　1. 先获取所有的constructors, 然后通过进行参数类型比较；  
　　2. 找到匹配后，通过 ReflectionFactory copy一份constructor返回；  
　　3. 否则抛出 NoSuchMethodException;

// 获取当前类所有的构造方法，通过jvm或者缓存
        private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) { 
            checkInitted();
            Constructor<T>[] res;
            ReflectionData<T> rd = reflectionData();
            if (rd != null) { 
                res = publicOnly ? rd.publicConstructors : rd.declaredConstructors;
                if (res != null) return res;
            }
            // No cached value available; request value from VM
            if (isInterface()) { 
                @SuppressWarnings("unchecked")
                Constructor<T>[] temporaryRes = (Constructor<T>[]) new Constructor<?>[0];
                res = temporaryRes;
            } else { 
                res = getDeclaredConstructors0(publicOnly);
            }
            if (rd != null) { 
                if (publicOnly) { 
                    rd.publicConstructors = res;
                } else { 
                    rd.declaredConstructors = res;
                }
            }
            return res;
        }

privateGetDeclaredConstructors(), 获取所有的构造器主要步骤；  
　　1. 先尝试从缓存中获取；  
　　2. 如果缓存没有，则从jvm中重新获取，并存入缓存，缓存使用软引用进行保存，保证内存可用；  
通过上面，获取到 Constructor 了！  
接下来调用newInstance()方法获取类实例

@CallerSensitive
        public T newInstance(Object ... initargs)
            throws InstantiationException, IllegalAccessException,
                   IllegalArgumentException, InvocationTargetException
        { 
            if (!override) { 
                if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) { 
                    Class<?> caller = Reflection.getCallerClass();
                    checkAccess(caller, clazz, null, modifiers);
                }
            }
            if ((clazz.getModifiers() & Modifier.ENUM) != 0)
                throw new IllegalArgumentException("Cannot reflectively create enum objects");
            ConstructorAccessor ca = constructorAccessor;   // read volatile
            if (ca == null) { 
                ca = acquireConstructorAccessor();
            }
            @SuppressWarnings("unchecked")
            T inst = (T) ca.newInstance(initargs);
            return inst;
        }

进而调用静态方法获取实例

private static native Object newInstance0(Constructor<?> var0, Object[] var1) throws InstantiationException, IllegalArgumentException, InvocationTargetException;

至此，获取到了类实例

### 4.全部反射获取类型实例过程完成，可以像使用new出来的对象一样使用 ###

[20200930210648540.png_pic_center]: /images/20221123/77b3e1af3d7841e7bc54c75e86245935.png