学习总结录
旭日
2023-03-31
目录

Java-反射

# 反射简介

image-20221208165745766

# 什么是反射

反射(Reflection)是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序获取自身的信息，并且可以操作类或对象的内部属性。

通过反射机制，可以在运行时访问 Java 对象的属性，方法，构造方法等。

# 反射的应用场景

  • 开发通用框架 - 反射最重要的用途就是开发各种通用框架。很多框架（比如 Spring）都是配置化的（比如通过 XML 文件配置 JavaBean、Filter 等），为了保证框架的通用性，它们可能需要根据配置文件加载不同的对象或类，调用不同的方法，这个时候就必须用到反射——运行时动态加载需要加载的对象。
  • 动态代理 - 在切面编程（AOP）中，需要拦截特定的方法，通常，会选择动态代理方式。这时，就需要反射技术来实现了。
  • 注解 - 注解本身仅仅是起到标记作用，它需要利用反射机制，根据注解标记去调用注解解释器，执行行为。如果没有反射机制，注解并不比注释更有用。
  • 可扩展性功能 - 应用程序可以通过使用完全限定名称创建可扩展性对象实例来使用外部的用户定义类。

# 反射的缺点

  • 性能开销 - 由于反射涉及动态解析的类型，因此无法执行某些 Java 虚拟机优化。因此，反射操作的性能要比非反射操作的性能要差，应该在性能敏感的应用程序中频繁调用的代码段中避免。
  • 破坏封装性 - 反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题。
  • 内部曝光 - 由于反射允许代码执行在非反射代码中非法的操作，例如访问私有字段和方法，所以反射的使用可能会导致意想不到的副作用，这可能会导致代码功能失常并可能破坏可移植性。反射代码打破了抽象，因此可能会随着平台的升级而改变行为。

# 反射机制

# Class对象

要想使用反射，首先需要获得待操作的类所对应的 Class 对象。如下定义的代码：

User user = new User();
  1. JVM 加载方法的时候，遇到 new User()，JVM 会根据 User 的全限定名去加载 User.class 。
  2. JVM 会去本地磁盘查找 User.class 文件并加载 JVM 内存中。
  3. JVM 通过调用类加载器自动创建这个类对应的 Class 对象，并且存储在 JVM 的方法区。注意：一个类有且只有一个 Class 对象。

Java 中，无论生成某个类的多少个对象，这些对象都会对应于同一个 Class 对象。这个 Class 对象是由 JVM 生成的，通过它能够获悉整个类的结构。所以反射的本质就是：在运行时，把 Java 类中的各种成分映射成一个个的 Java 对象。

# 方法的反射调用

方法的反射调用，也就是Method.invoke 方法。

public final class Method extends Executable {
  ...
  public Object invoke(Object obj, Object... args) throws ... {
    ... // 权限检查
    MethodAccessor ma = methodAccessor;
    if (ma == null) {
      ma = acquireMethodAccessor();
    }
    return ma.invoke(obj, args);
  }
}

Method.invoke 方法实际上委派给 MethodAccessor 接口来处理。它有两个已有的具体实现：

  • NativeMethodAccessorImpl：本地方法来实现反射调用
  • DelegatingMethodAccessorImpl：委派模式来实现反射调用

# 反射调用的开销

方法的反射调用会带来不少性能开销，原因主要有三个：

  • 变长参数方法导致的 Object 数组
  • 基本类型的自动装箱、拆箱
  • 还有最重要的方法内联

由于 Method.invoke 是一个变长参数方法，在字节码层面它的最后一个参数会是 Object 数组，Java 编译器会在方法调用处生成一个长度为传入参数数量的 Object 数组，并将传入参数一一存储进该数组中。由于 Object 数组不能存储基本类型，Java 编译器会对传入的基本类型参数进行自动装箱。

Class.forName 会调用本地方法，Class.getMethod 则会遍历该类的公有方法。如果没有匹配到，它还将遍历父类的公有方法。可想而知，这两个操作都非常费时。

