Java 反射 攻略

复制粘贴改改改
99 阅读10分钟

攻略大全

1. 粘贴攻略

一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的，并且能够获得此类的引用。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作。

反射则是一开始并不知道我们要初始化的类对象是什么，自然也无法使用 new 关键字来创建对象了。这时候，我们使用 JDK 提供的反射 API 进行反射调用。反射就是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;并且能改变它的属性。 这也是Java被视为动态语言的关键。

反射机制很重要的一点就是“运行时”，其使得我们可以在程序运行时加载、探索以及使用编译期间完全未知的 .class 文件。换句话说，Java 程序可以加载一个运行时才得知名称的 .class 文件，然后获悉其完整构造，并生成其对象实体、或对其 fields（变量）设值、或调用其 methods（方法）。

Java反射机制主要提供了以下功能:

  • 在运行时构造任意一个类的对象
  • 在运行时获取或者修改任意一个类所具有的成员变量和方法
  • 在运行时调用任意一个对象的方法(属性)

1.1 Class

反射始于Class，Class是一个类，封装了当前对象所对应的类的信息。一个类中有属性，方法，构造器等，比如说有一个Person类，一个Order类，一个Book类，这些都是不同的类，现在需要一个类，用来描述类，这就是 Class ，它应该有类名，属性，方法，构造器等。

Class是用来描述类的类。

Class类是一个对象照镜子的结果，对象可以看到自己有哪些属性，方法，构造器，实现了哪些接口等等。对于每 个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个类的有关信息。 对象只能由系统建立对象，一个类(而不是一个对象)在 JVM 中只会有一个Class实例。

1.2 获得Class对象

获取Class对象的三种方式

  1. 通过类名获取:类名.class

    Class<?> klass = int.class;
Class<?> classInt = Integer.TYPE;

  2. 通过对象获取:对象名.getClass()

    StringBuilder str = new StringBuilder("123");
Class<?> klass = str.getClass();

  3. 通过全类名获取: Class.forName(全类名) classLoader.loadClass(全类名)

    public static Class<?> forName(String className)

public Class<?> loadClass(String name)

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

一般地，我们用 instanceof 关键字来判断是否为某个类的实例。同时我们也可以借助反射中 Class 对象的 isInstance() 方法来判断是否为某个类的实例:

public native boolean isInstance(Object obj)

判断是否为某个类的类型:

public boolean isAssignableFrom(Class<?> cls)

1.4 创建实例

  • 使用Class对象的newInstance()方法来创建Class对象对应类的实例:
Class<?> c = String.class;
Object str = c.newInstance();
  • 先通过Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建实例：
// 获取String所对应的Class对象
Class<?> c = String.class; 
// 获取String类带一个String参数的构造器
Constructor constructor = c.getConstructor(String.class); 
// 根据构造器创建实例
Object obj = constructor.newInstance("23333");
System.out.println(obj);

1.5 获取构造器信息

// 获得使用特定的参数类型的public构造函数(包括父类)
Constructor getConstructor(Class[] params)

// 获得所有public构造函数(包括父类)
Constructor[] getConstructors()

// 获得本类使用特定参数类型的构造函数(包括私有)
Constructor getDeclaredConstructor(Class[] params) 

// 获得本类的所有构造函数(包括私有)
Constructor[] getDeclaredConstructors()

获取类构造器的用法与上述获取方法的用法类似。主要是通过Class类的getConstructor方法得到Constructor类的 一个实例，而Constructor类有一个newInstance方法可以创建一个对象实例:

public T newInstance(Object ... initargs)

1.6 获取类的成员变量(字段)信息

获得字段信息的方法:

// 获得指定的public字段(包括父类)
Field getField(String name) 

// 获得所有public字段(包括父类)
Field[] getFields() 

// 获得指定的本类声明的字段 (包括private)
Field getDeclaredField(String name) 

// 获得本类声明的所有字段(包括private)
Field[] getDeclaredFields()

1.7 调用方法

获得方法信息的方法：

// 使用特定的参数类型，获得指定的public方法
Method getMethod(String name, Class[] params) 

// 获得类的所有public方法
Method[] getMethods() 

// 使用特定的参数类型，获得本类声明的方法
Method getDeclaredMethod(String name, Class[] params)   

// 获得本类声明的所有方法
Method[] getDeclaredMethods()

当我们从类中获取了一个方法后，我们就可以用 invoke() 方法来调用这个方法。 invoke 方法的原型为:

