java反射

June 19, 2022

扩展阅读 https://zhuanlan.zhihu.com/p/32286740

Class 对象

Java 原始类型： char、boolean、byte、short、int、long、float、double
Java 中除了原始类型之外的所有的一切类型都是对象（引用类型）。

反射就是在运行时获取对象类型（而不是对象实例，可以说是类）信息的 API 。注意：反射 API 也可以获取基本类型（原始类型）的信息（另外，Java 数组也是对象）。

使用时需导入 import java.lang.reflect.*;

对于每一个对象类型（类），jvm 都在加载时为其创建对应的 Class<T> 对象
只有 jvm 才可以构造这个 Class 对象，因为构造函数被修饰为 private ：private Class(...)
获取这个对象的方法有三种：

java

// 从类型上获取
Class<String> cls = String.class;

// 从实例对象上获取，注意 "Hello" 在这里是 String 类型
Class<String> cls = "Hello".getClass();

// 利用反射API，通过完整类名获取
Class<String> cls = Class.forName("java.lang.String");

很明显，上面前两种方法是继承了 Object 。
特殊的是，基本类型（原始类型）也有对应的 Class，
数组类型也有对应的 Class，例如 String[]，它的类名是[Ljava.lang.String。
然而由于 Java 泛型参数不能是原始类型，看起来 int.class 和 Integer.class 的类型都是相同的，实际上还是不同的

java

Class<Integer> cls1 = int.class;
Class<Integer> cls2 = Integer.class;
System.out.println(cls1 == cls2); // false

// 也可以
Class<?> cls = int.class;
// 或者
var cls = int.class;

Class<T> 类的具体方法，参阅 Java8 文档https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html
下面参考https://www.liaoxuefeng.com/wiki/1252599548343744/1255945147512512
简略描述一下 Class<T> 类的一些公开方法，具体内容参见文档

Field 对象

获取 Field 对象

java

/*...*/ class Class<T> /*...*/ {
    // 获取公开字段，包括继承字段
    public Field getField(String name) throws NoSuchFieldException, SecurityException;
    // 获取所有非继承字段
    public Field getDeclaredField(String name) throws NoSuchFieldException, SecurityException;
    public Field[] getFields() throws SecurityException;
    public Field[] getDeclaredFields() throws SecurityException;
}

Field 类

java

class Field /*...*/ {
    public void setAccessible(boolean flag);
    public String getName(); // 返回字段名称
    public Class<?> getDeclaringClass(); // 返回字段对应Class

    public Class<?> getType(); // 返回字段类型对应Class
    public int getModifiers();  // 返回字段类型对应Java语言修饰符，配合Modifier类使用

    public Object get(Object obj); // 获取字段在指定实例对象上的值
    public /*boolean|byte|char|short|int|long|float|double*/ get/*Boolean|Byte|Char|Short|Int|Long|Float|Double*/(Object obj);
    // e.g. public boolean getBoolean(Object obj) throws IllegalArgumentException, IllegalAccessException;

    public void set(Object obj, Object value);// 设置字段在指定实例对象上的值为给定值
    public void set/*Boolean|Byte|Char|Short|Int|Long|Float|Double*/(Object obj, /*boolean|byte|char|short|int|long|float|double*/ x);
    // e.g. public void setBoolean(Object obj, boolean z);

    public <T extends Annotation> T getAnnotation(Class<T> annotationClass);
    public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass);
    public Annotation[] getDeclaredAnnotations();
    public AnnotatedType getAnnotatedType();
}

演示

java

Field f = String.class.getDeclaredField("value");
f.setAccessible(true); // 设置允许访问非public字段
f.getName(); // "value"
f.getType(); // class [B 表示byte[]类型
int m = f.getModifiers();
Modifier.isFinal(m); // true
Modifier.isPublic(m); // false
Modifier.isProtected(m); // false
Modifier.isPrivate(m); // true
Modifier.isStatic(m); // false

https://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Field.html

Method 对象

获取 Method 对象

java