# 使用反射

image-20221209174459860

# java.lang.reflect包

Java 中的 java.lang.reflect 包提供了反射功能。java.lang.reflect 包中的类都没有 public 构造方法。核心接口和类如下：

  • Member 接口：反映关于单个成员(字段或方法)或构造函数的标识信息。
  • Field 类：提供一个类的域的信息以及访问类的域的接口。
  • Method 类：提供一个类的方法的信息以及访问类的方法的接口。
  • Constructor 类：提供一个类的构造函数的信息以及访问类的构造函数的接口。
  • Array 类：该类提供动态地生成和访问 JAVA 数组的方法。
  • Modifier 类：提供了 static 方法和常量，对类和成员访问修饰符进行解码。
  • Proxy 类：提供动态地生成代理类和类实例的静态方法。

# 获取Class对象

方法一：Class.forName静态方法

public class Test {
    public static void main(String[] args) throws ClassNotFoundException {

        Class c1 = Class.forName("me.xu.Test");
        System.out.println(c1.getCanonicalName());

        Class c2 = Class.forName("[D");
        System.out.println(c2.getCanonicalName());

        Class c3 = Class.forName("[[Ljava.lang.String;");
        System.out.println(c3.getCanonicalName());

    }
}

使用类的完全限定名来反射对象的类。常见的应用场景为：在 JDBC 开发中常用此方法加载数据库驱动。

方法二：类名+.class

public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Integer.class;
        System.out.println(c1.getCanonicalName());

        Class c2 = java.io.InputStream.class;
        System.out.println(c2.getCanonicalName());

        Class c3 = int[][][].class;
        System.out.println(c3.getCanonicalName());

    }
}

方法三：Object 的 getClass 方法

Object 类中有 getClass 方法，因为所有类都继承 Object 类。从而调用 Object 类来获取 Class 对象。

public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c = "foo".getClass();
        System.out.println(c.getCanonicalName());
        byte[] bytes = new byte[1024];
        Class c2 = bytes.getClass();
        System.out.println(c2.getCanonicalName());
    }
}

# 判断是否为某个类的实例

判断是否为某个类的实例有两种方式：

  1. 用 instanceof 关键字
  2. 用 Class 对象的 isInstance 方法（它是一个 Native 方法）
public class InstanceofDemo {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        if (arrayList instanceof List) {
            System.out.println("ArrayList is List");
        }
        if (List.class.isInstance(arrayList)) {
            System.out.println("ArrayList is List");
        }
    }
}

# 创建实例

通过反射来创建实例对象主要有两种方式：

  • 用 Class 对象的 newInstance 方法。
  • 用 Constructor 对象的 newInstance 方法。
public class NewInstanceDemo {
    public static void main(String[] args)
        throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class<?> c1 = StringBuilder.class;
        StringBuilder sb = (StringBuilder) c1.newInstance();
        sb.append("aaa");
        System.out.println(sb.toString());

        //获取String所对应的Class对象
        Class<?> c2 = String.class;
        //获取String类带一个String参数的构造器
        Constructor constructor = c2.getConstructor(String.class);
        //根据构造器创建实例
        String str2 = (String) constructor.newInstance("bbb");
        System.out.println(str2);
    }
}

# 创建数组实例

数组在 Java 里是比较特殊的一种类型，它可以赋值给一个对象引用。Java 中，通过 Array.newInstance 创建数组的实例。

public class ReflectArrayDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> cls = Class.forName("java.lang.String");
        Object array = Array.newInstance(cls, 25);
        //往数组里添加内容
        Array.set(array, 0, "Scala");
        Array.set(array, 1, "Java");
        Array.set(array, 2, "Groovy");
        Array.set(array, 3, "Scala");
        Array.set(array, 4, "Clojure");
        //获取某一项的内容
        System.out.println(Array.get(array, 3));
    }
}

# Field

