joor反射工具

一.joor 简单介绍

1.功能介绍

1. 提供 on()操作符对类名、Class、Object 进行统一实例化为 Reflect 对象，后续所有的反射操作基于该 Reflect 对象。
   
2. 有功能调用方式均被封装成返回 Reflect 对象的链式结构，在使用上使得代码更加简洁。
   
3. 对方法的签名匹配封装了更完善的匹配规则，包括精确匹配 exactMethod()、近似匹配 similarMethod()【对函数参数的近似匹配（int -> Integer）】和基类搜索等。
   
4. 调用私有方法的不需要显示调用 setAccessible()，内部动态读取 public 标记自动适配。
   
5. 更加简洁的实现了对象构造函数的反射调用 create()方法。
   
6. 函数的调用 call()方法组合成了可以拼接在 Reflect 的对象后面的链式方法。
   
7. 额外增加了高级操作符 as()，它实现了类的代理访问以及 POJO 对象的 get/set/is 方法实现。
   

2.和传统反射优势

从上面的例子就可以看到 jOOR 明显的优势：

1. 简化了反射冗长的异常处理
   
2. 简化了对 Class、Method、Field、Constructor 反射类的实例化，改为统一 Reflect 替换
   
3. 支持 private 方法的调用，内部动态区分是否需要 accessible()
   
4. 将反射调用封装为更流行的链式调用方式，代码更容易理解（类似 Rxjava 的封装方式）
   
5. 支持类型内部 wrap 转换（泛型实现）
   

3.安装依赖

joor 优雅的进行反射,使用 joor 可以简化代码，可以捕捉到使用反射时无法抛出的异常

<!-- https://mvnrepository.com/artifact/org.jooq/joor -->

<dependency>

   <groupId>org.jooq</groupId>

   <artifactId>joor</artifactId>

   <version>0.9.6</version>

</dependency>

二.使用

1.api 介绍

/**

* https://github.com/jOOQ/jOOR

* Reflect实际是对原生java reflect进行封装，屏蔽了无关细节。

*

* Reflect.create 用来调用之前的类的构造方法，有两种重载，一种有参数，一种无参数

* Reflect.call 方法调用，传入方法名和参数，如有返回值还需要调用get

* Reflect.get 获取（field和method返回）值相关，会进行类型转换，常与call和field组合使用

* Reflect.field 获取属性值相关，需要调用get获取该值

* Reflect.set 设置属性相关。

*/

//1、通过类名转换成一个Reflect对象：

public static Reflect on(String name);

public static Reflect on(String name, ClassLoader classLoader);

public static Reflect on(Class<?> clazz);

//2、将一个类对象转换成一个Reflect对象：

public static Reflect on(Object object);

//3、修改一个AccessibleObject类型的对象的访问权限：

public static <T extends AccessibleObject> T accessible(T accessible);

//4、返回Reflect对象具体包装的类型，类型为Class或者对象，由操作符on()的重载参数决定：

public <T> T get()；

//5、将name指定的field转换成一个Reflect对象，后续对field的操作变为对Reflect对象的操作：

public Reflect field(String name);

//6、返回当前Reflect对象的所有field属性，并转换成Reflect对象的map：

public Map<String, Reflect> fields();

//7、修改(获取)field属性值：

public Reflect set(String name, Object value);

public <T> T get(String name);

//8、反射调用name指定的函数，此函数封装了对函数的签名的精准匹配和近似匹配：

public Reflect call(String name);

public Reflect call(String name, Object... args);

//9、反射调用指定类的构造函数，也封装了精准匹配和近似匹配：

public Reflect create();

public Reflect create(Object... args);

//10、返回当前Reflect对象封装的对象类型：

public Class<?> type()；

//11、给封装对象创建一个代理访问，还实现了对POJO对象的setXX/getXX/isxx功能（此为Reflect对象的高级功能）：

public <P> P as(Class<P> proxyType);

2.简单示例

// All examples assume the following static import:

import static org.joor.Reflect.*;

String world = on("java.lang.String")  // on后面放入类的全名，这里是String类

               .create("Hello World") // 将字符串“Hello World”，传入构造方法中

               .call("substring", 6)  // 执行subString这个方法，并且传入6作为参数

               .call("toString")      // 执行toString方法

               .get();                // 得到包装好的类，这里是一个String对象

// 使用joor赋值

ABC abc1 = new ABC();

on(abc1).set("A","123").set("B","321");

System.out.println(abc1);// ABC(A=123, B=321)

3.复杂示例

String name = null;

Kale kale;

// 【创建类】

kale = Reflect.on(Kale.class).create().get(); // 无参数

kale = Reflect.on(Kale.class).create("kale class name").get();// 有参数

System.err.println("------------------> class name = " + kale.getClassName());

// 【调用方法】

Reflect.on(kale).call("setName","调用setName");// 多参数

System.err.println("调用方法：name = " + Reflect.on(kale).call("getName"));// 无参数

// 【得到变量】

name = Reflect.on(kale).field("name").get();// 复杂

name = Reflect.on(kale).get("name");// 简单

System.err.println("得到变量值： name = " + name);

// 【设置变量的值】

Reflect.on(kale).set("className", "hello");

System.err.println("设置变量的值： name = " + kale.getClassName());

System.err.println("设置变量的值： name = " + Reflect.on(kale).set("className", "hello2").get("className"));

3.方法调用

//Instance methods on的参数是一个对象

//Static methods on的参数是一个类

// Instance methods

//value0 = "12";

final String value0 = Reflect.on((Object) "1234").call("substring", 0, 2).get();

// Static methods

//value1 = "true";

final String value1 = Reflect.on(String.class).call("valueOf", true).get();

// 使用joor执行方法

on(abc1).call("soutA");

4.属性操作

public static class TestField {

   private static final int SF_INT1 = new Integer(0);

   private static final Integer SF_INT2 = new Integer(0);

   private final int F_INT1 = new Integer(0);

   private final Integer F_INT2 = new Integer(0);

   private TestField I_DATA;

}

//Instant fields,on的参数是一个对象

//Static fields,on的参数是一个类

// Instance fields

// ----------------

TestField testField = new TestField();

/**

* 修改final属性

*/

final Integer value0 = Reflect.on(testField).set("F_INT2", 1).get("F_INT2"); //value0 = 1;

/**

* 获取属性值

*/

final int value1 = Reflect.on(testField).field("F_INT2").get(); //value1 = 1;

/**

* 链式修改多个属性值

*/

Reflect.on(testField).set("F_INT1", 2).set("F_INT2", 2);

/**

* 复杂链式修改多个属性值

*/

Reflect.on(testField).set("I_DATA", Reflect.on(TestField.class).create())

   .field("I_DATA").set("F_INT1", 3).set("F_INT2", 3);

// Static fields

// ----------------

/**

* 修改static final属性

*/

final int value2 = Reflect.on(TestField.class).set("SF_INT1", 4).get("SF_INT1"); //value2 = 4;

/**

* 获取静态属性值

*/

final int value3 = Reflect.on(TestField.class).field("SF_INT1").get(); //value3 = 4;

5.抽象代理

public interface StringProxy {

 String substring(int beginIndex);

}

String substring = on("java.lang.String")

                   .create("Hello World")

                   .as(StringProxy.class) // 为包装类建立一个代理

                   .substring(6);         // 访问代理方法

6.原生方法