反射API

反射 API 有什么用？

Java 的反射机制允许开发人员在运行时进行更改并获取有关类、接口、字段和方法的信息，而无需知道它们的名称。

反射 API 还允许您创建新对象、调用方法以及获取或设置字段值。

让我们列出使用反射可以做的所有事情：

• 识别/确定对象的类别
• 获取有关类修饰符、字段、方法、常量、构造函数和超类的信息
• 找出哪些方法属于已实现的接口
• 创建一个类的实例，其类名在程序执行之前是未知的
• 按名称获取和设置实例字段的值
• 按名称调用实例方法

几乎所有现代 Java 技术都使用反射。它是当今大多数 Java / Java EE 框架和库的基础，例如：

• 用于构建 Web 应用程序的Spring框架
• JUnit测试框架

如果您以前从未遇到过这些机制，您可能会问为什么所有这些都是必要的。答案很简单但也很模糊：反射极大地增加了灵活性以及定制我们的应用程序和代码的能力。

但总是有利有弊。那么让我们提几个缺点：

• 违反应用程序安全性。反射让我们访问我们不应该访问的代码（违反封装）。
• 安全限制。反射需要运行安全管理器的系统不可用的运行时权限。
• 低性能。Java 中的反射通过扫描类路径以找到要加载的类来动态确定类型。这会降低程序的性能。
• 维护困难。使用反射的代码难以阅读和调试。它不太灵活，也更难维护。

使用反射 API 处理类

所有反射操作都以java.lang.Class对象开始。对于每种类型的对象，都会创建一个不可变的java.lang.Class实例。它提供了获取对象属性、创建新对象和调用方法的方法。

让我们看一下使用java.lang.Class的基本方法列表：

这些是获取有关类、接口、字段和方法的数据的最重要的方法。还有一些方法可以让您获取或设置字段值，以及访问私有字段。我们稍后再看。

现在我们将讨论获取java.lang.Class本身。我们有三种方法可以做到这一点。

1.使用Class.forName

在正在运行的应用程序中，您必须使用forName(String className)方法来获取类。

此代码演示了我们如何使用反射创建类。让我们创建一个我们可以使用的Person类：

package com.company;