Class 对象提供以下方法获取对象的成员（Field）：

  • getFiled - 根据名称获取公有的（public）类成员。
  • getDeclaredField - 根据名称获取已声明的类成员。但不能得到其父类的类成员。
  • getFields - 获取所有公有的（public）类成员。
  • getDeclaredFields - 获取所有已声明的类成员。
public class ReflectFieldDemo {
    class FieldSpy<T> {
        public boolean[][] b = { {false, false}, {true, true} };
        public String name = "Alice";
        public List<Integer> list;
        public T val;
    }

    public static void main(String[] args) throws NoSuchFieldException {
        Field f1 = FieldSpy.class.getField("b");
        System.out.format("Type: %s%n", f1.getType());

        Field f2 = FieldSpy.class.getField("name");
        System.out.format("Type: %s%n", f2.getType());

        Field f3 = FieldSpy.class.getField("list");
        System.out.format("Type: %s%n", f3.getType());

        Field f4 = FieldSpy.class.getField("val");
        System.out.format("Type: %s%n", f4.getType());
    }
}

# Method

Class 对象提供以下方法获取对象的方法（Method）：

  • getMethod - 返回类或接口的特定方法。其中第一个参数为方法名称，后面的参数为方法参数对应 Class 的对象。
  • getDeclaredMethod - 返回类或接口的特定声明方法。其中第一个参数为方法名称，后面的参数为方法参数对应 Class 的对象。
  • getMethods - 返回类或接口的所有 public 方法，包括其父类的 public 方法。
  • getDeclaredMethods - 返回类或接口声明的所有方法，包括 public、protected、默认（包）访问和 private 方法，但不包括继承的方法。
public class Test {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        // 返回所有方法
        Method[] methods1 = System.class.getDeclaredMethods();
        System.out.println("System getDeclaredMethods 清单（数量 = " + methods1.length + "）：");
        for (Method m : methods1) {
            System.out.println(m);
        }

        // 返回所有 public 方法
        Method[] methods2 = System.class.getMethods();
        System.out.println("System getMethods 清单（数量 = " + methods2.length + "）：");
        for (Method m : methods2) {
            System.out.println(m);
        }

        // 利用 Method 的 invoke 方法调用 System.currentTimeMillis()
        Method method = System.class.getMethod("currentTimeMillis");
        System.out.println(method);
        System.out.println(method.invoke(null));
    }
}

# Constructor

Class 对象提供以下方法获取对象的构造方法（Constructor）：

  • getConstructor - 返回类的特定 public 构造方法。参数为方法参数对应 Class 的对象。
  • getDeclaredConstructor - 返回类的特定构造方法。参数为方法参数对应 Class 的对象。
  • getConstructors - 返回类的所有 public 构造方法。
  • getDeclaredConstructors - 返回类的所有构造方法。

获取一个 Constructor 对象后，可以用 newInstance 方法来创建类实例。

public class ReflectMethodConstructorDemo {
    public static void main(String[] args)
        throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Constructor<?>[] constructors1 = String.class.getDeclaredConstructors();
        System.out.println("String getDeclaredConstructors 清单（数量 = " + constructors1.length + "）：");
        for (Constructor c : constructors1) {
            System.out.println(c);
        }

        Constructor<?>[] constructors2 = String.class.getConstructors();
        System.out.println("String getConstructors 清单（数量 = " + constructors2.length + "）：");
        for (Constructor c : constructors2) {
            System.out.println(c);
        }

        System.out.println("====================");
        Constructor constructor = String.class.getConstructor(String.class);
        System.out.println(constructor);
        String str = (String) constructor.newInstance("bbb");
        System.out.println(str);
    }
}

# 参考

深入理解Java反射和动态代理 (opens new window)

#Java
上次更新: 2024/06/29, 15:13:44
Java-枚举
Java-泛型

← Java-泛型→

最近更新
01
基础概念
10-31
02
Pytorch
10-30
03
Numpy
10-30
更多文章>
Theme by Vdoing | Copyright © 2021-2024 旭日 | 蜀ICP备2021000788号-1