反射（Refelection）

静态语言 VS 动态语言

动态语言

动态语言是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其它结构上的变化。通俗一点说就是在运行时代码可以根据某些条件改变自身结构

静态语言

与动态语言相对应，运行时结构不可变的语言就是静态语言，如 Java、C、C++

Java 不是静态语言，但是 Java 可以称之为 “准动态语言”。即 Java 有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。Java 的动态性让编程的时候更加灵活

Java反射机制概述

??Reflection（反射）是 Java 被视为动态语言的关键，反射机制允许程序在执行期借助于 Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性以及方法

 Class c = Class.forName("java.lang.String");

加载完类之后，在堆内存的方法区中就产生了一个 Class 类型的对象（一个类只有一个 Class 对象），这个对象就包含了完整类的类的结构信息。我们可以通过对这个对象看到的类的结构。这个对象就像一面镜子，通过这个镜子看到类的结构，所以，我们形象地称之为：反射

• 正常方式：引入需要的 “ 包类 ” 名称 ——> 通过 new 实例化 ——> 取得实例化对象

• 反射方式：实例化对象 ——> getClass() 方法 ——> 得到完整的 “包类” 名称

Java 反射机制提供的功能

• 在运行时判断任意一个对象所属的类

• 在运行时构造任意一个类的对象

• 在运行时判断任意一个类所具有的成员变量和方法

• 在运行时获取泛型信息

• 在运行时调用任意一个对象的成员变量和方法

• 在运行时处理注解

• 生成动态代理

Java 反射优点和缺点

优点： 可以实现动态创建对象和编译，体现出很大的灵活性

缺点： 对性能有影响。使用反射基本上是一种解释操作，我们可以告诉 JVM，我们希望做什么并且它满足我们什么要求，这类操作总是慢于直接执行相同的操作

反射相关的主要 API

• java.lang.Class 代表一个类

• java.lang.reflect.Method 代表类的方法

• java.lang.reflect.Field 代表类的成员变量

• java.lang.reflect.Constructor 代表类的构造器

理解Class类并获取Class实例

先定义一个实体类

package com.sww.Refelection;
?
public class User {
        private int id;
        private String name;
        private int age;
?
    public int getId() {
        return id;
    }
?
    public void setId(int id) {
        this.id = id;
    }
?
    public String getName() {
        return name;
    }
?
    public void setName(String name) {
        this.name = name;
    }
?
    public int getAge() {
        return age;
    }
?
    public void setAge(int age) {
        this.age = age;
    }
?
    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public User(){
?
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }
?
}

主程序

public static void main(String[] args) throws ClassNotFoundException {
    //通过反射获取类Class对象
    Class<?> cl = Class.forName("com.sww.Refelection.User");
    System.out.println(cl);
}
----------------------------------------------------------------------
输出：class com.sww.Refelection.User

一个类在内存中只有一个 Class 对象，一个类被加载之后，类的整个结构都会被封装在 Class 对象中

在 Object 类中定义了以下方法，此方法将被所有子类继承

public final native Class<?> getClass();

上面的方法返回值的类型是一个 Class 类，此类是 Java 反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称

对于每个类而言，JRE 都为其保留了一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构（class / interface / enum / annotation / primitive type/void / []）

• Class 本身也是一个类

• Class 对象只能由系统建立对象

• 一个加载的类在 JVM 中只会有一个 Class 实例

• 一个 Class 对象对应的是一个加载到 JVM 中的一个 .class 文件

• 每个类的实例都会记得自己是由哪个 Class 实例所生成

• 通过 Class 可以完整地得到一个类中的所有被加载的结构

• Class 类是 Reflection 的根源，针对任何你想动态加载、运行的类、唯有先获得响应的 Class 对象

Class 类的常用方法

获取 Class 类的实例

public static void main(String[] args) throws Exception {
    // 方式一：forName 获得
    Class aClass = Class.forName("com.java.demo.reflect.User");
    System.out.println(aClass);
?
    // 方式二：通过对象获得
    Class aClass1 = new User().getClass();
    System.out.println(aClass1);
?
    // 方式三：通过类名.class 获得
    Class<User> aClass2 = User.class;
    System.out.println(aClass2);
}

所有类型的 Class 对象

