Java的基本使用之反射

1、反射的概念

反射就是Reflection，Java的反射是指程序在运行期可以拿到一个对象的所有信息。反射是为了解决在运行期，对某个实例一无所知的情况下，去调用其方法。

 

2、Class实例

除了int等基本类型外，Java的其他类型全部都是class（包括interface）。

而class是由JVM在执行过程中动态加载的，JVM在每次第一次读取到一种class类型时，都将其加载进内存。每加载一种class，JVM就为其创建一个Class类型的实例，并关联起来。注意：这里的Class类型是一个名叫Class的class。如下：

public final class Class {
    private Class() {}
}

比如String类，当JVM加载String类时，它首先读取String.class文件到内存，然后，为String类创建一个Class实例并关联起来：

Class cls = new Class(String);

JVM持有的每个Class实例都指向一个数据类型（class或interface）。一个Class实例包含了该class的所有完整信息，包括类名、包名、父类、实现的接口、所有方法、字段等，因此，如果获取了某个Class实例，我们就可以通过这个Class实例获取到该实例对应的class的所有信息。这种通过Class实例获取class信息的方法就称为反射（Reflection）。

JVM也为每一种基本类型都创建了Class，如 int 的 Class可以通过int.class访问。

 

2.1、如何获取一个class的Class实例

1）直接通过一个class的静态变量class获取

Class cls = String.class;

2）如果有class的一个实例变量，可以直接通过 class 的实例变量提供的getClass()方法获取

String s = "Hello";
Class cls = s.getClass();

3）如果知道class的完整类名，可以通过静态方法Class.forName()获取

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

一种class的Class实例在JVM中是唯一的。

 

如果获取到了一个Class实例，我们就可以通过该Class实例来创建对应类型的实例：

// 获取String的Class实例:
Class cls = String.class;
// 创建一个String实例:
String s = (String) cls.newInstance();  //创建了一个空字符串

上述代码相当于new String()。通过Class.newInstance()可以创建类实例，它的局限是：只能调用public的无参数构造方法。带参数的构造方法，或者非public的构造方法都无法通过Class.newInstance()被调用。

 

3、通过反射访问类的字段

3.1、获取类的字段信息

对任意的一个Object实例，只要我们获取了它的Class，就可以获取它的一切信息。我们可以通过Class实例获取字段信息。

Class类提供了以下几个方法来获取字段对象：

• Field getField(name)：根据字段名获取某个public的field对象（包括父类）
• Field getDeclaredField(name)：根据字段名获取当前类的某个field对象（不包括父类，也包含非public）
• Field[] getFields()：获取所有public的field对象（包括父类）
• Field[] getDeclaredFields()：获取当前类的所有field对象（不包括父类，也包含非public）

 代码示例：

public class Main {
    public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;
        // 获取public字段"score":
        System.out.println(stdClass.getField("score"));   //输出public int Student.score
        // 获取继承的public字段"name":
        System.out.println(stdClass.getField("name"));  //输出public java.lang.String Person.name
        // 获取private字段"grade":
        System.out.println(stdClass.getDeclaredField("grade"));  //输出private int Student.grade
    }
}

class Student extends Person {
    public int score;
    private int grade;
}

class Person {
    public String name;
}

一个Field对象包含了一个字段的所有信息：

• getName()：返回字段名称，例如，"name"；
• getType()：返回字段类型，也是一个Class实例，例如，String.class；
• getModifiers()：返回字段的修饰符，它是一个整型int，不同的bit表示不同的含义。可以通过调用Modifier.isFinal(int n)、Modifier.isPublic(int n)、Modifier.isProtected(int n)、Modifier.isPrivate(int n)、Modifier.isStatic(int n)来判断返回的修饰符

//以String类的value字段为例，它的定义如下：
public final class String {
    private final byte[] value;
}

//通过反射获取字段信息
Field f = String.class.getDeclaredField("value");
System.out.println(f.getName()); // "value"
System.out.println(f.getType()); // class [B 表示byte[]类型