public class Person {
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

我们示例的第二部分是使用反射的代码：

public class TestReflection {
    public static void main(String[] args) {
        try {
            Class<?> aClass = Class.forName("com.company.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

如果已知类的全名，则可以使用此方法。然后你可以使用静态Class.forName()方法获取相应的类。此方法不能用于基本类型。

2. 使用.class

如果一个类型可用但没有它的实例，那么您可以通过将.class添加到类型名称来获取该类。这是获取原始类型类的最简单方法。

Class aClass = Person.class;

3. 使用.getClass()

如果对象可用，那么获取类的最简单方法是调用object.getClass()。

Person person = new Person();
Class aClass = person.getClass();

最后两种方法有什么区别？

如果您在编码时知道您对哪个类对象感兴趣，请使用A.class 。如果没有实例可用，那么您应该使用.class。

获取类的方法

让我们看看返回类方法的方法：getDeclaredMethods()和getMethods()。

getDeclaredMethods()返回一个数组，其中包含Class 对象表示的类或接口的所有已声明方法的Method对象，包括公共、私有、默认和受保护的方法，但不包括继承的方法。

getMethods()返回一个数组，其中包含由 Class 对象表示的类或接口的所有公共方法的Method对象——那些由类或接口声明的，以及那些从超类和超接口继承的。

让我们来看看它们各自是如何工作的。

让我们从getDeclaredMethods()开始。为了再次帮助我们理解这两种方法之间的区别，下面我们将使用抽象的Numbers类。让我们编写一个静态方法，将我们的Method数组转换为List<String>：

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class TestReflection {
    public static void main(String[] args) {
        final Method[] declaredMethods = Number.class.getDeclaredMethods();
        List<String> actualMethodNames = getMethodNames(declaredMethods);
        actualMethodNames.forEach(System.out::println);
    }

    private static List<String> getMethodNames(Method[] methods) {
        return Arrays.stream(methods)
                .map(Method::getName)
                .collect(Collectors.toList());
    }
}

这是运行此代码的结果：

这些是在Number类中声明的方法。getMethods()返回什么？让我们更改示例中的两行：

final Method[] methods = Number.class.getMethods();
List<String> actualMethodNames = getMethodNames(methods);

这样做，我们将看到以下一组方法：

因为所有类都继承Object ，所以我们的方法也返回Object类的公共方法。

获取类的字段

getFields和getDeclaredFields方法用于获取类的字段。例如，让我们看一下LocalDateTime类。我们将重写我们的代码：

import java.lang.reflect.Field;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class TestReflection {
    public static void main(String[] args) {
        final Field[] declaredFields = LocalDateTime.class.getDeclaredFields();
        List<String> actualFieldNames = getFieldNames(declaredFields);
        actualFieldNames.forEach(System.out::println);
    }

    private static List<String> getFieldNames(Field[] fields) {
        return Arrays.stream(fields)
                .map(Field::getName)
                .collect(Collectors.toList());
    }
}

作为执行此代码的结果，我们获得了包含在 LocalDateTime 类中的字段集。

类比我们之前对方法的检查，让我们看看如果我们稍微更改代码会发生什么：

final Field[] fields = LocalDateTime.class.getFields();
List<String> actualFieldNames = getFieldNames(fields);

输出：

现在让我们弄清楚这些方法之间的区别。

getDeclaredFields方法返回一个Field对象数组，用于由 this 表示的类或接口声明的所有字段班级目的。

getFields方法为类或接口所代表的所有公共字段返回一个Field对象数组班级目的。

现在让我们看看LocalDateTime 的内部。

班级的最小值和最大限度字段是公共的，这意味着它们将通过getFields方法可见。相比之下，日期,时间,serialVersionUID方法具有private修饰符，这意味着它们不会通过getFields方法可见，但我们可以使用getDeclaredFields获取它们。这就是我们如何访问私有字段的 Field 对象。

其他方法说明

现在该说说Class类的一些方法了，即：

getModifiers()

修饰符可以使用班级目的。

修饰符是关键字，如public、static、interface等。我们使用getModifiers()方法获取修饰符：

Class<Person> personClass = Person.class;
int classModifiers = personClass.getModifiers();

此代码设置一个值整数位域变量。每个访问修饰符都可以通过设置或清除相应的位来打开或关闭。我们可以使用java.lang.reflect.Modifier类中的方法检查修饰符：

import com.company.Person;
import java.lang.reflect.Modifier;

public class TestReflection {
    public static void main(String[] args) {
        Class<Person> personClass = Person.class;
        int classModifiers = personClass.getModifiers();

        boolean isPublic = Modifier.isPublic(classModifiers);
        boolean isStatic = Modifier.isStatic(classModifiers);
        boolean isFinal = Modifier.isFinal(classModifiers);
        boolean isAbstract = Modifier.isAbstract(classModifiers);
        boolean isInterface = Modifier.isInterface(classModifiers);

        System.out.printf("Class modifiers: %d%n", classModifiers);
        System.out.printf("Is public: %b%n", isPublic);
        System.out.printf("Is static: %b%n", isStatic);
        System.out.printf("Is final: %b%n", isFinal);
        System.out.printf("Is abstract: %b%n", isAbstract);
        System.out.printf("Is interface: %b%n", isInterface);
    }
}

回想一下我们的Person的声明是什么样的：

public class Person {
   …
}

我们得到以下输出：

如果我们使我们的类抽象，那么我们有：

public abstract class Person { … }

这个输出：

我们更改了访问修饰符，这意味着我们还更改了通过Modifier类的静态方法返回的数据。

获取包()

只知道一个类，我们可以得到关于它的包的信息：

Class<Person> personClass = Person.class;
final Package aPackage = personClass.getPackage();
System.out.println(aPackage.getName());

获取超类()

如果我们有一个 Class 对象，那么我们可以访问它的父类：

public static void main(String[] args) {
    Class<Person> personClass = Person.class;
    final Class<? super Person> superclass = personClass.getSuperclass();
    System.out.println(superclass);
}

我们得到众所周知的Object类：

class java.lang.Object

但是如果我们的类有另一个父类，那么我们会看到它：

package com.company;

class Human {
    // Some info
}

public class Person extends Human {
    private int age;
    private String name;

    // Some info
}

在这里我们得到我们的父类：

class com.company.Human

获取接口（）

以下是我们如何获取类实现的接口列表的方法：

public static void main(String[] args) {
    Class<Person> personClass = Person.class;
    final Class<?>[] interfaces = personClass.getInterfaces();
    System.out.println(Arrays.toString(interfaces));
}

我们不要忘记更改我们的Person类：

public class Person implements Serializable { … }

输出：

一个类可以实现很多接口。这就是为什么我们得到一个数组班级对象。在 Java Reflection API 中，接口也被表示为班级对象。

请注意：该方法只返回指定类实现的接口，不返回其父类。要获得该类实现的接口的完整列表，您需要引用当前类及其在继承链上游的所有祖先。

getName() & getSimpleName() & getCanonicalName()

让我们编写一个涉及原始类、嵌套类、匿名类和String类的示例：

public class TestReflection {
    public static void main(String[] args) {
        printNamesForClass(int.class, "int class (primitive)");
        printNamesForClass(String.class, "String.class (ordinary class)");
        printNamesForClass(java.util.HashMap.SimpleEntry.class,
                "java.util.HashMap.SimpleEntry.class (nested class)");
        printNamesForClass(new java.io.Serializable() {
                }.getClass(),
                "new java.io.Serializable(){}.getClass() (anonymous inner class)");
    }

    private static void printNamesForClass(final Class<?> clazz, final String label) {
        System.out.printf("%s:%n", label);
        System.out.printf("\tgetName()):\t%s%n", clazz.getName());
        System.out.printf("\tgetCanonicalName()):\t%s%n", clazz.getCanonicalName());
        System.out.printf("\tgetSimpleName()):\t%s%n", clazz.getSimpleName());
        System.out.printf("\tgetTypeName():\t%s%n%n", clazz.getTypeName());
    }
}

我们程序的结果：

现在让我们分析程序的输出：

• getName()返回实体的名称。

• getCanonicalName()返回基类的规范名称，如 Java 语言规范所定义。如果基类没有规范名称（即，如果它是本地类或匿名类或元素类型没有规范名称的数组），则返回 null。

• getSimpleName()返回源代码中指定的基类的简单名称。如果基类是匿名的，则返回一个空字符串。

• getTypeName()返回此类型名称的信息字符串。