Java-反射

Java-反射 反射机制△

反射机制允许程序在执行期借助于Reflection API 取得任何类的内部信息（比如成员变量，构造器，成员方法等等），并能操作对象的属性及方法。反射在设计模式和框架底层都会用到加载完类后，在堆中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了雷的完整结构信息。通过这个对象得到类的结构。这个对象就像是一面镜子，透过这个镜子看到类的结构，所以，形象的称之为：反射

功能

在运行时判断任意个对象所属的类在运行时构造任意一个类的对象在运行时得到任意一个类所具有的成员变量和方法在运行时调用任意一个对象的成员变量和方法生成动态代理

反射的优缺点

优点：可以动态的创建和使用对象（也是框架底层核心），使用灵活，没有反射机制，框架技术就失去底层支撑缺点：使用反射基本是解释执行，对执行速度有影响

优化方案

Method 和 Field、Constructor对象都有setAccessible()方法setAccessible作业是启动和禁用访问安全检查的开关参数值为true表示，反射的对象在使用时取消访问检查，提高反射效率。参数值为false，则表示反射的对象执行访问检查

public class Reflection02 {
    // 测试 反射机制 的性能 和 优化方案
    public static void main(String[] args) throws Exception {
        m1();
        m2();
        m3();
    }
    // 传统方案
    public static void m1() {
        Cat cat = new Cat();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 90000000; i++) {
            cat.hi();
        }
        long end = System.currentTimeMillis();
        System.out.println("传统方法的执行时间是：" + (end - start)); // 5
    }

    // 反射机制
    public static void m2() throws Exception {
        Class cla = Class.forName("com.wxy.Cat");
        Object o = cla.newInstance();
        Method method = cla.getMethod("hi");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 90000000; i++) {
            method.invoke(o);
        }
        long end = System.currentTimeMillis();
        System.out.println("反射机制的执行时间是：" + (end - start)); // 202
    }

    // 反射优化
    public static void m3() throws Exception {
        Class cla = Class.forName("com.wxy.Cat");
        Object o = cla.newInstance();
        Method method = cla.getMethod("hi");
        method.setAccessible(true); // 在反射 调用 方法时， 取消访问机制
        long start = System.currentTimeMillis();
        for (int i = 0; i < 90000000; i++) {
            method.invoke(o);
        }
        long end = System.currentTimeMillis();
        System.out.println("反射机制的执行时间是：" + (end - start)); // 135
    }
}

Class类△

Class也是类，因此也继承Object类Class类对象不是new出来的，而是系统创建的对于某个类的Class对象，在内存中只有一份，因为类只加载一次每个类的实例都会记得自己是由哪个Class实例所生成通过Class可以完整地得到一个类的完整结构，通过一系列APIClass对象是存放在堆的类的字节码二进制数据，是放在方法区的，有的地方称之为类的元数据(包括方法代码，变量名，方法名，访问权限等等)

常用方法

// Class类的常用方法
public static void main(String[] args) throws Exception {
    String classPath = "com.wxy.Car";
    // 1 获取Car类对应的Class类
    Class aClass = Class.forName(classPath);
    // 2 输出alcass
    System.out.println(aClass); // 显示aclass对象，是哪个类的Class对象 com.wxy.Car
    System.out.println(aClass.getClass()); // 输出aclass的运行类型，java.lang.Class
    // 3 得到包名
    System.out.println(aClass.getPackage().getName()); // com.wxy
    // 4 得到类名
    System.out.println(aClass.getName()); // com.wxy.Car
    // 5 通过反射机制，创建对象实例
    Car car = (Car) aClass.newInstance();
    System.out.println(car);
    // 6 通过范式，获取属性
    Field brand = aClass.getField("brand");
    System.out.println(brand.get(car)); // 此方法无法获取私有属性
    // 7 通过反射给属性赋值
    brand.set(car, "dazhong");
    System.out.println(brand.get(car));
    // 8 得到所有属性
    Field[] fields = aClass.getFields();
    for (Field field : fields) {
        System.out.print(field.getName() + " ");
    }

}

获取Class类对象

前提：已知类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException，实例：Class aclass = Class.forName(classPath);

前提：若已知具体的类，通过类的class获取，该方式最为安全可靠，程序性能最高实例：Class aClass = Car.class

前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象，实例：Class aClass = 对象.getClass()

其他方式：ClassLoader cl = 对象.getClass().getClassLoader();

​ Class aclass = cl.loadClass(“类的全类名”);