int m = f.getModifiers();
System.out.println(Modifier.isFinal(m));   //true
System.out.println(Modifier.isPublic(m));   //false
System.out.println(Modifier.isProtected(m));  //false
System.out.println(Modifier.isPrivate(m));  //true
System.out.println(Modifier.isStatic(m));   //false

 

3.2、获取类的实例的字段值

我们可以通过反射拿到一个类实例对应的该字段的值。

例如，下面对于一个Person实例，我们先拿到name字段对应的Field，再获取这个实例的name字段的值：

import java.lang.reflect.Field;
public class Main {
    public static void main(String[] args) throws Exception {
        Object p = new Person("Xiao Ming");
        Class c = p.getClass();   //获取Class实例
        Field f = c.getDeclaredField("name");   //获取Field实例

        f.setAccessible(true);      //调用Field.setAccessible(true)使其可以访问private字段，否则会报错。也可以将 Person 的 name 字段改成public
        Object value = f.get(p);   //用Field.get(Object)获取指定实例的指定字段的值。
        System.out.println(value); // "Xiao Ming"
    }
}

class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
}

使用反射可以获取private字段的值，但是反射是一种非常规的用法，使用反射，首先代码非常繁琐，其次，它更多地是给工具或者底层框架来使用，目的是在不知道目标实例任何信息的情况下，获取特定字段的值。所以说类的封装还是有意义的。

setAccessible(true)可能会失败。如果JVM运行期存在SecurityManager，那么它会根据规则进行检查，有可能阻止setAccessible(true)。例如，某个SecurityManager可能不允许对java和javax开头的package的类调用setAccessible(true)，这样可以保证JVM核心库的安全。

 

3.3、设置实例的字段值

我们可以通过Field.set(Object, Object)来设置实例的字段值，其中第一个Object参数是指定的实例，第二个Object参数是待修改的值。

下面代码通过反射修改实例的name字段值：

import java.lang.reflect.Field;
public class Main {
    public static void main(String[] args) throws Exception {
        Person p = new Person("Xiao Ming");
        System.out.println(p.getName()); // "Xiao Ming"
        Class c = p.getClass();
        Field f = c.getDeclaredField("name");
        f.setAccessible(true);   //修改非public字段，需要先调用setAccessible(true)。
        f.set(p, "Xiao Hong");
        System.out.println(p.getName()); // "Xiao Hong"
    }
}

class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
}

 

4、通过反射调用方法

4.1、通过Class实例获取方法

我们可以通过Class实例获取类的所有Method信息，Class类提供了以下几个方法来获取Method： 

• Method getMethod(name, Class...)：获取某个public的Method（包括父类）
• Method getDeclaredMethod(name, Class...)：获取当前类的某个Method（不包括父类）
• Method[] getMethods()：获取所有public的Method（包括父类）
• Method[] getDeclaredMethods()：获取当前类的所有Method（不包括父类）

public class Main {
    public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;
        // 获取public方法getScore，参数为String:
        System.out.println(stdClass.getMethod("getScore", String.class));   //输出public int Student.getScore(java.lang.String) 

        // 获取继承的public方法getName，无参数:
        System.out.println(stdClass.getMethod("getName"));   //输出public java.lang.String Person.getName() 

        // 获取private方法getGrade，参数为int:
        System.out.println(stdClass.getDeclaredMethod("getGrade", int.class));  //输出private int Student.getGrade(int) 
    }
}

class Student extends Person {
    public int getScore(String type) {
        return 99;
    }
    private int getGrade(int year) {
        return 1;
    }
}
class Person {
    public String getName() {
        return "Person";
    }
}

一个Method对象包含一个方法的所有信息：

• getName()：返回方法名称，例如："getScore"；
• getReturnType()：返回方法返回值类型，也是一个Class实例，例如：String.class；
• getParameterTypes()：返回方法的参数类型，是一个Class数组，例如：{String.class, int.class}；
• getModifiers()：返回方法的修饰符，它是一个int，不同的bit表示不同的含义。

 

