Java Proxy 和 CGLIB 动态代理原理

时间  2019-11-19
标签 java proxy cglib 动态 代理 原理 栏目 Java 繁體版
原文   原文链接

动态代理在Java中有着普遍的应用，好比Spring AOP，Hibernate数据查询、测试框架的后端mock、RPC，Java注解对象获取等。静态代理的代理关系在编译时就肯定了，而动态代理的代理关系是在编译期肯定的。静态代理实现简单，适合于代理类较少且肯定的状况，而动态代理则给咱们提供了更大的灵活性。今天咱们来探讨Java中两种常见的动态代理方式：JDK原生动态代理和CGLIB动态代理。html

JDK原生动态代理

先从直观的示例提及，假设咱们有一个接口Hello和一个简单实现HelloImp：java

// 接口
interface Hello {
    String sayHello(String str);
}

// 实现
class HelloImp implements Hello {
    @Override
    public String sayHello(String str) {
        return "HelloImp: " + str;
    }
}

这是Java种再常见不过的场景，使用接口制定协议，而后用不一样的实现来实现具体行为。假设你已经拿到上述类库，若是咱们想经过日志记录对sayHello()的调用，使用静态代理能够这样作：git

// 静态代理方式
class StaticProxiedHello implements Hello {
    ...
    private Hello hello = new HelloImp();

    @Override
    public String sayHello(String str) {
        logger.info("You said: " + str);
        return hello.sayHello(str);
    }
}

上例中静态代理类StaticProxiedHello做为HelloImp的代理，实现了相同的Hello接口。用Java动态代理能够这样作：github

  1. 首先实现一个InvocationHandler，方法调用会被转发到该类的invoke()方法。
  2. 而后在须要使用Hello的时候，经过JDK动态代理获取Hello的代理对象。
// Java Proxy
// 1. 首先实现一个InvocationHandler，方法调用会被转发到该类的invoke()方法。
class LogInvocationHandler implements InvocationHandler {
    ...
    private Hello hello;

    public LogInvocationHandler(Hello hello) {
        this.hello = hello;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if ("sayHello".equals(method.getName())) {
            logger.info("You said: " + Arrays.toString(args));
        }
        return method.invoke(hello, args);
    }
}
// 2. 而后在须要使用Hello的时候，经过JDK动态代理获取Hello的代理对象。
Hello hello = (Hello) Proxy.newProxyInstance(
        getClass().getClassLoader(), // 1. 类加载器
        new Class<?>[]{Hello.class}, // 2. 代理须要实现的接口，能够有多个
        new LogInvocationHandler(new HelloImp()));// 3. 方法调用的实际处理者
 System.out.println(hello.sayHello("I love you!"));

运行上述代码输出结果：spring

日志信息: You said: [I love you!]
  HelloImp: I love you!

上述代码的关键是Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler)方法，该方法会根据指定的参数动态建立代理对象。三个参数的意义以下：编程

  1. loader，指定代理对象的类加载器；
  2. interfaces，代理对象须要实现的接口，能够同时指定多个接口；
  3. handler，方法调用的实际处理者，代理对象的方法调用都会转发到这里（*注意1）。

newProxyInstance()会返回一个实现了指定接口的代理对象，对该对象的全部方法调用都会转发给InvocationHandler.invoke()方法。理解上述代码须要对Java反射机制有必定了解。动态代理神奇的地方就是：后端

  1. 代理对象是在程序运行时产生的，而不是编译期；
  2. 对代理对象的全部接口方法调用都会转发到InvocationHandler.invoke()方法，在invoke()方法里咱们能够加入任何逻辑，好比修改方法参数，加入日志功能、安全检查功能等；以后咱们经过某种方式执行真正的方法体，示例中经过反射调用了Hello对象的相应方法，还能够经过RPC调用远程方法。

注意1：对于从Object中继承的方法，JDK Proxy会把hashCode()、equals()、toString()这三个非接口方法转发给InvocationHandler，其他的Object方法则不会转发。详见JDK Proxy官方文档。api

若是对JDK代理后的对象类型进行深挖，能够看到以下信息：安全

# Hello代理对象的类型信息
class=class jdkproxy.$Proxy0
        superClass=class java.lang.reflect.Proxy
        interfaces:
interface jdkproxy.Hello
        invocationHandler=jdkproxy.LogInvocationHandler@a09ee92

代理对象的类型是jdkproxy.$Proxy0，这是个动态生成的类型，类名是形如$ProxyN的形式；父类是java.lang.reflect.Proxy，全部的JDK动态代理都会继承这个类；同时实现了Hello接口，也就是咱们接口列表中指定的那些接口。oracle

若是你还对jdkproxy.$Proxy0具体实现感兴趣，它大体长这个样子：

// JDK代理类具体实现
public final class $Proxy0 extends Proxy implements Hello {
  ...

    public $Proxy0(InvocationHandler invocationhandler) {
        super(invocationhandler);
    }
  ...

    @Override
    public final String sayHello(String str) {
    ...
        return super.h.invoke(this, m3, new Object[]{str});// 将方法调用转发给invocationhandler
    ...
    }
  ...
}

这些逻辑没什么复杂之处，可是他们是在运行时动态产生的，无需咱们手动编写。更多详情，可参考BrightLoong的Java静态代理&动态代理笔记