基本数据（int char boolean float double byte long short） ： Class aclass = 基本数据类型.class

基本数据了理性对应的包装类，可以通过 .type 得到Class类对象

Class aclass = 包装类.TYPE;

// 得到Class对象的各种方式 -- 6
public static void main(String[] args) throws Exception {
    // 1. Class aclass = Class.forName(classPath);
    String classPath = "com.wxy.Car";
    Class aClass = Class.forName(classPath);
    System.out.println(aClass + "    1");
    // 2. Class aClass = Car.class
    Class aClass1 = Car.class;
    System.out.println(aClass1 + "    2");
    // 3. Class aClass = 对象.getClass()
    Car car = new Car();
    Class aClass2 = car.getClass();
    System.out.println(aClass2 + "    3");
    // 4.ClassLoader cl = 对象.getClass().getClassLoader();
    //      Class aclass = cl.loadClass("类的全类名");
    ClassLoader classLoader = car.getClass().getClassLoader();
    Class aClass3 = classLoader.loadClass("com.wxy.Car");
    System.out.println(aClass3 + "    4 ");

    System.out.println(aClass.hashCode());
    System.out.println(aClass1.hashCode());
    System.out.println(aClass2.hashCode());
    System.out.println(aClass3.hashCode());
    // 5. 基本数据（int  char  boolean  float  double  byte  long  short） ：
    //          Class aclass = 基本数据类型.class
    Class integerClass = int.class;
    System.out.println(integerClass);
    Class doubleClass = double.class;
    System.out.println(doubleClass);
    // 6. 基本数据了理性对应的包装类，可以通过 .type 得到Class类对象
    //          Class aclass = 包装类.TYPE;
    Class floatClass = Float.TYPE;
    Class characterClass = Character.TYPE;
    System.out.println(floatClass);
    System.out.println(characterClass);

    Class type = Integer.TYPE;
    System.out.println(type.hashCode()); // 相同
    System.out.println(integerClass.hashCode());
}

哪些类型有Class对象

外部类，成员内部类，静态内部类，局部内部类，匿名内部类interface 接口数组enum 枚举Annotation 注解基本数据类型void

public static void main(String[] args) {
    Class stringClass = String.class; // 外部类
    Class serializableClass = Serializable.class; // 接口
    Class aClass = Integer[].class; // 数组
    Class aClass1 = float[][].class; // 二维数组
    Class deprecatedClass = Deprecated.class; // 注解
    Class stateClass = Thread.State.class; // 枚举
    Class longClass = long.class; // 基本数据类型
    Class voidClass = void.class; // void
    Class classClass = Class.class; // Class
    System.out.println(stringClass);
    System.out.println(serializableClass);
    System.out.println(aClass);
    System.out.println(aClass1);
    System.out.println(deprecatedClass);
    System.out.println(stateClass);
    System.out.println(longClass);
    System.out.println(voidClass);
    System.out.println(classClass);
}

类加载△ 基本说明

反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载静态加载：编译时加载相关的类，若没有则报错，依赖性强动态加载：运行时加载相关的类，若运行时不用该类，则不报错，降低依赖性

类加载时机

当创建对象时 new – 静态加载当子类被加载时，父类也加载 – 静态加载调用类中的静态成员时 – 静态加载通过反射 – 动态加载

过程图

​ 加载和连接有JVM完成

类加载五个阶段的详解 加载阶段

JVM在该阶段的主要目的是将字节码从不同的数据源（可能是class文件，也可能是jar包，甚至网络）转化成二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象

连接阶段-验证

目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全包括：文件格式验证（是否以魔数 ox cafe babe开头）、元数据验证、字节码验证和符号引用验证可以考虑使用 -Xverify:none 参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间

连接阶段-准备

JVM会在该阶段对静态变量，分配内存并默认初始化（对应数据类型的默认初始值，如0、0L、null、false等）。这些变量所使用的内存都讲在方法去中进行分配。

连接阶段-解析

虚拟机将常量池内的符号引用替换为直接引用的过程

初始化阶段

到初始化阶段，才真正开始执行类中定义的java程序代码，此阶段是执行()方法的过程()方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程都需要阻塞等待，知道活动线程执行()方法完毕

反射获取类的结构信息△ Class