4.2、调用方法

对Method实例调用invoke就相当于调用该方法。invoke() 方法的返回值是一个 Object 对象，invoke() 的第一个参数是对象实例，即在哪个实例上调用该方法，后面的可变参数要与方法参数一致，否则将报错。如果方法没有参数，那么invoke也没有第二个参数。

public class Main {
    public static void main(String[] args) throws Exception {
        //下面相当于是操作了 String r = s.substring(6);  // "world" 

        String s = "Hello world";   
        Method m = String.class.getMethod("substring", int.class);  // 获取String substring(int)方法，参数为int:
        String r = (String) m.invoke(s, 6);  // 在s对象上调用该方法并获取结果   
        System.out.println(r);
    }
}

4.2.1、调用静态方法

如果获取到的Method表示一个静态方法，调用静态方法时，由于无需指定实例对象，所以invoke方法传入的第一个参数永远为null。我们以Integer.parseInt(String)为例：

import java.lang.reflect.Method;
public class Main {
    public static void main(String[] args) throws Exception {
        // 获取Integer.parseInt(String)方法，参数为String:
        Method m = Integer.class.getMethod("parseInt", String.class);
        // 调用该静态方法并获取结果:
        Integer n = (Integer) m.invoke(null, "12345");
        // 打印调用结果:
        System.out.println(n);
    }
}

4.2.2、调用非public方法

和Field类似，对于非public方法，我们虽然可以通过Class.getDeclaredMethod()获取该方法实例，但直接对其调用将得到一个IllegalAccessException。为了调用非public方法，我们通过Method.setAccessible(true)允许其调用：

import java.lang.reflect.Method;
public class Main {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        Method m = p.getClass().getDeclaredMethod("setName", String.class);
        m.setAccessible(true);
        m.invoke(p, "Bob");
        System.out.println(p.name);
    }
}

class Person {
    String name;
    private void setName(String name) {
        this.name = name;
    }
}

此外，setAccessible(true)可能会失败。如果JVM运行期存在SecurityManager，那么它会根据规则进行检查，有可能阻止setAccessible(true)。例如，某个SecurityManager可能不允许对java和javax开头的package的类调用setAccessible(true)，这样可以保证JVM核心库的安全。

 

4.3、多态

使用反射调用方法时，仍然遵循多态原则：即总是调用实际类型的覆写方法（如果存在）。

如下：Person类定义了hello()方法，并且它的子类Student也覆写了hello()方法，从Person.class获取的Method，作用于Student实例时，调用的是Student类的方法

import java.lang.reflect.Method;
public class Main {
    public static void main(String[] args) throws Exception {
        // 获取Person的hello方法:
        Method h = Person.class.getMethod("hello");
        // 对Student实例调用hello方法:
        h.invoke(new Student());   //输出Student:hello 
    }
}

class Person {
    public void hello() {
        System.out.println("Person:hello");
    }
}

class Student extends Person {
    public void hello() {
        System.out.println("Student:hello");
    }
}

 

5、通过反射调用构造方法创建类实例

我们可以通过 Class 提供的 newInstance() 方法来创建类的实例。但是 Class.newInstance() 只能调用该类的 public 无参数构造方法。如果构造方法带有参数，或者不是public，就无法直接通过Class.newInstance()来调用。

Person p = Person.class.newInstance();   //Class.newInstance()返回Object对象

 

为了调用任意的构造方法，Java的反射API提供了Constructor对象，它包含一个构造方法的所有信息，可以创建一个实例。

