java反射学习

发表于 | 分类于
字数统计: 3.9k word | 阅读时长 ≈ 15 min
简介
  • 定义：Java语言中 一种 动态（运行时）访问、检测 & 修改它本身的能力
  • 作用：动态（运行时）获取 类的完整结构信息 & 调用对象的方法（类的结构信息包括：变量、方法等）
特点
优点

灵活性高。因为反射属于动态编译，即只有到运行时才动态创建 &获取对象实例。

  1. 静态编译：在编译时确定类型 & 绑定对象。如常见的使用new关键字创建对象
  2. 动态编译：运行时确定类型 & 绑定对象。动态编译体现了Java的灵活性、多态特性 & 降低类之间的藕合性
缺点

  • 执行效率低

    因为反射的操作 主要通过JVM执行，所以时间成本会 高于 直接执行相同操作

因为接口的通用性，Java的invoke方法是传object和object[]数组的。基本类型参数需要装箱和拆箱，产生大量额外的对象和内存开销，频繁促发GC。

编译器难以对动态调用的代码提前做优化，比如方法内联。

反射需要按名检索类和方法，有一定的时间开销。

  • 容易破坏类结构
    因为反射操作饶过了源码，容易干扰类原有的内部逻辑
应用场景
  • 动态获取 类文件结构信息（如变量、方法等 & 调用对象的方法
  • 常用的需求场景有：动态代理、工厂模式优化、Java JDBC数据库操作等
使用
反射能干啥？

反射的实现主要是通过操作 java.lang.Class 类，因此来学一下这个类

java.lang.Class 类
  • 定义：java.lang.Class类是反射机制的基础
  • 作用：存放着对应类型对象的 运行时信息
  1. 在Java程序运行时，Java虚拟机为所有 类型 维护一个java.lang.Class对象
  2. 该Class对象存放着所有关于该对象的 运行时信息
  3. 泛型形式为Class<T>

看下面一段代码，对于2个String类型对象，它们的Class对象相同：

1
2
3
Class c1 = "hello".getClass();
Class c2 = Class.forName("java.lang.String");  //Class.forName()返回与给定的字符串名称相关联类或接口的Class对象。
System.out.println(c1 == c2); // true

结论：每种类型的Class对象只有1个 = 地址只有1个

其他类
  • Java反射机制的实现除了依靠Java.lang.Class类，还需要依靠：Constructor类、Field类、Method类，分别作用于类的各个组成部分：

使用步骤

在使用Java反射机制时，主要步骤包括：

  1. 获取目标类型的Class对象
  2. 通过 Class 对象分别获取Constructor类对象、Method类对象 & Field 类对象
  3. 通过 Constructor类对象、Method类对象 & Field类对象分别获取类的构造函数、方法&属性的具体信息，并进行后续操作
步骤1：获取目标类型的Class对象

获取目标类型的Class对象的方式主要有4种:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<-- 方式1：Object.getClass() -->
  
    // Object类中的getClass()返回一个Class类型的实例 
    Boolean carson = true; 
    Class<?> classType = carson.getClass(); 
    System.out.println(classType);
    // 输出结果：class java.lang.Boolean  

<-- 方式2：T.class 语法    -->
  
    // T = 任意Java类型
    Class<?> classType = Boolean.class; 
    System.out.println(classType);
    // 输出结果：class java.lang.Boolean  
    // 注：Class对象表示的是一个类型，而这个类型未必一定是类
    // 如，int不是类，但int.class是一个Class类型的对象

<-- 方式3：static method Class.forName   -->
  
    Class<?> classType = Class.forName("java.lang.Boolean"); 
    // 使用时应进行异常处理
    System.out.println(classType);
    // 输出结果：class java.lang.Boolean  

<-- 方式4：TYPE语法  -->

    Class<?> classType = Boolean.TYPE; 
    System.out.println(classType);
    // 输出结果：boolean
步骤2：通过 Class 对象分别获取Constructor类对象、Method类对象 & Field 类对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
// 即以下方法都属于`Class` 类的方法。

