java反射机制

前言
在 Java中，反射机制（Reflection）非常重要，但对于很多开发者来说，这并不容易理解，甚至觉得有点神秘
今天，我将献上一份 Java反射机制的介绍 & 实战攻略，希望你们会喜欢。

1. 简介
定义：Java语言中 一种 动态（运行时）访问、检测 & 修改它本身的能力
作用：动态（运行时）获取类的完整结构信息 & 调用对象的方法
类的结构信息包括：变量、方法等
正常情况下，Java类在编译前，就已经被加载到JVM中；而反射机制使得程序运行时还可以动态地去操作类的变量、方法等信息
2. 特点
2.1 优点

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

编译方式说明：

1. 静态编译：在编译时确定类型 & 绑定对象。如常见的使用new关键字创建对象

2. 动态编译：运行时确定类型 & 绑定对象。动态编译体现了Java的灵活性、多态特性 & 降低类之间的藕合性

2.2 缺点

执行效率低
因为反射的操作 主要通过JVM执行，所以时间成本会 高于 直接执行相同操作
因为接口的通用性，Java的invoke方法是传object和object[]数组的。基本类型参数需要装箱和拆箱，产生大量额外的对象和内存开销，频繁促发GC。
编译器难以对动态调用的代码提前做优化，比如方法内联。
反射需要按名检索类和方法，有一定的时间开销。
容易破坏类结构
因为反射操作饶过了源码，容易干扰类原有的内部逻辑
3. 应用场景
动态获取 类文件结构信息（如变量、方法等） & 调用对象的方法
常用的需求场景有：动态代理、工厂模式优化、Java JDBC数据库操作等
4. 具体使用
4.1 Java反射机制提供的功能
4.2 实现手段

反射机制的实现 主要通过 操作java.lang.Class类
下面将主要讲解 java.lang.Class 类
定义：java.lang.Class类是反射机制的基础
作用：存放着对应类型对象的 运行时信息
在Java程序运行时，Java虚拟机为所有类型维护一个java.lang.Class对象
该Class对象存放着所有关于该对象的 运行时信息
泛型形式为Class
每种类型的Class对象只有1个 = 地址只有1个
// 对于2个String类型对象，它们的Class对象相同

Class c1 = “Carson”.getClass();
Class c2 = Class.forName(“java.lang.String”);
运行结果：

4.3 使用步骤

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

1. 获取 目标类型的Class对象
2. 通过 Class 对象分别获取Constructor类对象、Method类对象 & Field 类对象
3. 通过 Constructor类对象、Method类对象 & Field类对象分别获取类的构造函数、方法&属性的具体信息，并进行后续操作
   
   下面，我将详细讲解每个步骤中的使用方法。
   获取类的类名：
   
   获取构造方法
   
   获取方法
   
   获取属性
   
   // 即以下方法都分别属于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反射机制的步骤说明已经讲解完毕。

4.4 特别注意：访问权限问题

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

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

解决方案
脱离Java程序中安全管理器的控制、屏蔽Java语言的访问检查，从而脱离访问控制
具体实现手段：使用Field类、Method类 & Constructor类对象的setAccessible()
void setAccessible(boolean flag)

// 作用：为反射对象设置可访问标志

// 规则：flag = true时 ，表示已屏蔽Java语言的访问检查，使得可以访问 & 修改对象的私有属性

boolean isAccessible()

// 返回反射对象的可访问标志的值

static void setAccessible(AccessibleObject[] array, boolean flag)

// 设置对象数组可访问标志

案例一：反射修改属性值

案例二：利用反射创建对象，并赋值

三.利用反射调用类方法

5.2 常见需求场景讲解

实例1：工厂模式优化

背景
采用简单工厂模式
冲突
操作成本高：每增加一个接口的子类，必须修改工厂类的逻辑
系统复杂性提高：每增加一个接口的子类，都必须向工厂类添加逻辑
关于 简单工厂模式的介绍 & 使用 请看文章：简单工厂模式（SimpleFactoryPattern）- 最易懂的设计模式解析

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

Product.java

abstract class Product{

public abstract void show();

}

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

<-- 具体产品类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”);

}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
步骤3. 创建工厂类

Factory.java

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;

}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
步骤4：外界通过调用工厂类的静态方法（反射原理），传入不同参数从而创建不同具体产品类的实例

TestReflect.java

public class TestReflect {

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

// 1. 通过调用工厂类的静态方法（反射原理），从而动态创建产品类实例

// 需传入完整的类名 & 包名

Product concreteProduct = Factory.getInstance(“scut.carson_ho.reflection_factory.ProductA”);

// 2. 调用该产品类对象的方法，从而生产产品

concreteProduct.show();

}

}

1
2
3
4
5
6
7
8
9
10
11
展示结果

Demo地址
Carson_Ho的Github地址：Reflection_Factory1
如此一来，通过采用反射机制（通过 传入子类名称 & 动态创建子类实例），从而使得在增加产品接口子类的情况下，也不需要修改工厂类的逻辑 & 增加系统复杂度

实例2：应用了反射机制的工厂模式再次优化

背景
在上述方案中，通过调用工厂类的静态方法（反射原理），从而动态创建产品类实例（该过程中：需传入完整的类名 & 包名）
冲突
开发者 无法提前预知 接口中的子类类型 & 完整类名
解决方案
通过 属性文件的形式（ Properties） 配置所要的子类信息，在使用时直接读取属性配置文件从而获取子类信息（完整类名）
具体实现
步骤1：创建抽象产品类的公共接口

Product.java

abstract class Product{

public abstract void show();

}

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

<-- 具体产品类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”);

}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
步骤3. 创建工厂类

Factory.java

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;

}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
步骤4：创建属性配置文件

Product.properties

// 写入抽象产品接口类的子类信息（完整类名）

ProductA = scut.carson_ho.reflection_factory.ProductA

ProductB = scut.carson_ho.reflection_factory.ProductB

1
2
3
步骤5：将属性配置文件 放到src/main/assets文件夹中

若没assets文件夹，则自行创建

步骤6：在动态创建产品类对象时，动态读取属性配置文件从而获取子类完整类名

TestReflect.java

public class TestReflect {

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

// 1. 读取属性配置文件

Properties pro = new Properties() ;

pro.load(this.getAssets().open(“Product.properties”));

// 2. 获取属性配置文件中的产品类名

String Classname = pro.getProperty(“ProductA”);

// 3. 动态生成产品类实例

Product concreteProduct = Factory.getInstance(Classname);

// 4. 调用该产品类对象的方法，从而生产产品

concreteProduct.show();

}

测试结果

Demo地址
Carson_Ho的Github地址：Reflection_Factory2
实例3：动态代理

通过反射机制实现动态代理，具体请看文章：设计模式：这是一份全面 & 清晰的动态代理模式（Proxy Pattern）学习指南