/*...*/ class Class<T> /*...*/ {
    // 通过方法名及参数类型获取方法
    public Method getMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException;
    public Method getDeclaredMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException;
    public Method[] getMethods() throws SecurityException;
    public Method[] getDeclaredMethods() throws SecurityException;
}

Method 类

java

public final class Method extends Executable {
    public void setAccessible(boolean flag);
    public String getName();
    public int getModifiers();
    public Class<?> getReturnType();
    public Class<?>[] getParameterTypes();
    public int getParameterCount();
    public Class<?>[] getExceptionTypes();
    // invoke的第一个参数是对象实例，即在哪个实例上调用该方法（相当于js的Function.prototype.call）
    public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException;
}

Constructor 对象，调用构造方法

java

// deprecated
try {
    String str = String.class.newInstance();
} catch (Exception e) {
    e.printStackTrace();
}

获取 Constructor 类

java

/*...*/ class Class<T> /*...*/ {
    public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException;
    public Constructor<?>[] getConstructors() throws SecurityException;
}

Constructor 类

java

public final class Constructor<T> extends Executable {
    public void setAccessible(boolean flag);
    public T newInstance(Object ... initargs);
    // 判断cls是否继承当前类（如果cls可以assign为当前类，则cls可以向上转型为当前类。也就是说，这个方法判断cls能否向上转型为当前类）
    public native boolean isAssignableFrom(Class<?> cls);
}

演示

java

try {
    Constructor<Integer> cons = Integer.class.getConstructor(int.class);
    Integer n = (Integer) cons.newInstance(123);
    System.out.println(n); // 123
} catch (Exception e) {
    e.printStackTrace();
}

获取继承关系

java

/*...*/ class Class<T> /*...*/ {
    // 获取父类的Class
    public native Class<? super T> getSuperclass();
    // 获取所有implement的interface的Class（不包括父类interface）
    public Class<?>[] getInterfaces();
}

Proxy

Java 中的 Proxy 用于在运行期动态创建某个 interface 的实例
example

java

import java.lang.reflect.*;

public class Main {
    public static void main(String[] args) {
        // 1.构造调用处理器对象
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if (method.getName() == "morning") {
                    System.out.println("Good morning, " + args[0]);
                }
                return null;
            }
        };

        // 2.构造代理对象
        Hello hello = (Hello) Proxy.newProxyInstance(
                Hello.class.getClassLoader(), // 传入ClassLoader
                new Class[] { Hello.class }, // 传入要实现的接口
                handler); // 传入处理调用方法的InvocationHandler

        // 3.调用代理对象的方法
        hello.morning("Bob");
    }
}

// 接口定义
interface Hello {
    void morning(String name);
}

关系

扩展阅读https://zhuanlan.zhihu.com/p/64584427

java

public final class Class<T> implements java.io.Serializable,
                              GenericDeclaration,
                              Type,
                              AnnotatedElement,
                              TypeDescriptor.OfField<Class<?>>,
                              Constable

public interface ParameterizedType extends Type
public interface GenericArrayType extends Type
public interface WildcardType extends Type

public class AccessibleObject implements AnnotatedElement

public final class Field extends AccessibleObject
    implements Member

public abstract sealed class Executable extends AccessibleObject
    implements Member, GenericDeclaration permits Constructor, Method

public final class Method extends Executable
public final class Constructor<T> extends Executable



                      ┌────┐
                      │Type│
                      └────┘
                         ▲
                         │
   ┌────────────┬────────┴─────────┬───────────────┐
   │            │                  │               │
┌─────┐┌─────────────────┐┌────────────────┐┌────────────┐
│Class││ParameterizedType││GenericArrayType││WildcardType│
└─────┘└─────────────────┘└────────────────┘└────────────┘


┌────────────────┐
│AccessibleObject│
└────────────────┘
        ▲
        │
   ┌─────────┐
   │         │
┌─────┐┌──────────┐
│Field││Executable│
└─────┘└──────────┘
            ▲
            │
       ┌──────────┐
       │          │
    ┌──────┐┌───────────┐
    │Method││Constructor│
    └──────┘└───────────┘

←Back to home