Java提升班（六）反射和动态代理（JDK Proxy和Cglib）

反射和动态代理放有必定的相关性，但单纯的说动态代理是由反射机制实现的，实际上是不够全面不许确的，动态代理是一种功能行为，而它的实现方法有不少。要怎么理解以上这句话，请看下文。

1、反射

反射机制是 Java 语言提供的一种基础功能，赋予程序在运行时自省（introspect，官方用语）的能力。经过反射咱们能够直接操做类或者对象，好比获取某个对象的类定义，获取类声明的属性和方法，调用方法或者构造对象，甚至能够运行时修改类定义。

一、获取类（Class）对象

获取类对象有三种方法：

• 经过forName() -> 示例：Class.forName("PeopleImpl")
• 经过getClass() -> 示例：new PeopleImpl().getClass()
• 直接获取.class -> 示例：PeopleImpl.class

二、类的经常使用方法

• getName()：获取类完整方法；
• getSuperclass()：获取类的父类；
• newInstance()：建立实例对象；
• getFields()：获取当前类和父类的public修饰的全部属性；
• getDeclaredFields()：获取当前类（不包含父类）的声明的全部属性；
• getMethod()：获取当前类和父类的public修饰的全部方法；
• getDeclaredMethods()：获取当前类（不包含父类）的声明的全部方法；

更多方法：icdn.apigo.cn/blog/class-…

三、类方法调用

反射要调用类中的方法，须要经过关键方法“invoke()”实现的，方法调用也分为三种：

• 静态（static）方法调用
• 普通方法调用
• 私有方法调用

如下会分别演示，各类调用的实现代码，各类调用的公共代码部分，以下：

// 此段代码为公共代码
interface People {
    int parentAge = 18;
    public void sayHi(String name);
}
class PeopleImpl implements People {
    private String privSex = "男";
    public String race = "汉族";
    @Override
    public void sayHi(String name) {
        System.out.println("hello," + name);
    }
    private void prvSayHi() {
        System.out.println("prvSayHi~");
    }
    public static void getSex() {
        System.out.println("18岁");
    }
}
复制代码

3.1 静态方法调用

// 核心代码（省略了抛出异常的声明）
public static void main(String[] args) {
    Class myClass = Class.forName("example.PeopleImpl");
    // 调用静态（static）方法
    Method getSex = myClass.getMethod("getSex");
    getSex.invoke(myClass);
}
复制代码

静态方法的调用比较简单，使用 getMethod(xx) 获取到对应的方法，直接使用 invoke(xx)就能够了。

3.2 普通方法调用

普通非静态方法调用，须要先获取类示例，经过“newInstance()”方法获取，核心代码以下：

Class myClass = Class.forName("example.PeopleImpl");
Object object = myClass.newInstance();
Method method = myClass.getMethod("sayHi",String.class);
method.invoke(object,"老王");
复制代码

getMethod 获取方法，能够声明须要传递的参数的类型。

3.3 调用私有方法

调用私有方法，必须使用“getDeclaredMethod(xx)”获取本类全部什么的方法，代码以下：

Class myClass = Class.forName("example.PeopleImpl");
Object object = myClass.newInstance();
Method privSayHi = myClass.getDeclaredMethod("privSayHi");
privSayHi.setAccessible(true); // 修改访问限制
privSayHi.invoke(object);
复制代码

除了“getDeclaredMethod(xx)”能够看出，调用私有方法的关键是设置 setAccessible(true) 属性，修改访问限制，这样设置以后就能够进行调用了。

四、总结

1.在反射中核心的方法是 newInstance() 获取类实例，getMethod(..) 获取方法，使用 invoke(..) 进行方法调用，经过 setAccessible 修改私有变量/方法的访问限制。

2.获取属性/方法的时候有无“Declared”的区别是，带有 Declared 修饰的方法或属性，能够获取本类的全部方法或属性（private 到 public），但不能获取到父类的任何信息；非 Declared 修饰的方法或属性，只能获取 public 修饰的方法或属性，并能够获取到父类的信息，好比 getMethod(..)和getDeclaredMethod(..)。

2、动态代理

动态代理是一种方便运行时动态构建代理、动态处理代理方法调用的机制，不少场景都是利用相似机制作到的，好比用来包装 RPC 调用、面向切面的编程（AOP）。

实现动态代理的方式不少，好比 JDK 自身提供的动态代理，就是主要利用了上面提到的反射机制。还有其余的实现方式，好比利用传说中更高性能的字节码操做机制，相似 ASM、cglib（基于 ASM）等。