import java.lang.reflect.Constructor;
public class Main {
    public static void main(String[] args) throws Exception {
        // 获取构造方法Integer(int):
        Constructor cons1 = Integer.class.getConstructor(int.class);
        // 调用构造方法:
        Integer n1 = (Integer) cons1.newInstance(123);
        System.out.println(n1);

        // 获取构造方法Integer(String)
        Constructor cons2 = Integer.class.getConstructor(String.class);
        Integer n2 = (Integer) cons2.newInstance("456");
        System.out.println(n2);
    }
}

通过Class实例获取Constructor的方法如下：

• getConstructor(Class...)：获取某个public的Constructor；
• getDeclaredConstructor(Class...)：获取某个Constructor，可获取不是public修饰的构造函数，比如private修饰的；
• getConstructors()：获取所有public的Constructor；
• getDeclaredConstructors()：获取所有的Constructor，不只是public修饰的。

调用非public的Constructor时，必须首先通过 Class.setAccessible(true)设置允许访问，才能调用 Class.newInstance() 方法来创建实例，否则会报错。不过setAccessible(true)也可能会失败。

 

6、通过反射获取继承关系

6.1、获取父类的Class实例

通过Class实例，我们可以获取该实例 Class 实例的类的父类的 Class 实例：

public class Main {
    public static void main(String[] args) throws Exception {
        Class i = Integer.class;
        Class n = i.getSuperclass();   //class java.lang.Number
        System.out.println(n);
        Class o = n.getSuperclass();  //class java.lang.Object
        System.out.println(o);
        System.out.println(o.getSuperclass());  //null
    }
}

运行上述代码，可以看到，Integer的父类类型是Number，Number的父类是Object，Object的父类是null。除Object外，其他任何非interface的Class都必定存在一个父类类型。

对所有interface的Class调用getSuperclass()返回的是null，获取接口的父接口要用getInterfaces()

 

6.2、获取该类实现的接口interface

由于一个类可能实现一个或多个接口，通过Class的getInterfaces()方法我们就可以查询到实现的接口类型。如果一个类没有实现任何interface，那么getInterfaces()返回空数组。

例如，查询Integer实现的接口：

import java.lang.reflect.Method;
public class Main {
    public static void main(String[] args) throws Exception {
        Class s = Integer.class;
        Class[] is = s.getInterfaces();
        for (Class i : is) {
            System.out.println(i);  //interface java.lang.Comparable   interface java.lang.constant.Constable       interface java.lang.constant.ConstantDesc
        }
    }
}

getInterfaces()只返回当前类直接实现的接口类型，并不包括其父类实现的接口类型。

 

6.3、根据Class实例判断类是否可向上转型（isAssignableFrom()） 

根据两个Class实例要判断类的向上转型是否成立，可以调用isAssignableFrom()

// Integer i = ?
Integer.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Integer
// Number n = ?
Number.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Number
// Object o = ?
Object.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Object
// Integer i = ?
Integer.class.isAssignableFrom(Number.class); // false，因为Number不能赋值给Integer

 

7、动态加载

JVM在执行Java程序的时候，并不是一次性把所有用到的class全部加载到内存，而是第一次需要用到class时才加载。例如：

// Main.java
public class Main {
    public static void main(String[] args) {
        if (args.length > 0) {
            create(args[0]);
        }
    }

    static void create(String name) {
        Person p = new Person(name);
    }
}

当执行Main.java时，由于用到了Main，因此，JVM首先会把Main.class加载到内存。然而，并不会加载Person.class，除非程序执行到create()方法，JVM发现需要加载Person类时，才会首次加载Person.class。如果没有执行create()方法，那么Person.class根本就不会被加载。这就是JVM动态加载class的特性。

动态加载class的特性对于Java程序非常重要。利用JVM动态加载class的特性，我们才能在运行期根据条件加载不同的实现类。

 

8、动态代理

运用Java的动态代理，可以在每个类中的执行方法前后进行一些统一的操作，由此可以不必修改每个类中的每个方法。

比如下面： 我们先写一个被代理对象的接口和实现类。接口是Bird (鸭子是鸟类的一种)，被代理的实现类是鸭子Duck

