Java基础-反射的理解与优缺点

什么是反射

反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 Java 语言的反射机制

反射的使用

反射的创建：三种创建方式

1. 通过类名创建。 类名.class
2. 通过对象名 使用getClass（）方法创建。 对象.getClass()
3. 通过使用forName方法创建。 Class.forName(“类全名”)

反射对类中各个属性方法的使用

成员变量Field（Field[ ]）、成员方法Method(Method[ ])、构造方法Construction(Construction[ ])

反射获取构造方法（构造器）

1. Constructor<?>[ ] getConstructors()：返回public修饰的所有构造方法对象的数组（也会获取父类的）
2. Constructor getConstructor(Class<?>… parameterTypes)：返回public修饰的单个构造方法对象
   Declared（声明，即为自己定义的）parameter（变量）
3. Constructor<?>[ ] getDeclaredConstructors()：返回任意权限的所有构造方法对象的数组
4. Constructor getDeclaredConstructor(Class<?>… parameterTypes)：返回任意权限的单个构造方法对象

反射获取成员方法

1. Method[ ] getMethods()：返回所有public的成员方法对象的数组，包括继承的。
2. Method getMethod(String name, Class<?>… parameterTypes) ：返回单个public的成员方法对象。
   参数name：表示方法名 ；参数parameterTypes：表示方法的形参类型
3. Method[ ] getDeclaredMethods()：返回所有成员方法对象的数组，不包括继承的
4. Method getDeclaredMethod(String name, Class<?>… parameterTypes)：返回单个成员方法对象。

反射的原理

public class RefTest {
    public static void main(String[] args) throws Exception {
        Class<?> aClass = Class.forName("Test.Person");
        Person o = (Person)aClass.newInstance();
        o.say();
    }
}

forName

首先调用了 java.lang.Class 的静态方法，获取类信息！
forName()反射获取类信息，并没有将实现留给了java,而是交给了jvm去加载！
主要是先获取 ClassLoader, 然后调用 native 方法，获取信息，加载类则是回调 java.lang.ClassLoader.
最后，jvm又会回调 ClassLoader 进类加载！

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

上面的Class对象是在加载类时由JVM构造的，JVM为每个类管理一个独一无二的Class对象，这份Class对象里维护着该类的所有Method，Field，Constructor的cache，这份cache也可以被称作根对象。

如果调用newInstance()就直接生生成对象,接下来就调用新对象的方法

newInstance

生成具体的对象

1. 权限检查，不通过就抛出异常
2. 查找无参构造器，并缓存下来
3. 调用具体方法的无参构造方法生成实例返回

 public T newInstance()
        throws InstantiationException, IllegalAccessException
    {
        if (System.getSecurityManager() != null) {
            checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
        }

        if (cachedConstructor == null) {
            if (this == Class.class) {
                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);

                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;
        
        int modifiers = tmpConstructor.getModifiers();
        if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            if (newInstanceCallerCache != caller) {
                Reflection.ensureMemberAccess(caller, this, null, modifiers);
                newInstanceCallerCache = caller;
            }
        }
     
        try {
            return tmpConstructor.newInstance((Object[])null);
        } catch (InvocationTargetException e) {
            Unsafe.getUnsafe().throwException(e.getTargetException());
            // Not reached
            return null;
        }
    }

反射的优缺点

优点

反射提高了程序的灵活性和扩展性，降低耦合性，提高自适应能力。它允许程序创和控制任何类的对象，无需提前硬编码目标类

对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法

缺点

性能问题

使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此Java反射机制主要应用在对灵活性和扩展性要求很高的系统框架上,普通程序不建议使用

代码可读性下降

程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂

安全问题

可以越过泛型检查，同时还可以获得私有变量