public Object invoke(Object obj, Object... args)

1.8 利用反射创建数组

数组在Java里是比较特殊的一种类型，它可以赋值给一个Object Reference 其中的Array类为java.lang.reflect.Array类。我们通过Array.newInstance()创建数组对象，它的原型是:

public static Object newInstance(Class<?> componentType, int length);

1.9 反射获取泛型真实类型

当我们对一个泛型类进行反射时，需要的到泛型中的真实数据类型，来完成如json反序列化的操作。此时需要通 过 Type 体系来完成。 Type 接口包含了一个实现类(Class)和四个实现接口，他们分别是:

  • TypeVariable

    泛型类型变量，可以获得泛型上下限等信息。

  • ParameterizedType

    具体的泛型类型，可以获得元数据中泛型签名类型(泛型真实类型) 。

  • GenericArrayType

    当需要描述的类型是泛型类的数组时，比如List[]、Map[]，此接口会作为Type的实现。

  • WildcardType

    通配符泛型，获得上下限信息。

1.9.1 TypeVariable

public class TestType <K extends Comparable & Serializable, V> {
    K key;
    V value;
    public static void main(String[] args) throws Exception {

        // 获取字段
        Field fk = TestType.class.getDeclaredField("key"); 
        Field fv = TestType.class.getDeclaredField("value");

        // 获取字段相关信息
        TypeVariable keyType = (TypeVariable)fk.getGenericType(); 
        TypeVariable valueType =(TypeVariable)fv.getGenericType();

        // getName 方法
        // K 
        System.out.println(keyType.getName());
        // V
        System.out.println(valueType.getName());

        // getGenericDeclaration 方法 
        // class com.test.TestType
        System.out.println(keyType.getGenericDeclaration());
        // class com.test.TestType
        System.out.println(valueType.getGenericDeclaration());

        // getBounds 方法
        System.out.println("K 的上界:");
        for (Type type : keyType.getBounds()) {
            System.out.println(type);
            // 有两个
            // interface java.lang.Comparable
            // interface java.io.Serializable
        }
        System.out.println("V 的上界:");
        for (Type type : valueType.getBounds()) {
            System.out.println(type);
            // 没明确声明上界的, 默认上界是 Object
            // class java.lang.Object
        }
    } 
}

1.9.2 ParameterizedType

public class TestType {
    Map<String, String> map;
    public static void main(String[] args) throws Exception {
        Field f = TestType.class.getDeclaredField("map");
        System.out.println(f.getGenericType());// java.util.Map<java.lang.String,
java.lang.String>
        ParameterizedType pType = (ParameterizedType) f.getGenericType();
        System.out.println(pType.getRawType());// interface java.util.Map
        for (Type type : pType.getActualTypeArguments()) {
            System.out.println(type); // 打印两遍: class java.lang.String 
        }
    } 
}

1.9.3 GenericArrayType

public class TestType<T> {
    List<String>[] lists;
    public static void main(String[] args) throws Exception {
        Field f = TestType.class.getDeclaredField("lists");
        GenericArrayType genericType = (GenericArrayType) f.getGenericType();
        System.out.println(genericType.getGenericComponentType());
    } 
}

1.9.4 WildcardType

public class TestType {

private List<? extends Number> a; // 上限 
private List<? super String> b; //下限

public static void main(String[] args) throws Exception { 

    Field fieldA = TestType.class.getDeclaredField("a");
    Field fieldB = TestType.class.getDeclaredField("b"); 

    // 先拿到范型类型
    ParameterizedType pTypeA = (ParameterizedType) fieldA.getGenericType(); 
    ParameterizedType pTypeB = (ParameterizedType) fieldB.getGenericType(); 

    // 再从范型里拿到通配符类型
    WildcardType wTypeA = (WildcardType) pTypeA.getActualTypeArguments()[0];
    WildcardType wTypeB = (WildcardType) pTypeB.getActualTypeArguments()[0]; 

    // 方法测试
    System.out.println(wTypeA.getUpperBounds()[0]); // class java.lang.Number 
    System.out.println(wTypeB.getLowerBounds()[0]); // class java.lang.String 

    // 看看通配符类型到底是什么, 打印结果为: ? extends java.lang.Number
    System.out.println(wTypeA);
    }

}

1.9.5 Gson反序列化