Java动态代理为咱们提供了很是灵活的代理机制，但Java动态代理是基于接口的，若是对象没有实现接口咱们该如何代理呢？CGLIB登场。

CGLIB动态代理

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它容许咱们在运行时对字节码进行修改和动态生成。CGLIB经过继承方式实现代理。

来看示例，假设咱们有一个没有实现任何接口的类HelloConcrete：

public class HelloConcrete {

    public String sayHello(String str) {
        return "HelloConcrete: " + str;
    }
}

由于没有实现接口该类没法使用JDK代理，经过CGLIB代理实现以下：

  1. 首先实现一个MethodInterceptor，方法调用会被转发到该类的intercept()方法。
  2. 而后在须要使用HelloConcrete的时候，经过CGLIB动态代理获取代理对象。
// CGLIB动态代理
// 1. 首先实现一个MethodInterceptor，方法调用会被转发到该类的intercept()方法。
class MyMethodInterceptor implements MethodInterceptor {
  ...

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        logger.info("You said: " + Arrays.toString(args));
        return proxy.invokeSuper(obj, args);
    }
}
    // 2. 而后在须要使用HelloConcrete的时候，经过CGLIB动态代理获取代理对象。
    Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HelloConcrete.class);
        enhancer.setCallback(new MyMethodInterceptor());
        HelloConcrete hello=(HelloConcrete)enhancer.create();
        System.out.println(hello.sayHello("I love you!"));

运行上述代码输出结果：

日志信息: You said: [I love you!]
  HelloConcrete: I love you!

上述代码中，咱们经过CGLIB的Enhancer来指定要代理的目标对象、实际处理代理逻辑的对象，最终经过调用create()方法获得代理对象，对这个对象全部非final方法的调用都会转发给MethodInterceptor.intercept()方法，在intercept()方法里咱们能够加入任何逻辑，好比修改方法参数，加入日志功能、安全检查功能等；经过调用MethodProxy.invokeSuper()方法，咱们将调用转发给原始对象，具体到本例，就是HelloConcrete的具体方法。CGLIG中MethodInterceptor的做用跟JDK代理中的InvocationHandler很相似，都是方法调用的中转站。

注意：对于从Object中继承的方法，CGLIB代理也会进行代理，如hashCode()、equals()、toString()等，可是getClass()、wait()等方法不会，由于它是final方法，CGLIB没法代理。

若是对CGLIB代理以后的对象类型进行深挖，能够看到以下信息：

# HelloConcrete代理对象的类型信息
class=class cglib.HelloConcrete$$EnhancerByCGLIB$$e3734e52
        superClass=class lh.HelloConcrete
        interfaces:
interface net.sf.cglib.proxy.Factory
        invocationHandler=not java proxy class

咱们看到使用CGLIB代理以后的对象类型是cglib.HelloConcrete$$EnhancerByCGLIB$$e3734e52，这是CGLIB动态生成的类型；父类是HelloConcrete，印证了CGLIB是经过继承实现代理；同时实现了net.sf.cglib.proxy.Factory接口，这个接口是CGLIB本身加入的，包含一些工具方法。

注意，既然是继承就不得不考虑final的问题。咱们知道final类型不能有子类，因此CGLIB不能代理final类型，遇到这种状况会抛出相似以下异常：

java.lang.IllegalArgumentException: Cannot subclass final class cglib.HelloConcrete

一样的，final方法是不能重载的，因此也不能经过CGLIB代理，遇到这种状况不会抛异常，而是会跳过final方法只代理其余方法。

若是你还对代理类cglib.HelloConcrete$$EnhancerByCGLIB$$e3734e52具体实现感兴趣，它大体长这个样子：

// CGLIB代理类具体实现
public class HelloConcrete$$EnhancerByCGLIB$$e3734e52
        extends HelloConcrete
        implements Factory {
  ...
    private MethodInterceptor CGLIB$CALLBACK_0; // ~~
  ...

    public final String sayHello(String paramString) {
    ...
        MethodInterceptor tmp17_14 = CGLIB$CALLBACK_0;
        if (tmp17_14 != null) {
            // 将请求转发给MethodInterceptor.intercept()方法。
            return (String) tmp17_14.intercept(this,
                    CGLIB$sayHello$0$Method,
                    new Object[]{paramString},
                    CGLIB$sayHello$0$Proxy);
        }
        return super.sayHello(paramString);
    }
  ...
}

上述代码咱们看到，当调用代理对象的sayHello()方法时，首先会尝试转发给MethodInterceptor.intercept()方法，若是没有MethodInterceptor就执行父类的sayHello()。这些逻辑没什么复杂之处，可是他们是在运行时动态产生的，无需咱们手动编写。如何获取CGLIB代理类字节码可参考Access the generated byte[] array directly。

更多关于CGLIB的介绍能够参考Rafael Winterhalter的cglib: The missing manual，一篇很深刻的文章。

结语

本文介绍了Java两种常见动态代理机制的用法和原理，JDK原生动态代理是Java原生支持的，不须要任何外部依赖，可是它只能基于接口进行代理；CGLIB经过继承的方式进行代理，不管目标对象有没有实现接口均可以代理，可是没法处理final的状况。

动态代理是Spring AOP(Aspect Orient Programming, 面向切面编程)的实现方式，了解动态代理原理，对理解Spring AOP大有帮助。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程