ublic static void main(String[] args) {
    Class objectClass = Object.class;            // 类
    Class comparableClass = Comparable.class;    // 接口
    Class aClass = String[].class;               // 一维数组
    Class aClass1 = int[][].class;               // 二维数组
    Class overrideClass = Override.class;        // 注解
    Class elementTypeClass = ElementType.class;  // 枚举
    Class integerClass = Integer.class;          // 基本数据类型
    Class voidClass = void.class;                // void
    Class classClass = Class.class;              // Class
?
    System.out.println(objectClass);
    System.out.println(comparableClass);
    System.out.println(aClass);
    System.out.println(aClass1);
    System.out.println(overrideClass);
    System.out.println(elementTypeClass);
    System.out.println(integerClass);
    System.out.println(voidClass);
    System.out.println(classClass);
}

Java 内存分析

类的加载与ClassLoader

• 加载：将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的 java.lang.Class 对象

• 链接：将 Java 类的二进制代码合并到 JVM 的运行状态之中的过程

  • 验证：确保加载的类信息符合 JVM 规范，没有安全方面的问题

  • 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配

  • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程

• 初始化：

  • 执行类构造器< clint>() 方法的过程，类构造器< clint>() 方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的（类构造器是构造类信息的，不是构造该类对象的构造器）

  • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化

  • 虚拟机会保证一个类的< clint>() 方法在多线程环境中被正确加锁和同步

public static void main(String[] args) {
        /**
         * 1、加载到内存，会产生一个类对应的 Class 对象
         * 2、链接，链接结束后 m = 0
         * 3、初始化
         <clint>() {
         System.out.println("A 类静态代码块初始化");
         m = 300;
         m = 100;
         }
         m = 100;
         */
        A a = new A();
        System.out.println(A.m);
    }
}
?
class A {
    static {
        System.out.println("A 类静态代码块初始化");
        m = 300;
    }
?
    static int m = 100;
?
    public A() {
        System.out.println("A 类的无参构造函数初始化");
    }
------------------------------------------------------------------------
A 类静态代码块初始化
A 类的无参构造函数初始化
100

获取运行时类的完整结构 & 动态创建对象执行方法

Field、Method、Constructor、SuperClass、Interface、Annotation

• 实现的全部接口

• 所继承的父类

• 全部的构造器

• 全部的方法

• 全部的 Field

• 注解

• …

性能对比分析

setAccessible

• Method 和 Field、Constructor 对象都有 setAccessible() 方法

• setAccessible 作用是启动和禁用访问安全检查的开关

• 参数值为 true 则提示反射的对象在使用时应该取消 Java 语言访问检查

  • 提高反射的效率，如果代码中必须用反射，而该语句需要频繁的被调用，那么请设置为 true

  • 使得原本无法访问的私有成员也可以访问

• 参数值为 false 则指示反射的对象应该实施 Java 语言访问检查

// 普通方式调用
public static void test01() {
    User user = new User();
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 100000000; i++) {
        user.getName();
    }
    long endTime = System.currentTimeMillis();
    System.out.println("普通方式执行 1 亿次：" + (endTime - startTime) + "ms");
}
?
// 反射方式调用
public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    User user = new User();
    Class c = user.getClass();
    Method getName = c.getDeclaredMethod("getName", null);
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 100000000; i++) {
        getName.invoke(user, null);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("反射方式执行 1 亿次：" + (endTime - startTime) + "ms");
}
?
// 反射方式调用，关闭检测
public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    User user = new User();
    Class c = user.getClass();
    Method getName = c.getDeclaredMethod("getName", null);
    getName.setAccessible(true);
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 100000000; i++) {
        getName.invoke(user, null);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("关闭检测方式执行 1 亿次：" + (endTime - startTime) + "ms");
}
?
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
    test01();
    test02();
    test03();
}
---------------------------------------------------------------------
普通方式执行 1 亿次：4ms
反射方式执行 1 亿次：119ms
关闭检测方式执行 1 亿次：87ms

通过反射去操作泛型

• Java 采用泛型擦除的机制来引入泛型，Java 中的泛型仅仅是给编译器 javac 使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除

• 为了通过反射操作这些类型，Java 新增了 ParameterizedType，GenericArrayType，TypeVariable 和 WildcardType 几种类型来代表不能被归一到 Class 类中的类型但是又和原始类型齐名的类型

  • ParameterizedType：表示一种参数化类型，比如 Collection< String>

  • GenericArrayType：表示一种元素类型时参数化类型或者类型变量的数组类型

  • TypeVariable ：是各种类型变量的公共父接口

  • WildcardType ：代表一种通配符类型表达式

