• 技术文章 >Java >Java基础

    超详细的JVM反射原理技术点总结哦~

    coldplay.xixicoldplay.xixi2020-10-10 17:20:14转载97

    java基础栏目今天介绍超详细的JVM反射原理技术点总结哦。

    反射定义

    1,JAVA反射机制是在运行状态中

    对于任意一个类,都能够知道这个类的所有属性和方法;

    对于任意一个对象,都能够调用它的任意一个方法和属性;

    这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

    反射提供的功能:

    (如果属性是private,正常情况下是不允许外界操作属性值,这里可以用Field类的setAccessible(true)方法,暂时打开操作的权限)

    反射的使用场景

    反射源码解析

    举例API :

    Class.forName("com.my.reflectTest").newInstance()复制代码

    1. 反射获取类实例 Class.forName("xxx");

      首先调用了 java.lang.Class 的静态方法,获取类信息!

    注意:forName()反射获取类信息,并没有将实现留给了java,而是交给了jvm去加载!

    主要是先获取 ClassLoader, 然后调用 native 方法,获取信息,加载类则是回调 入参ClassLoader 进类加载!

     @CallerSensitive
        public static Class<?> forName(String className)
                    throws ClassNotFoundException {
            // 先通过反射,获取调用进来的类信息,从而获取当前的 classLoader
            Class<?> caller = Reflection.getCallerClass();
            // 调用native方法进行获取class信息
            return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
        }复制代码

    2. java.lang.ClassLoader-----loadClass()

    // java.lang.ClassLoader
        protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
        {
            // 先获取锁
            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;
            }
        }
        
        protected Object getClassLoadingLock(String className) {
            Object lock = this;
            if (parallelLockMap != null) {
                // 使用 ConcurrentHashMap来保存锁
                Object newLock = new Object();
                lock = parallelLockMap.putIfAbsent(className, newLock);
                if (lock == null) {
                    lock = newLock;
                }
            }
            return lock;
        }
        
        protected final Class<?> findLoadedClass(String name) {
            if (!checkName(name))
                return null;
            return findLoadedClass0(name);
        }复制代码

    3. newInstance()

    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) {
                    // 不允许调用 Class 的 newInstance() 方法
                    throw new IllegalAccessException(
                        "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;
            }
        }复制代码

    4. getConstructor0() 为获取匹配的构造方器;分三步:

      1. 先获取所有的constructors, 然后通过进行参数类型比较;   2. 找到匹配后,通过 ReflectionFactory copy一份constructor返回;   3. 否则抛出 NoSuchMethodException;

    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));
        }复制代码

    5. privateGetDeclaredConstructors(), 获取所有的构造器主要步骤;

      1. 先尝试从缓存中获取;   2. 如果缓存没有,则从jvm中重新获取,并存入缓存,缓存使用软引用进行保存,保证内存可用;

    // 获取当前类所有的构造方法,通过jvm或者缓存
        // Returns an array of "root" constructors. These Constructor
        // objects must NOT be propagated to the outside world, but must
        // instead be copied via ReflectionFactory.copyConstructor.
        private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) {
            checkInitted();
            Constructor<T>[] res;
            // 调用 reflectionData(), 获取保存的信息,使用软引用保存,从而使内存不够可以回收
            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 {
                // 使用native方法从jvm获取构造器
                res = getDeclaredConstructors0(publicOnly);
            }
            if (rd != null) {
                // 最后,将从jvm中读取的内容,存入缓存
                if (publicOnly) {
                    rd.publicConstructors = res;
                } else {
                    rd.declaredConstructors = res;
                }
            }
            return res;
        }
        
        // Lazily create and cache ReflectionData
        private ReflectionData<T> reflectionData() {
            SoftReference<ReflectionData<T>> reflectionData = this.reflectionData;
            int classRedefinedCount = this.classRedefinedCount;
            ReflectionData<T> rd;
            if (useCaches &&
                reflectionData != null &&
                (rd = reflectionData.get()) != null &&
                rd.redefinedCount == classRedefinedCount) {
                return rd;
            }
            // else no SoftReference or cleared SoftReference or stale ReflectionData
            // -> create and replace new instance
            return newReflectionData(reflectionData, classRedefinedCount);
        }
        
        // 新创建缓存,保存反射信息
        private ReflectionData<T> newReflectionData(SoftReference<ReflectionData<T>> oldReflectionData,
                                                    int classRedefinedCount) {
            if (!useCaches) return null;
     
            // 使用cas保证更新的线程安全性,所以反射是保证线程安全的
            while (true) {
                ReflectionData<T> rd = new ReflectionData<>(classRedefinedCount);
                // try to CAS it...
                if (Atomic.casReflectionData(this, oldReflectionData, new SoftReference<>(rd))) {
                    return rd;
                }
                // 先使用CAS更新,如果更新成功,则立即返回,否则测查当前已被其他线程更新的情况,如果和自己想要更新的状态一致,则也算是成功了
                oldReflectionData = this.reflectionData;
                classRedefinedCount = this.classRedefinedCount;
                if (oldReflectionData != null &&
                    (rd = oldReflectionData.get()) != null &&
                    rd.redefinedCount == classRedefinedCount) {
                    return rd;
                }
            }
        }复制代码

    另外,使用 relactionData() 进行缓存保存;ReflectionData 的数据结构如下!

    // reflection data that might get invalidated when JVM TI RedefineClasses() is called
        private static class ReflectionData<T> {
            volatile Field[] declaredFields;
            volatile Field[] publicFields;
            volatile Method[] declaredMethods;
            volatile Method[] publicMethods;
            volatile Constructor<T>[] declaredConstructors;
            volatile Constructor<T>[] publicConstructors;
            // Intermediate results for getFields and getMethods
            volatile Field[] declaredPublicFields;
            volatile Method[] declaredPublicMethods;
            volatile Class<?>[] interfaces;
     
            // Value of classRedefinedCount when we created this ReflectionData instance
            final int redefinedCount;
     
            ReflectionData(int redefinedCount) {
                this.redefinedCount = redefinedCount;
            }
        }复制代码

    6.通过上面,获取到 Constructor 了!接下来就只需调用其相应构造器的 newInstance(),即返回实例了!

    // return tmpConstructor.newInstance((Object[])null); 
        // java.lang.reflect.Constructor
        @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;
        }
        // sun.reflect.DelegatingConstructorAccessorImpl
        public Object newInstance(Object[] args)
          throws InstantiationException,
                 IllegalArgumentException,
                 InvocationTargetException
        {
            return delegate.newInstance(args);
        }
        // sun.reflect.NativeConstructorAccessorImpl
        public Object newInstance(Object[] args)
            throws InstantiationException,
                   IllegalArgumentException,
                   InvocationTargetException
        {
            // We can't inflate a constructor belonging to a vm-anonymous class
            // 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(c.getDeclaringClass())) {
                ConstructorAccessorImpl acc = (ConstructorAccessorImpl)
                    new MethodAccessorGenerator().
                        generateConstructor(c.getDeclaringClass(),
                                            c.getParameterTypes(),
                                            c.getExceptionTypes(),
                                            c.getModifiers());
                parent.setDelegate(acc);
            }
     
            // 调用native方法,进行调用 constructor
            return newInstance0(c, args);
        }复制代码

    返回构造器的实例后,可以根据外部进行进行类型转换,从而使用接口或方法进行调用实例功能了。

    相关免费学习推荐:java基础

    以上就是超详细的JVM反射原理技术点总结哦~的详细内容,更多请关注php中文网其它相关文章!

    本文转载于:juejin,如有侵犯,请联系a@php.cn删除
    专题推荐:JVM反射原理技术
    上一篇:认识Lombok的坑 下一篇:java高并发系统设计之缓存篇
    第13期线上培训班

    相关文章推荐

    • 为什么jvm要性能调优?• JVM的内部结构及运行机制• 什么是JVM?它在什么位置?• jvm类加载的过程是什么

    全部评论我要评论

  • 取消发布评论发送
  • 1/1

    PHP中文网