Java反射-你不得不知道的那点事

迷南。 2021-07-24 22:09 619阅读 0赞

# Java反射 #

## 1、动态语言 ##

> **动态语言是指程序在运行时可以改变其结构，新的函数可以引进，已有的函数可以删除等结构上的变化。比如常见的JavaScript就是动态语言，除此之外Ruby、Python也属于动态语言，而c、c++则不属于动态语言。从反射的角度来说Java属于半动态语言。**

## 2、反射机制概念 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5_size_16_color_FFFFFF_t_70_pic_center]

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

## 3、反射的应用场合 ##

> **编译时类型和运行时类型**
> 
> **在Java程序中许多对象在运行时都会出现两种类型：编译时类型和运行时类型。编译时的类型由申明对象时引用的类型来决定，运行时类型由实际赋值给对象的类型决定。如：**

// 其编译类型为person，运行类型为Student
    Person person = new Student();

> **如果程序在编译类型无法获取具体对象，程序在运行时还可能接收到外部传入的对象，该对象的编译时类型为Object,但是程序有需要调用该对象的运行时类型的方法。为了解决这些问题，程序需要运行时发现对象和类的真实信息。然而，如果编译时根本无法预知该对象和类属于那些类，程序只能依靠运行时信息来发现对象和类的真实信息，此时就需要使用到反射了。**

## 4、Java反射API ##

> **反射用来生成JVM中的类、接口或者对象的信息**

*  Class类：java.lang.Class反射的核心类，可以获取类的属性，方法等信息。
 *  Field类：java.lang.reflect.Field，表示类的成员变量，可以用来获取和设置类之中的属性值。
 *  Method类：java.lang.reflect.Method，表示类的方法，可以用来获取类中的方法信息或者执行方法。
 *  Constructor类：java.lang.reflect.Constructor，表示类中的构造方法。

## 5、反射的使用步骤 ##

*  获取想要操作的类的class对象，它是反射的核心，通过class对象我们可以任意调用类的方法。
 *  调用class类中的方法，就是反射的使用阶段
 *  使用反射API来操作这些信息

## 6、获取class对象的4种方法 ##

*  调用某个对象的getClass()方法
    
        Person person = new Student();
        Class clazz = person.getClass();
 *  调用某个类的class属性来获取该类对应的class对象
    
        Class clazz = Student.class;
 *  使用class类中的forName()静态方法（最常用|最安全|性能最高）
    
        Class clazz = Class.forName("类的全路径");
 *  使用类加载器获取
    
        // Xxx为与需要获取类信息的类同级别的类加载器。类加载器的选择，要符合双亲委派机制
        Class<?> clazz = Xxx.class.getClassLoader().loadClass("类的全路径");

> **当我们获得了想要操作的类的Class的对象后，可以通过Class类中的方法获取并查看该类中的方法和属性**

try { 
        // 获取Person的Class对象
        Class<?> clazz = Class.forName("com.liziba.reflect.Person");
        // 获取Person类的所有成员属性信息
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) { 
            System.out.println(field);
        }
        // 获取Person类的所有方法信息
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) { 
            System.out.println(method);
        }
        // 获取Person类的所有构造方法信息
        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors) { 
            System.out.println(constructor);
        }
    } catch (ClassNotFoundException e) { 
        e.printStackTrace();
    }

## 7、创建对象的两种方法 ##

*  Class对象的newInstance()
    
        // 使用Class对象的newInstance()方法来创建该Class对象对应类的实例，但是这种方法要求该Class对象对应的类有默认的空构造器
        Person person = (Person)clazz.newInstance();
        
        // newInstance()方法的本质，仍然是下面的情况，只是传入的参数是(Object[])null
         try { 
             return tmpConstructor.newInstance((Object[])null);
         } catch (InvocationTargetException e) { 
             Unsafe.getUnsafe().throwException(e.getTargetException());
             return null;
         }
 *  调用Constructor的newInstance()
    
        // 先使用Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方发来创建Class对象对应类的实例，通过这种方法可以选定指定构造方法创建实例
        Constructor<?> constructor = clazz.getConstructor(String.class, int.class, String.class, int.class);
                    constructor.newInstance("李子捌", 1, "深圳宝安", 23);

## 8、反射到底慢在哪里 ##

*  寻找类Class字节码的过程
 *  安全机制的权限校验
 *  可能需要调用native方法时调用JNI接口

// 安全机制校验，Field/Method/Constructor
    private void checkMemberAccess(int which, Class<?> caller, boolean checkProxyInterfaces){ 
        final SecurityManager s = System.getSecurityManager();
        if (s != null) { 
            final ClassLoader ccl = ClassLoader.getClassLoader(caller);
            final ClassLoader cl = getClassLoader0();
            if (which != Member.PUBLIC) { 
                if (ccl != cl) { 
                    s.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
                }
            }
            this.checkPackageAccess(ccl, checkProxyInterfaces);
        }
    }

## 9、反射单例模式的漏洞 ##

> **简单单例**

public class SingletonFactory { 
    
        private volatile static SingletonFactory singletonFactory = null;
    
        private SingletonFactory() { 
        }
    
        public static SingletonFactory getInstance() { 
            if(singletonFactory == null) { 
                synchronized (SingletonFactory.class) { 
                    if(singletonFactory == null) { 
                         singletonFactory = new SingletonFactory();
                    }
                }
            }
            return singletonFactory;
        }
    }

> **反射破坏单例**

public class TestReflectBreakSingleInstance { 
    
        public static void main(String[] args) { 
            SingletonFactory instance1 = null;
            SingletonFactory instance2 = null;
            Class<?> clazz = null;
            try { 
                clazz = Class.forName("com.liziba.reflect.SingletonFactory");
                Constructor<?> constructor = clazz.getDeclaredConstructor(null);
                constructor.setAccessible(true);
                // 单例获取对象1
                instance1 = SingletonFactory.getInstance();
                // 反射获取对象2
                instance2 = (SingletonFactory)constructor.newInstance();
            } catch (Exception e) { 
                e.printStackTrace();
            }
            // 输出false
            System.out.println(instance1 == instance2);
        }
    }

> **解决方法**

// 在单例构造方法中判断实例是否存在
    private SingletonFactory() { 
        if(SingletonFactory.singletonFactory != null) { 
            throw new RuntimeException("实例存在，无法实例化...");
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5_size_16_color_FFFFFF_t_70_pic_center]: /images/20210724/38f8265aba434902b7ad72e7cff41bbd.png