====================================================================

public void test01(Map<String, User> map, List<User> list) {
    System.out.println("test01");
}

public Map<String, User> test02() {
    System.out.println("test02");
    return null;
}

// 通过反射获取泛型
public static void main(String[] args) throws NoSuchMethodException {
    Method test01 = Test01.class.getMethod("test01", Map.class, List.class);
    // 获取通用参数类型
    Type[] genericParameterTypes = test01.getGenericParameterTypes();
    // 迭代遍历
    for (Type genericParameterType : genericParameterTypes) {
        System.out.println("# " + genericParameterType);
        if (genericParameterType instanceof ParameterizedType) {
            // 获取实际参数类型
            Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }

    Method test02 = Test01.class.getMethod("test02", null);
    Type genericReturnType = test02.getGenericReturnType();
    if (genericReturnType instanceof ParameterizedType) {
        Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
        for (Type actualTypeArgument : actualTypeArguments) {
            System.out.println(actualTypeArgument);
        }
    }
}

注意： invoke方法如果提供了错误的参数，会抛出一个异常，所以要提供一个异常处理器。建议在有必要的时候才使用invoke方法，有如下原因：

• 1、invoke方法的参数和返回值必须是Object类型，意味着必须进行多次类型转换

• 2、通过反射调用方法比直接调用方法要明显慢一些

Constructor

getConstructor(Class<?>… parameterTypes)

获取类的特定 public 构造方法。参数为方法参数对应 Class 的对象

public class ReflectDemo {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        Constructor<CaseMethod> constructor = CaseMethod.class.getConstructor(int.class, String.class);
        System.out.println(constructor);
    }
}

class CaseMethod{

    private int id;
    private String name;
    private int cap;

    public CaseMethod(int id,String name){
        this.id = id;
        this.name = name;
    }

    public CaseMethod(int cap){

    }
}

getConstructors()

获取类的所有 public 构造方法

public static void main(String[] args) {
        Constructor<?>[] constructors = CaseMethod.class.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
    }
}

class CaseMethod{

    private int id;
    private String name;
    private int cap;

    public CaseMethod(int id,String name){
        this.id = id;
        this.name = name;
    }

    public CaseMethod(int cap){

    }

getDeclaredConstructor(Class<?>… parameterTypes)

    public static void main(String[] args) throws NoSuchMethodException {
        // 注意：由于private修饰的CaseMethod构造函数没有参数，所以getDeclaredConstructor()可以为空
        // 默认的getDeclaredConstructor(Class<?>... parameterTypes)方法是要传参数类型的
        Constructor<CaseMethod> constructor = CaseMethod.class.getDeclaredConstructor();
        Constructor<CaseMethod> declaredConstructor = CaseMethod.class.getDeclaredConstructor(int.class, String.class);
        System.out.println(constructor);
        System.out.println(declaredConstructor);
    }
}

class CaseMethod{

    private int id;
    private String name;
    private int cap;

    private CaseMethod(){

    }

    public CaseMethod(int id,String name){
        this.id = id;
        this.name = name;
    }

getDeclaredConstructors()

    public static void main(String[] args) throws NoSuchMethodException {
        Constructor<?>[] constructors = CaseMethod.class.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
    }
}

class CaseMethod{

    private int id;
    private String name;
    private int cap;

    private CaseMethod(){

    }

    public CaseMethod(int id,String name){
        this.id = id;
        this.name = name;
    }

使用newInstance创建实例

public class ReflectDemo {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Constructor<CaseMethod> constructor = CaseMethod.class.getConstructor(String.class);
        CaseMethod caseMethod = constructor.newInstance("Lisa");
        System.out.println(caseMethod);
    }
}

class CaseMethod{

    private String name;

    public CaseMethod(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return "CaseMethod{" +
                "name=‘" + name + ‘\‘‘ +
                ‘}‘;
    }
}

总结

Java获得Class对象的引用的方法中，Class.forName() 方法会自动初始化Class对象，而 .class 方法不会，.class 的初始化被延迟到静态方法或非常数静态域的首次引用

反射（Refelection）

原文：https://www.cnblogs.com/suwenwu/p/15097384.html