//接口
public interface Bird {
    String name="bird";
    public void say();
}

//实现类
public class Duck implements Bird {
    @Override
    public void say() {
        System.out.println("鸭子。。。");
    }
}

再写一个鸭子的代理类。需要注意4点：
a. 代理类需实现 InvocationHandler 接口。

b.代理类有一个Object的属性，通过构造器注入被代理对象。

c. 在代理类里面的invoke方法进行对被代理对象的调用，及调用前后的额外处理（你想在调用前后干啥就干啥呗）。

d.写一个获取代理对象的get方法，方便获取代理对象。这个代理对象执行被代理对象的方法时，会执行invoke方法。

public class DuckProxy implements InvocationHandler {
    private Object duckObject;
    public DuckProxy(Object duckObject) {
        this.duckObject = duckObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //在代理真实对象前我们可以添加一些自己的操作
        System.out.println("方法执行之前的操作");

        System.out.println("Method:" + method);
        Object returnValue = method.invoke(duckObject, args);   //执行增强后的方法，returnValue即为真实对象执行方法的返回值。当通过代理对象来调用真实对象的方法时，会自动地跳转到代理对象关联的handler对象的invoke方法来进行调用

        //在代理真实对象后我们也可以添加一些自己的操作
        System.out.println("方法执行之后的操作");
        return returnValue;
    }

    public Object getDuckProxy(){
        return Proxy.newProxyInstance(duckObject.getClass().getClassLoader(), duckObject.getClass().getInterfaces(), this);
    }
}

测试运行：

//依次输出：  方法执行之前的操作  Method:public abstract void proxyTest.Bird.say()   鸭子。。。   方法执行之后的操作
public class Test{
    public static void main(String[] args){
        Bird bird = new Duck();
        Bird proxy = (Bird)new DuckProxy(bird).getDuckProxy();  //拿到代理对象
        proxy.say();
    }
}

 

8.1、动态代理直接在运行期创建接口实例

我们可以通过Java标准库提供的动态代理（Dynamic Proxy）的机制，在运行期动态创建某个接口interface的实例。这样就可以不用编写接口的实现类，直接在运行期创建接口的实例然后调用接口的方法。

如下：我们仍然先定义了接口Hello，但是我们并不去编写实现类，而是直接通过JDK提供的一个Proxy.newProxyInstance()创建了一个Hello接口对象。这种没有实现类但是在运行期动态创建了一个接口对象的方式，我们称为动态代码。JDK提供的动态创建接口对象的方式，就叫动态代理。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Main {
    public static void main(String[] args) {
        InvocationHandler handler = new InvocationHandler() {   //定义一个InvocationHandler实例
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method);
                if (method.getName().equals("morning")) {
                    System.out.println("Good morning, " + args[0]);
                }
                return null;
            }
        };
        Hello hello = (Hello) Proxy.newProxyInstance(   //创建interface实例
            Hello.class.getClassLoader(), // 传入ClassLoader
            new Class[] { Hello.class }, // 传入要实现的接口
            handler                     // 传入处理调用方法的InvocationHandler
        ); 

        hello.morning("Bob");
        hello.say();
    }
}

interface Hello {
    void morning(String name);
    void say();
}

在运行期动态创建一个interface实例的方法如下：

1. 先定义一个InvocationHandler实例，它负责实现接口的方法调用；
2. 通过Proxy.newProxyInstance()创建interface实例，它需要3个参数：
   1. 使用的ClassLoader，通常就是接口类的ClassLoader；
   2. 需要实现的接口数组，至少需要传入一个接口进去；
   3. 用来处理接口方法调用的InvocationHandler实例。
3. 将Proxy.newProxyInstance()返回的Object强制转型为接口。

动态代理实际上是JDK在运行期动态创建class字节码并加载的过程，其实就是JDK帮我们自动编写了一个类（不需要源码，可以直接生成字节码），并不存在可以直接实例化接口的黑魔法。