动态代理解读

动态代理解读

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

---

###目录

• 静态代理
• JDK动态代理
• CGLIB动态代理

---

1. 静态代理

先从直观的示例说起，假设我们有一个接口Hello和一个简单实现HelloImp：

public interface Hello {
String sayHello(String str);
}
@Override
public String sayHello(String str) {
return “HelloImpl:” + str;
}

 //静态代理方式
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接口。

2. JDK原生动态代理

首先实现一个InvocationHandler，方法调用会被转发到该类的invoke()方法。然后在需要使用Hello的时候，通过JDK动态代理获取Hello的代理对象。

public 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 {
    addClassToDisk(proxy.getClass().getName(),HelloImpl.class,"D:/proxy.class");
    if("sayHello".equals(method.getName())) {
        System.out.println("invoke You said: " + Arrays.toString(args));
    }
    return method.invoke(hello, args);
}

public static void main(String[] args) {
    Hello hello = (Hello)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
            new Class[]{Hello.class},new LogInvocationHandler(new HelloImpl()));
    System.out.println(hello.sayHello("ni hao"));

}

private void addClassToDisk(String className, Class<?cl, String path) {
    //用于生产代理对象的字节码
    byte[] classFile = ProxyGenerator.generateProxyClass(className, cl.getInterfaces());
    FileOutputStream out = null;
    try {
        out = new FileOutputStream(path);
        //将代理对象的class字节码写到硬盘上
        out.write(classFile);
        out.flush();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 }
}

运行上述代码输出结果：
invoke You said: [ni hao]
You said: [ni hao]

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

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

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

代理对象是在程序运行时产生的，而不是编译期；
对代理对象的所有接口方法调用都会转发到InvocationHandler.invoke()方法，在invoke()方法里我们可以加入任何逻辑，比如修改方法参数，加入日志功能、安全检查功能等；之后我们通过某种方式执行真正的方法体，示例中通过反射调用了Hello对象的相应方法，还可以通过RPC调用远程方法。
*****注意1：**对于从Object中继承的方法，JDK Proxy会把hashCode()、equals()、toString()这三个非接口方法转发给InvocationHandler，其余的Object方法则不会转发。详见JDK Proxy官方文档。

如果对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接口，也就是我们接口列表中指定的那些接口。

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

代理类的代码

public final class $Proxy0 extends Proxy implements Hello {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;

public $Proxy0(InvocationHandler var1) throws  {
    super(var1);
}

public final boolean equals(Object var1) throws  {...
}

public final String sayHello(String var1) throws  {
    try {
        return (String)super.h.invoke(this, m3, new Object[]{var1});
    } catch (RuntimeException | Error var3) {
        throw var3;
    } catch (Throwable var4) {
        throw new UndeclaredThrowableException(var4);
    }
}

public final String toString() throws  {..
}

public final int hashCode() throws  {..
}

static {
    try {
        m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
        m3 = Class.forName("com.zhou.proxy.jdk.Hello").getMethod("sayHello", Class.forName     
        ("java.lang.String"));
        m2 = Class.forName("java.lang.Object").getMethod("toString");
        m0 = Class.forName("java.lang.Object").getMethod("hashCode");
    } catch (NoSuchMethodException var2) {
        throw new NoSuchMethodError(var2.getMessage());
    } catch (ClassNotFoundException var3) {
        throw new NoClassDefFoundError(var3.getMessage());
    }
  }
}

3. CGLIB动态代理

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB通过继承方式实现代理。
来看示例，假设我们有一个没有实现任何接口的类HelloConcrete：

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

因为没有实现接口该类无法使用JDK代理，通过CGLIB代理实现如下：

首先实现一个MethodInterceptor，方法调用会被转发到该类的intercept()方法。
然后在需要使用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无法代理。
注意，既然是继承就不得不考虑final的问题。我们知道final类型不能有子类，所以CGLIB不能代理final类型，遇到这种情况会抛出类似如下异常：

java.lang.IllegalArgumentException: Cannot subclass final class cglib.HelloConcrete
同样的，final方法是不能重载的，所以也不能通过CGLIB代理，遇到这种情况不会抛异常，而是会跳过final方法只代理其他方法。