廖雪峰java教程学习笔记—

反射 Reflection

Java的反射是指程序在运行期可以拿到一个对象的所有信息。

它更多地是给工具或者底层框架来使用，目的是在不知道目标实例任何信息的情况下，获取特定字段的值。

Class类

每加载一种class，JVM就为其创建一个Class类型的实例，并关联起来。注意：这里的Class类型是一个名叫Class的class：：

java">public final class Class {
    private Class() {}
}

Class 是一种特殊的类，用来描述各种类信息。

对于未知的类，想知道它到底是谁，就用到了反射：

java">void printObjectInfo(Object obj) {
    Class cls = obj.getClass();  //能知道obj到底是个啥
}

获取Class实例的方法

直接通过一个类的静态变量class获取：Class cls = String.class;
用一个实例的getClass()方法获取：Class cls = s.getClass();
通过静态方法Class.forName()获取：Class cls = Class.forName("java.lang.String");

Class实例在JVM中是唯一的，Class之间可以用==比较。

Class == 与 instanceof的区别

instanceof能匹配到父类；

Class之间的==只能精确匹配本身；

因为通常是面向抽象编程，所以一般用instanceof比较即可。

java">Integer n = new Integer(123);

boolean b1 = n instanceof Integer; // true，因为n是Integer类型
boolean b2 = n instanceof Number; // true，因为n是Number类型的子类

boolean b3 = n.getClass() == Integer.class; // true，因为n.getClass()返回Integer.class
boolean b4 = n.getClass() == Number.class; // false，因为Integer.class!=Number.class

动态加载 + 反射一种用法

JVM会第一次用到某个class时，才把它加载到内存。这样就能在运行期根据条件加载不同的实现类。

例如Commons Logging优先加载Log4j的代码大概如下：

java">// Commons Logging优先使用Log4j:
LogFactory factory = null;
if (isClassPresent("org.apache.logging.log4j.Logger")) {
    factory = createLog4j();
} else {
    factory = createJdkLog();
}

boolean isClassPresent(String name) {
    try {
        Class.forName(name);  //类名存在
        return true;
    } catch (Exception e) {
        return false;
    }
}

访问字段

如下方法可以获取类中的字段信息：

java">Field getField(name)：根据字段名获取某个public的field（包括父类）
Field getDeclaredField(name)：根据字段名获取当前类的某个field，包括private（不包括父类）
Field[] getFields()：获取所有public的field（包括父类）
Field[] getDeclaredFields()：获取当前类的所有field，包括private（不包括父类）

例如：

java">        Class stdClass = Student.class;
        stdClass.getField("score");        //返回 public int Student.score
        stdClass.getDeclaredField("grade");  //返回 private int Student.grade，它能访问到private字段

对于一个实例，还能获取值或设置值，必须调用setAccessible()才能正常读写private字段：

java">package oop_package.src.com.itranswarp.sample;
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);  //允许访问private字段
        Object value = f.get(p);
        System.out.println(value); // "Xiao Ming"
        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;
    }
}

学到了一种能破坏类封装性的方法。

调用方法

可以通过Class实例获取所有Method信息：

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

java">// reflection
import java.lang.reflect.Method;
public class Main {
    public static void main(String[] args) throws Exception {
        // String对象:
        String s = "Hello world";
        // 获取String substring(int)方法，参数为int:
        Method m = String.class.getMethod("substring", int.class);
        // 在s对象上调用该方法并获取结果:
        String r = (String) m.invoke(s, 6);
        // 打印调用结果:
        System.out.println(r);
    }
}

Method对象可以用invoke()方法调用其指向的方法。注意：对于重载函数要精确指定其参数。

通过设置setAccessible(true)来访问非public方法；

通过反射调用方法时，仍然遵循多态原则。

调用构造方法

class.newInstance();只能调用该类的public 无参数构造方法：

java">Person p = Person.class.newInstance();

为了调用含任意参数的构造方法，Java的反射API提供了Constructor对象：

java">        // 获取构造方法Integer(int):
        Constructor cons1 = Integer.class.getConstructor(int.class);
        // 调用构造方法:
        Integer n1 = (Integer) cons1.newInstance(123);
        System.out.println(n1);

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

java">getConstructor(Class...)：获取某个public的Constructor；
getDeclaredConstructor(Class...)：获取某个Constructor；
getConstructors()：获取所有public的Constructor；
getDeclaredConstructors()：获取所有Constructor。

获取父类

用getSuperclass()接口能获取到父类，一层层追溯到Object对象后，其父类为null。

java">        Class i = Integer.class;
        Class n = i.getSuperclass();

获取interface

用getInterfaces()接口能获取到实现的接口。实现的接口可能有多个，返回一个Class数组。

java">        Class s = Integer.class;
        Class[] is = s.getInterfaces();
        for (Class i : is) {
            System.out.println(i);
        }

判断继承关系

用instanceof操作符能判断是否是父子关系；

用isAssignableFrom()可以判断能否向上转型：

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

动态代理 Dynamic Proxy

接口本来是不能直接用的，必须由类实现后，向上转型指向某个实例才能用。

为了能直接用接口，JDK提供的动态创建接口对象的方式，即动态代理。

是通过Proxy创建代理对象，然后将接口方法“代理”给InvocationHandler完成的。

java">package oop_package.src.com.itranswarp.sample;

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() {
            @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(
            Hello.class.getClassLoader(), // 传入ClassLoader
            new Class[] { Hello.class }, // 传入要实现的接口
            handler); // 传入处理调用方法的InvocationHandler
        hello.morning("Bob");
    }
}

interface Hello {
    void morning(String name);
}

打印：

java">public abstract void oop_package.src.com.itranswarp.sample.Hello.morning(java.lang.String)
Good morning, Bob

等效于通常静态实现方式：

java">public class HelloDynamicProxy implements Hello {
    InvocationHandler handler;
    public HelloDynamicProxy(InvocationHandler handler) {
        this.handler = handler;
    }
    public void morning(String name) {
        handler.invoke(
           this,
           Hello.class.getMethod("morning", String.class),
           new Object[] { name });
    }
}