// 获得Class对象
Class personClass = Class.forName("com.wxy.reflect.Person");
System.out.println(personClass.getName()); // 1. 获取全类名
System.out.println(personClass.getSimpleName()); // 2. 获取简单类名
// 3. 获取所有public修饰的属性，包含本类和父类的
Field[] fields = personClass.getFields();
for (Field field : fields) {
    System.out.println(field);
}
// 4. 获取本类中所有属性
Field[] declaredFields = personClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
    System.out.println(declaredField);
}
// 5. 获取所有public修饰的方法，包含本类及父类
for (Method method : personClass.getMethods()) {
    System.out.println(method);
}
// 6. 获取本类中的所有方法
for (Method declaredMethod : personClass.getDeclaredMethods()) {
    System.out.println(declaredMethod);
}
// 7. 获取所有public修饰的构造器，包含本类及父类
for (Constructor constructor : personClass.getConstructors()) {
    System.out.println(constructor.getName());
}
// 8. 获取本类所有构造器
for (Constructor declaredConstructor : personClass.getDeclaredConstructors()) {
    System.out.println(declaredConstructor.getName());
}
// 9. 以Package形式返回 包信息
System.out.println(personClass.getPackage());
// 10. 以Class形式返回父类信息
System.out.println(personClass.getClass());
// 11. 以Class[] 形式返回接口信息
Class[] interfaces = personClass.getInterfaces();
for (Class anInterface : interfaces) {
    System.out.println(anInterface.getName());
}
// 12 以Annotation[]形式返回注解信息
for (Annotation annotation : personClass.getAnnotations()) {
    System.out.println(annotation);
}

Field

Class personClass = Class.forName("com.wxy.reflect.Person");
// 说明：默认修饰符为0  public为1  private为2  protected为4 static为8 final为12
Field[] declaredFields = personClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
    System.out.println("本类中所有属性=" + declaredField.getName()
            + " 该属性的修饰符值=" + declaredField.getModifiers()
    + " 该属性的类型=" + declaredField.getType());
}

Method

Class personClass = Class.forName("com.wxy.reflect.Person");
Method[] declaredMethods = personClass.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
    System.out.println("本类的所有方法=" + declaredMethod.getName()
            + " 该方法的访问修饰符值=" + declaredMethod.getModifiers()
            + " 该方法的返回类型=" + declaredMethod.getReturnType());
    System.out.println("当前方法的参数的类型=" + declaredMethod.getParameterTypes());
}

Constructor

Class personClass = Class.forName("com.wxy.reflect.Person");
Constructor[] declaredConstructors = personClass.getDeclaredConstructors();
for (Constructor declaredConstructor : declaredConstructors) {
    System.out.println("本类中所有构造器=" + declaredConstructor.getName());
    Class[] parameterTypes = declaredConstructor.getParameterTypes();
    for (Class parameterType : parameterTypes) {
        System.out.println("该构造器的形参类型=" + parameterType);
    }
}

反射暴破 创建实例

// 1. 先获取到User类的class对象
Class userClass = Class.forName("com.wxy.reflect.User");
// 2. 通过public的无参构造器创建实例
Object o = userClass.newInstance();
System.out.println(o);
// 3. 通过public的有参构造器创建实例   public 的 构造器
Constructor constructor = userClass.getConstructor(int.class, String.class);
Object xwr = constructor.newInstance(22, "xwr");
System.out.println(xwr);
// 4. 通过非public的有参构造器创建实例
Constructor declaredConstructor = userClass.getDeclaredConstructor(int.class);
declaredConstructor.setAccessible(true); // 暴破， 使用反射可以访问private构造器
Object o1 = declaredConstructor.newInstance(32);
System.out.println(o1);

操作属性

// 1. 先获取到Student类的class对象
Class studentClass = Class.forName("com.wxy.reflect.Student");
// 2. 创建对象
Object student = studentClass.newInstance();
// 3. 反射得到 age 和 name
Field age = studentClass.getField("age");
age.set(student, 18);
System.out.println(student);

Field name = studentClass.getDeclaredField("name");
name.setAccessible(true);
name.set(student, "xwr");
name.set(null, "xwr"); // null  ，因为 name是static
System.out.println(student);

操作方法

// 1. 先获取到Boss类的class对象
Class bossClass = Class.forName("com.wxy.reflect.Boss");
// 2. 创建对象
Object boss = bossClass.newInstance();
// 3. 调用 public的hi方法
Method hi = bossClass.getMethod("hi", String.class);
hi.invoke(boss, "sadsadasdas");
// 4. 调用 private 的 say 方法
Method say = bossClass.getDeclaredMethod("say", int.class, String.class, char.class);
say.setAccessible(true);
Object o = say.invoke(boss, 88, "wxy", 'z');
System.out.println(o.toString());