// 为什么TypeToken要定义为抽象类?
Response<Data> resp = gson.fromJson(json, new TypeToken<Response<Data>>() { }.getType());
System.out.println(resp.data.result);

在进行GSON反序列化时，存在泛型时，可以借助 TypeToken 获取Type以完成泛型的反序列化。但是为什么 TypeToken 要被定义为抽象类呢?

因为只有定义为抽象类或者接口，这样在使用时，需要创建对应的实现类，此时确定泛型类型，编译才能够将泛型 signature信息记录到Class元数据中。

2 造火箭攻略

2.1 反射修改私有常量

2.1.1 常规反射修改是无意义的

常量是指使用 final 修饰符修饰的成员属性，与变量的区别就在于有无 final 关键字修饰。

编译器在编译 .java 文件得到 .class 文件时，会优化我们的代码以提升效率。其中一个优化就是：在编译阶段会把引用常量的代码替换成具体的常量值，如下所示（部分代码）。

编译前的 .java 文件：

//注意是 String  类型的值
private final String FINAL_VALUE = "hello";

if(FINAL_VALUE.equals("world")){
    //do something
}

编译后得到的 .class 文件（当然，编译后是没有注释的）：

private final String FINAL_VALUE = "hello";
//替换为"hello"
if("hello".equals("world")){
    //do something
}

但是，并不是所有常量都会优化。经测试对于 int 、long 、boolean这些基本类型以及 String 会被编译器优化，而对于 Integer 、Long 、Boolean 这种包装类型，或者其他诸如 Date 、Object 类型则不会被优化。

总结来说：对于基本类型的静态常量，编译器在编译阶段会把引用此常量的代码替换成具体的常量值。

虽然在程序运行时刻依然可以使用反射修改常量的值，但是在编译阶段得到的 .class 文件已经将常量优化为具体的值，在运行阶段会直接使用具体的值。在这种情况下，即使修改常量的值也已经毫无意义。

2.1.2 有意义修改的技巧：逃过编译期的代码优化

2.1.2.1 方法一 构造函数中赋值常量

public class TestClass {

    //......
    private final String FINAL_VALUE;
    
    //构造函数内为常量赋值 
    public TestClass(){
        this.FINAL_VALUE = "FINAL";
    }
    //......
}

将赋值放在构造函数中，构造函数是我们运行时 new 对象才会调用的，所以就不会像之前直接为常量赋值那样，在编译阶段将 getFinalValue() 方法优化为返回常量值，而是指向 FINAL_VALUE ，这样我们在运行阶段通过反射修改常量的值就有意义啦。

2.1.2.2 方法二 三元表达式赋值

private final String FINAL_VALUE
        = null == null ? "FINAL" : null;

其实，上述代码等价于直接为 FINAL_VALUE 赋值 "FINAL"，但是他就是可以！至于为什么，你这么想：null == null ? "FINAL" : null 是在运行时刻计算的，在编译时刻不会计算，也就不会被优化，所以你懂的。

2.2 反射的优缺点

2.2.1 增加程序的灵活性

面对需求变更时，可以灵活地实例化不同对象。

2.2.2 破坏类的封装性

反射可以获取类中被private修饰的变量、方法和构造器，这违反了面向对象的封装特性，因为被 private 修饰意味着不想对外暴露，只允许本类访问，而setAccessable(true)可以无视访问修饰符的限制，外界可以强制访问。

2.2.3 性能损耗

在直接 new 对象并调用对象方法和访问属性时，编译器会在编译期提前检查可访问性，如果尝试进行不正确的访问，IDE会提前提示错误，例如参数传递类型不匹配，非法访问 private 属性和方法。

而在利用反射操作对象时，编译器无法提前得知对象的类型，访问是否合法，参数传递类型是否匹配。只有在程序运行时调用反射的代码时才会从头开始检查、调用、返回结果，JVM也无法对反射的代码进行优化。

虽然反射具有性能损耗的特点，但是我们不能一概而论，产生了使用反射就会性能下降的思想，反射的慢，需要同时调用上100W次才可能体现出来，在几次、几十次的调用，并不能体现反射的性能低下。所以不要一味地戴有色眼镜看反射，在单次调用反射的过程中，性能损耗可以忽略不计。如果程序的性能要求很高，那么尽量不要使用反射。

3. 拧螺丝攻略

4. 复制攻略

4.1《Java编程思想》

4.2《Effective Java》

avatar
文章
阅读
粉丝