动态代理解决的问题？

首先，它是一个代理机制。若是熟悉设计模式中的代理模式，咱们会知道，代理能够看做是对调用目标的一个包装，这样咱们对目标代码的调用不是直接发生的，而是经过代理完成。经过代理可让调用者与实现者之间解耦。好比进行 RPC 调用，经过代理，能够提供更加友善的界面。还能够经过代理，能够作一个全局的拦截器。

一、JDK Proxy 动态代理

JDK Proxy 是经过实现 InvocationHandler 接口来实现的，代码以下：

interface Animal {
    void eat();
}
class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("The dog is eating");
    }
}
class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("The cat is eating");
    }
}

// JDK 代理类
class AnimalProxy implements InvocationHandler {
    private Object target; // 代理对象
    public Object getInstance(Object target) {
        this.target = target;
        // 取得代理对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用前");
        Object result = method.invoke(target, args); // 方法调用
        System.out.println("调用后");
        return result;
    }
}

public static void main(String[] args) {
    // JDK 动态代理调用
    AnimalProxy proxy = new AnimalProxy();
    Animal dogProxy = (Animal) proxy.getInstance(new Dog());
    dogProxy.eat();
}
复制代码

如上代码，咱们实现了经过动态代理，在全部请求以前和以后打印了一个简单的信息。

注意： JDK Proxy 只能代理实现接口的类（即便是extends继承类也是不能够代理的）。

JDK Proxy 为何只能代理实现接口的类？

这个问题要从动态代理的实现方法 newProxyInstance 源码提及：

@CallerSensitive
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
// 省略其余代码
复制代码

来看前两个源码参数说明：

* @param   loader the class loader to define the proxy class * @param interfaces the list of interfaces for the proxy class to implement 复制代码

• loader：为类加载器，也就是 target.getClass().getClassLoader()
• interfaces：接口代理类的接口实现列表

因此这个问题的源头，在于 JDK Proxy 的源码设计。若是要执意动态代理，非接口实现类就会报错：

Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be cast to xxx

二、Cglib 动态代理

JDK 动态代理机制只能代理实现了接口的类，Cglib 是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现加强，但由于采用的是继承，因此不能对 final 修饰的类进行代理。

Cglib 能够经过 Maven 直接进行版本引用，Maven 版本地址：mvnrepository.com/artifact/cg…

本文使用的是最新版本 3.2.9 的 Cglib，在 pom.xml 添加以下引用：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.9</version>
</dependency>
复制代码

Cglib 代码实现，以下：

class Panda {
    public void eat() {
        System.out.println("The panda is eating");
    }
}
class CglibProxy implements MethodInterceptor {
    private Object target; // 代理对象
    public Object getInstance(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        // 设置父类为实例类
        enhancer.setSuperclass(this.target.getClass());
        // 回调方法
        enhancer.setCallback(this);
        // 建立代理对象
        return enhancer.create();
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("调用前");
        Object result = methodProxy.invokeSuper(o, objects); // 执行方法调用
        System.out.println("调用后");
        return result;
    }
}

public static void main(String[] args) {
    // CGLIB 动态代理调用
    CglibProxy proxy = new CglibProxy();
    Panda panda = (Panda)proxy.getInstance(new Panda());
    panda.eat();
}
复制代码

cglib 的调用经过实现 MethodInterceptor 接口的 intercept 方法，调用 invokeSuper 进行动态代理的，能够直接对普通类进行动态代理。

3、JDK Proxy VS Cglib

JDK Proxy 的优点：

• 最小化依赖关系，减小依赖意味着简化开发和维护，JDK 自己的支持，更加可靠；
• 平滑进行 JDK 版本升级，而字节码类库一般须要进行更新以保证在新版上可以使用；

Cglib 框架的优点：

• 可调用普通类，不须要实现接口；
• 高性能；

总结： 须要注意的是，咱们在选型中，性能未必是惟一考量，可靠性、可维护性、编程工做量等每每是更主要的考虑因素，毕竟标准类库和反射编程的门槛要低得多，代码量也是更加可控的，若是咱们比较下不一样开源项目在动态代理开发上的投入，也能看到这一点。

本文全部示例代码：github.com/vipstone/ja…

4、参考文档

Java核心技术36讲：t.cn/EwUJvWA

Java反射与动态代理：www.cnblogs.com/hanganglin/…

---

关注做者公众号：

若是以为本文对您有帮助，请我喝杯咖啡吧。