深入理解Java反射机制

反射即反向探知，有点像考古学家根据发掘的物品来探知以前的事情

指在Java程序运行状态中，

1. 对于给定的一个类(Class)对象，可以获得这个类(Class)对象的所有属性和方法；
2. 对于给定的一个对象(new XXXClassName)，都能够调用它的任意一个属性和方法.

这种动态获取类的内容以及动态调用对象的方法和获取属性的机制.就叫做JAVA的反射机制
如下案例

package com.example.demo;

public class Person {
    public void say(){
        System.out.println("Person中的say方法");
    };
}

public static void main(String[] args) throws Exception {
        // 获取类对象
        Class clazz = Person.class;
        // 创建对象
        Person person = (Person) clazz.newInstance();
        // 获取类的相关结构
        System.out.println(clazz.getName()); // 类名
        System.out.println(clazz.getPackage()); // 包名
        System.out.println(clazz.getClassLoader()); // 获取类的classLoader
        System.out.println(clazz.getSuperclass()); // 获取父类

        // 获取方法
        Method method = clazz.getDeclaredMethod("say");
        // 等价于 Person p = new Person();
        // p.say();
        method.invoke(person);

    }

通过反射对象得到构造方法成员变量成员方法

优点
增加程序的灵活性，避免将固有的逻辑程序写死到代码里
代码简洁,可读性强，可提高代码的复用率
缺点
相较直接调用在量大的情景下反射性能下降
内部暴露和安全隐患

public interface Office {

    void toPDF();
}

public class Word implements Office {
    @Override
    public void toPDF() {
        System.out.println("Word 2 PDF ");
    }
}

public class Excel implements Office {
    @Override
    public void toPDF() {
        System.out.println(" Excel 2 PDF");
    }
}

package com.example.demo.fashe1;

public class Main {
    public static void main(String[] args) {
        String key = "word";
    }

    
    public static Office getInstanceByKey(String key){
        if("word".equals(key)){
            return new Word();
        }

        if("excel".equals(key)){
            return new Excel();
        }
        return null;
    }

    
    public static Office getInstanceReflectByKey(String key){
        String packageName = "com.example.demo.fashe1";
        Office office = null;
        try {
            Class clazz = Class.forName(packageName+"."+key);
            office = (Office)clazz.newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        return office;
    }
}

寻找类Class字节码的过程
安全管理机制的权限验证等等
若需要调用native方法调用时JNI接口的使用

public static void main(String[] args) {
    String key = "word";
    //getInstanceByKey("word");
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 1000000 ; i++) {
        getInstanceByKey(key);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("总计花费时间:" + (endTime - startTime));
}

通过new的方式创建1000000个对象只需要花费9毫秒

如果通过反射的方式的话

public static void main(String[] args) {
    String key = "Word";
    //getInstanceByKey("word");
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 1000000 ; i++) {
        //getInstanceByKey(key);
        getInstanceReflectByKey(key);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("总计花费时间:" + (endTime - startTime));
}

大家能发现差距还是非常大的~

源码层面

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

private static native Class forName0(String name, boolean initialize,
                                        ClassLoader loader,
                                        Class caller)
    throws ClassNotFoundException;

在编写每个类实例中,都会定义这个类的包名,类名,访问域,特征符,构造器,字段,函数,父类,接口等等内容.

这些内容在我们的Class类中都提供了对应的获取方法进行获取.

//clazz 代表对应的Class类实例

Class clazz = Person.class;
Class clazz2 = new Person().getClass();
Class clazz3 = Class.forName("com.example.demo.fashe.Person");
Class clazz4 = Demo02.class.getClassLoader().loadClass("com.example.demo.fashe.Person");

// 获取类的相关结构
int modifier = clazz.getModifiers(); // 获取类修饰符
Package aPackage = clazz.getPackage(); // 获取类包名
String fullClassName = clazz.getName(); // 获取类的全路径名称
String simpleName = clazz.getSimpleName(); // 获取类的简单名称
ClassLoader classLoader = clazz.getClassLoader(); // 获取类加载器
Class[] interfaces = clazz.getInterfaces(); // 获取类实现的接口列表
Class superclass = clazz.getSuperclass(); // 获取类的父类
Annotation[] annotations = clazz.getAnnotations(); // 获取类的注解信息

Person person = (Person) clazz.newInstance();
// 获取类中所有的共有字段 包含继承的字段
Field[] fields = clazz.getFields();
// 获取类中定义的字段 内部
Field[] declaredFields = clazz.getDeclaredFields();
// 获取指定名称的类中定义的字段
Field nameField = clazz.getDeclaredField("name");
// 获取字段的修饰符
int modifiers = nameField.getModifiers();
// 指定字段强制访问
nameField.setAccessible(true);
// 修改字段的值
nameField.set(person,"平安");
// 静态字段赋值
nameField.set(null,"静态字段赋值");

// 获取类中的所有的共有的方法 继承
Method[] methods = clazz.getMethods();
// 获取类中的定义的方法
Method[] declaredMethods = clazz.getDeclaredMethods();
// 获取类中指定名称和参数的公有方法
Method say = clazz.getMethod("say", String.class);
// 获取类中定义的指定名称和参数的方法
Method say1 = clazz.getDeclaredMethod("say");
// 获取方法的修饰符
int modifiers1 = say.getModifiers();
// 指定对象进行成员方法的调用
Object 小米666 = say.invoke(person, "小米666");
say.setAccessible(true);// 指定方法的强制执行
// 静态方法调用
say.invoke(null);

Constructor[] cons = clazz.getConstructors();            //获取类中所有的公有构造器
Constructor[] cons1 = clazz.getDeclaredConstructors();       //获取类中所有的构造器
Constructor conNoParam= clazz.getDeclaredConstructor();       //获取类中无参的构造器
Constructor con= clazz.getDeclaredConstructor(String.class,String.class);   //获取类中有参构造
int modifers = con.getModifiers();             //获取构造器的修饰符
conNoParam.newInstance();              //构造器实例对象
con.setAccessible(true);                  //指定方法的强制访问
con.newInstance("abc","bbb");              //有参构造调用
Person.class.newInstance();                //class直接调用默认无参构造

newInstance();方法的本质

定义一个简单的单例模式

public class PersonSingle {

    private static PersonSingle instance;

    private PersonSingle(){

    }

    public static synchronized  PersonSingle getInstance(){
        if(instance == null){
            instance = new PersonSingle();
        }
        return instance;
    }
}

通过反射可以创建多个实例，从而破坏单例的设计

public static void main(String[] args) throws Exception{
    PersonSingle s1 = PersonSingle.getInstance();
    System.out.println(s1);
    Class aClass = s1.getClass();
    Constructor declaredConstructor = aClass.getDeclaredConstructor();
    declaredConstructor.setAccessible(true);
    Thread.sleep(1000);
    // 通过反射 调用私有的构造器来创建对象，从而破坏单例设计
    PersonSingle s2 =  declaredConstructor.newInstance(null);
    System.out.println(s2);
}

那么如何防止这种破坏呢，其实很简单我们只需要在私有构造中加个判断就可以了，如下

private  PersonSingle(){
    if(PersonSingle.instance != null){
        throw new RuntimeException("实例已经创建，不允许再创建了...");
    }
}