<-- 1. 获取类的构造函数（传入构造函数的参数类型）->>
  // a. 获取指定的构造函数 （公共 / 继承）
  Constructor<T> getConstructor(Class<?>... parameterTypes)
  // b. 获取所有的构造函数（公共 / 继承） 
  Constructor<?>[] getConstructors(); 
  // c. 获取指定的构造函数 （ 不包括继承）
  Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 
  // d. 获取所有的构造函数（ 不包括继承）
  Constructor<?>[] getDeclaredConstructors(); 
// 最终都是获得一个Constructor类对象

// 特别注意：
  // 1. 不带 "Declared" 的方法支持取出包括继承、公有（Public） & 不包括私有（Private）的构造函数
  // 2. 带 "Declared"的方法是支持取出包括公共（Public）、保护（Protected）、默认（包）访问和私有（Private）的构造方法，但不包括继承的构造函数
  // 下面同理

<--  2. 获取类的属性（传入属性名） -->
  // a. 获取指定的属性（公共 / 继承）
   Field getField(String name) ;
  // b. 获取所有的属性（公共 / 继承）
   Field[] getFields() ;
  // c. 获取指定的所有属性 （不包括继承）
   Field getDeclaredField(String name) ；
  // d. 获取所有的所有属性 （不包括继承）
   Field[] getDeclaredFields() ；
// 最终都是获得一个Field类对象

<-- 3. 获取类的方法（传入方法名 & 参数类型）-->
  // a. 获取指定的方法（公共 / 继承）
    Method getMethod(String name, Class<?>... parameterTypes) ；
  // b. 获取所有的方法（公共 / 继承）
   Method[] getMethods() ；
  // c. 获取指定的方法 （ 不包括继承）
   Method getDeclaredMethod(String name, Class<?>... parameterTypes) ；
  // d. 获取所有的方法（ 不包括继承）
   Method[] getDeclaredMethods() ；
// 最终都是获得一个Method类对象

<-- 4. Class类的其他常用方法 -->
getSuperclass(); 
// 返回父类

String getName(); 
// 作用：返回完整的类名（含包名，如java.lang.String ） 
 
Object newInstance(); 
// 作用：快速地创建一个类的实例
// 具体过程：调用默认构造器（若该类无默认构造器，则抛出异常 
// 注：若需要为构造器提供参数需使用java.lang.reflect.Constructor中的newInstance（）
步骤3：通过 Constructor类对象、Method类对象 & Field类对象分别获取类的构造函数、方法 & 属性的具体信息 & 进行操作

这部分方法很重要，熟练了后实际操作才能感受到反射的好用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 即以下方法都分别属于`Constructor`类、`Method`类 & `Field`类的方法。

<-- 1. 通过Constructor 类对象获取类构造函数信息 -->
  String getName()；// 获取构造器名
  Class getDeclaringClass()；// 获取一个用于描述类中定义的构造器的Class对象
  int getModifiers()；// 返回整型数值，用不同的位开关描述访问修饰符的使用状况
  Class[] getExceptionTypes()；// 获取描述方法抛出的异常类型的Class对象数组
  Class[] getParameterTypes()；// 获取一个用于描述参数类型的Class对象数组

<-- 2. 通过Field类对象获取类属性信息 -->
  String getName()；// 返回属性的名称
  Class getDeclaringClass()； // 获取属性类型的Class类型对象
  Class getType()；// 获取属性类型的Class类型对象
  int getModifiers()； // 返回整型数值，用不同的位开关描述访问修饰符的使用状况
  Object get(Object obj) ；// 返回指定对象上 此属性的值
  void set(Object obj, Object value) // 设置 指定对象上此属性的值为value
 
<-- 3. 通过Method 类对象获取类方法信息 -->
  String getName()；// 获取方法名
  Class getDeclaringClass()；// 获取方法的Class对象 
  int getModifiers()；// 返回整型数值，用不同的位开关描述访问修饰符的使用状况
  Class[] getExceptionTypes()；// 获取用于描述方法抛出的异常类型的Class对象数组
  Class[] getParameterTypes()；// 获取一个用于描述参数类型的Class对象数组

<--额外：java.lang.reflect.Modifier类 -->
// 作用：获取访问修饰符

static String toString(int modifiers)   
// 获取对应modifiers位设置的修饰符的字符串表示

