三者代码量的比较

在分析比较三者之前，我们先比较直观的通过代码量来看看三者之间的区别。

我们首先看一段反射的例子。

原生反射实现

JOOR实现

Hutool实现

首先从主观上来看JOOR和Hutool在api层面都精简了很多，并且对异常进行了封装，不强制捕获，而JOOR在Hutool的基础上又支持了链式编程。

JOOR主要API

那么我们来看下JOOR的主要API

public class JoorExample {
    public static void main(String[] args) {
        String name = null;
        Kale kale;
        // 【创建类】
        kale = Reflect.onClass(Kale.class).create().get(); // 无参数
//        kale = Reflect.on(Kale.class).create("kale class name").get();// 有参数
        System.out.println("------------------> class name = " + kale.getClass());
 
        // 【调用方法】
        Reflect.on(kale).call("setName","调用setName");// 多参数
        System.out.println("调用方法：name = " + Reflect.on(kale).call("getName"));// 无参数
 
        // 【得到变量】
        name = Reflect.on(kale).field("name").get();// 复杂
        name = Reflect.on(kale).get("name");// 简单
        System.out.println("得到变量值： name = " + name);
 
        // 【设置变量的值】
        Reflect.on(kale).set("className", "hello");
        System.out.println("设置变量的值： name = " + kale.getClass());
        System.out.println("设置变量的值： name = " + Reflect.on(kale).set("className", "hello2").get("className"));
 
    }
}

可以看出JOOR内置了set和get方法供我们调用，可以直接获得某些属性的值，而链式编程也极大地简化了开发。

JOOR是否支持java原生的几种方式(全类名，对象实例，类的class对象)获得反射对象呢？

由上面的例子我们已知JOOR支持根据对象的实例获得反射对象。

再来看看下面的例子

String world = onClass("java.lang.String")  // on后面放入类的全名，这里是String类
        .create("Hello World") // 将字符串“Hello World”，传入构造方法中
        .call("substring", 6)  // 执行subString这个方法，并且传入6作为参数
        .call("toString")      // 执行toString方法
        .get();                // 得到包装好的类，这里是一个String对象
 
String substring = onClass("java.lang.String")
        .create("Hello World")
        .as(StringProxy.class) // 为包装类建立一个代理
        .substring(6);         // 访问代理方法
 
String string = onClass(String.class)
        .create("Hello World")
        .as(StringProxy.class) // 为包装类建立一个代理
        .substring(6);         // 访问代理方法
 
 
 
System.out.println(world);
System.out.println(substring);
System.out.println(string);

我们可以看出，通过全类名和类的class对象均可以获得反射对象，同时还支持访问jdk的代理方法。

JOOR实现代理

我们首先来写一个静态代理，包含代理类和普通类，Waiter是ZhangSan的代理类。

public interface Restaurant {
    void eat();
}
public class ZhangSan implements Restaurant{
    @Override
    public void eat() {
        System.out.println("吃吃吃");
    }
}
public class Waiter implements Restaurant{
    private ZhangSan zhangSan;
 
    public Waiter(ZhangSan zhangSan) {
        this.zhangSan = zhangSan;
    }
 
    @Override
    public void eat() {
        System.out.println("做饭");
        zhangSan.eat();
        System.out.println("洗碗");
    }
}

实现代理的测试

这里代理对象必须以构造方法的形式传入对象，对其增强，通过代理实现增强的方法。

结论

通过以上案例可以看出，JOOR由于其链式编程的特性，对代码的简化和可扩展性要强于另外两个，且其包含了一些高级应用，如代理，虽然代码不如原生的精简，但是通俗易懂。

如需使用，则只需引入下列的包，即可使用JOOR或Hutool中的反射封装类。

//JOOR
<dependency>
    <groupId>org.jooq</groupId>
    <artifactId>joor-java-8</artifactId>
    <version>0.9.13</version>
</dependency>
 
//Hutool
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.4.6</version>
</dependency>

具体如何使用可根据实际情况灵活选择。