static boolean isXXX(int modifiers) 
// 检测方法名中对应的修饰符在modifiers中的值
访问权限问题

  • 背景
    反射机制的默认行为受限于Java的访问控制。如：无法访问（ private ）私有的方法、字段

  • 冲突
    Java安全机制只允许查看任意对象有哪些域，而不允许读它们的值。若强制读取，将抛出异常

  • 解决方案
    脱离Java程序中安全管理器的控制、屏蔽Java语言的访问检查，从而脱离访问控制

  • 具体实现手段：使用Field类、Method类 & Constructor类对象的setAccessible()
1
2
3
4
5
6
7
8
9
void setAccessible(boolean flag)    
// 作用：为反射对象设置可访问标志
// 规则：flag = true时 ，表示已屏蔽Java语言的访问检查，使得可以访问 & 修改对象的私有属性

boolean isAccessible()  
// 返回反射对象的可访问标志的值

static void setAccessible(AccessibleObject[] array, boolean flag)   
// 设置对象数组可访问标志
基础实例学习
利用反射获取类的属性 & 赋值

Student 类：

1
2
3
4
5
6
7
8
class Student {

    private String name;

    public Student() {
        System.out.println("创建了一个Student实例");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
try {
    //1.获取Student类的Class对象
    Class studentClass = Student.class;

    //2.通过Class对象创建Student类的对象
    Object mStudent = studentClass.newInstance();

    //3.通过Class对象获取Student类的name属性
    Field f = studentClass.getDeclaredField("name");

    //4.设置私有访问权限
    f.setAccessible(true);

    //5.对新创建的Student对象设置name值
    f.set(mStudent,"zx");

    //6.获取新创建Student对象的name属性&输出
    System.out.println(f.get(mStudent));

} catch (Exception e) {
    e.printStackTrace();
}

上面的代码自己可以改着看看，比如将序号4的代码注释掉，就会出现我们上面提到的访问权限的问题。会提示你不能访问private修饰的属性。

1
java.lang.IllegalAccessException: Class TestDemo can not access a member of 		  class Student with modifiers "private"
利用反射调用类的构造函数
1
2
3
4
5
6
7
8
9
10
11
12
class Student {

    private String name;

    public Student() {
        System.out.println("调用了无参构造函数");
    }

    public Student(String name) {
        System.out.println("调用了有参构造函数");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
try {
    //1.获取Student类的Class对象
    Class studentClass = Student.class;

    //2.1 通过Class对象获取Constructor类对象，从而调用无参构造方法
    //注：构造函数的调用实际上是在newInstance()，而不是在getConstructor()中调用
    Object mObj1 = studentClass.getConstructor().newInstance();

    // 2.2 通过Class对象获取Constructor类对象（传入参数类型），从而调用有参构造方法
    Object mObj2 = studentClass.getConstructor(String.class).newInstance("zx");
    
} catch (Exception e) {
    e.printStackTrace();
}

利用反射调用类对象的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Student {

    private String name;

    public Student() {
        System.out.println("调用了无参构造函数");
    }

    public Student(String name) {
        System.out.println("调用了有参构造函数");
    }

    //无参数方法
    public void setName1() {
        System.out.println("调用了无参方法： setName1()");
    }

    //有参数的方法
    public void setName2(String str) {
        System.out.println("调用了有参方法 setName2(String str): "+str);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
try {
   //获取student类的Class对象
    Class studentClass = Student.class;

    //2.通过Class对象创建Student类的对象
    Object mStudent = studentClass.newInstance();

    //3.1 通过Class对象获取方法 setName1() 的Method对象： 需传入方法名
    //因为该方法无参，所以不需要传入参数
    Method msetName1 = studentClass.getMethod("setName1");

    //通过Method对象调用setName1() ： 需传入创建的实例
    msetName1.invoke(mStudent);

    //3.2 通过Class对象获取方法setName2() 的Method对象： 需传入方法名 & 参数类型
    Method msetName2 = studentClass.getMethod("setName2", String.class);

    //通过Method对象调用setName2() : 需传入创建的实例 & 参数值
    msetName2.invoke(mStudent,"zx");

} catch (Exception e) {
    e.printStackTrace();
}

常见需求场景讲解
工厂模式优化
  • 背景
    采用简单工厂模式

  • 冲突

    1. 操作成本高：每增加一个接口的子类，必须修改工厂类的逻辑
    2. 系统复杂性提高：每增加一个接口的子类，都必须向工厂类添加逻辑

  • 解决方案
    采用反射机制： 通过 传入子类名称 & 动态创建子类实例，从而使得在增加产品接口子类的情况下，也不需要修改工厂类的逻辑

  • 实例演示

步骤1. 创建抽象产品类的公共接口

Product.java：

1
2
3
abstract class Product{
    public abstract void show();
}

步骤2. 创建具体产品类（继承抽象产品类），定义生产的具体产品

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<-- 具体产品类A：ProductA.java -->
public class ProductA extends Product{

    @Override
    public void show() {
        System.out.println("生产出了产品A");
    }
}

<-- 具体产品类B：ProductB.java -->
public class  ProductB extends  Product{

    @Override
    public void show() {
        System.out.println("生产出了产品B");
    }
}

步骤3. 创建工厂类

Factory.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Factory {

    // 定义方法：通过反射动态创建产品类实例
    public static Product getInstance(String ClassName) {

        Product concreteProduct = null;

        try {
            
            // 1. 根据 传入的产品类名 获取 产品类类型的Class对象
            Class product_Class = Class.forName(ClassName);
            // 2. 通过Class对象动态创建该产品类的实例
            concreteProduct = (Product) product_Class.newInstance();

        } catch (Exception e) {
            e.printStackTrace();
        }
        
        // 3. 返回该产品类实例
        return concreteProduct;
    }
    
}

步骤4：外界通过调用工厂类的静态方法（反射原理），传入不同参数从而创建不同具体产品类的实例

TestReflect.java

1
2
3
4
5
6
7
8
9
public class Test {
    public static void main(String args[]) {
        // 1. 通过调用工厂类的静态方法（反射原理），从而动态创建产品类实例
        // 需传入完整的类名 & 包名
        Product concreteProduct = Factory.getInstance("model.ProductA");
        // 2. 调用该产品类对象的方法，从而生产产品
        concreteProduct.show();
    }
}

可以明显看出，通过采用反射机制（通过传入子类名称 & 动态创建子类实例），从而使得在增加产品接口子类的情况下，也不需要修改工厂类的逻辑 & 增加系统复杂度。

工厂模式再优化

  • 背景
    在上述方案中，通过调用工厂类的静态方法（反射原理），从而动态创建产品类实例（该过程中：需传入完整的类名 & 包名）

  • 冲突
    开发者 无法提前预知 接口中的子类类型 & 完整类名

  • 解决方案
    通过 属性文件的形式（ Properties） 配置所要的子类信息，在使用时直接读取属性配置文件从而获取子类信息（完整类名）

  • 实例演示

步骤1、2、3同上

步骤4：创建属性配置文件

Product.properties

1
2
3
//写入抽象产品接口的子类信息（即完整的类名）
ProductA = model.ProductA
ProductB = model.ProductB

项目结构如下：

步骤5：下面引用创建的properties文件

之所以要贴出项目结构图，就是为了引用的时候别搞错路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main(String args[]) throws Exception {

    //1.读取属性配置文件
    Properties pro = new Properties();
    FileInputStream inputStream = new FileInputStream("src/Product.properties");   //注意路径
    pro.load(inputStream);
    //System.out.println(pro.getProperty("ProductA"));

    //2.获取属性配置文件中的产品类名
    String className = pro.getProperty("ProductA");

    //3.动态生成产品类实例
    Product concreteProduct = Factory.getInstance(className);

    //4.调用该产品类对象的方法，从而生产产品
    concreteProduct.show();
}

结果同上

上面读取配置文件还可以采用ClassLoader

只不过，ClassLoader采用的是相对路径，上面的FileInputStream采用的是绝对路径

1
2
3
ClassLoader classLoader = Test.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("Product.properties");
pro.load(is);
使用反射前后对比

如果Factory类中我们没有采用反射，而是采用常规写法，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class  Factory {
    public static Product Manufacture(String ProductName){
//工厂类里用switch语句控制生产哪种商品；
//使用者只需要调用工厂类的静态方法就可以实现产品类的实例化。
        switch (ProductName){
            case "A":
                return new ProductA();

            case "B":
                return new ProductB();

            case "C":
                return new ProductC();

            default:
                return null;

        }
    }
}

可见，如果我们新增加了一款产品 ProductD，那就要去修改工厂类，如果采用反射的话，就没必要了

0%