Java动态代理机制

  代理（Proxy）是一种常见的软件设计方式，具体可以参考https://www.jianshu.com/p/03e90e4a73ab。代理的实现方式主要可以分成两种：静态代理当时和动态代理方式。动态代理在Java中有着广泛的应用，比如Spring AOP，Hibernate数据查询、测试框架的后端mock、RPC，Java注解对象获取等。

静态代理方式

  
  静态代理方式是一种在编译时就确定了代理关系的代理方式。静态代理实现简单，适合于代理类较少且确定的情况。下面有个简单的静态代理实现方式，仅供参考。

interface Hello{
    String sayHello(String str);
}

class HelloImpl implements Hello{

    @Override
    public String sayHello(String str) {
        return "Hello " + str;
    }
}

class StaticProxyHello implements Hello{
    private Hello hello = new HelloImpl();

    @Override
    public String sayHello(String str) {
        System.out.println("static Log : will say Hello " + str);
        return hello.sayHello(str);
    }
    
}

运行示例：

执行代码：

public static void main(String[] args) {
        //static proxy
        Hello hello1 = new StaticProxyHello();
        System.out.println(hello1.sayHello("QuanQuan Matser"));
    }


运行结果：

static Log : will say Hello QuanQuan Matser
Hello QuanQuan Matser

JDK动态代理

  JDK提供了一种原生的动态代理方式，该动态代理方式主要分成两个步骤：

1. 创建一个实现InvocationHandler接口的代理类，方法调用会被转发到该类的invoke()方法。
2. 在需要使用Hello的时候，通过JDK动态代理Proxy.newProxyInstance()生成Hello的代理对象。

interface Hello{
    String sayHello(String str);
}

class HelloImpl implements Hello{

    @Override
    public String sayHello(String str) {
        return "Hello " + str;
    }
}

class helloInvocationHandler implements InvocationHandler{

    private Hello hello;

    public helloInvocationHandler(Hello hello){
        this.hello = hello;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if("sayHello".equals(method.getName())){
            System.out.println("dynamic Log : will say Hello " + Arrays.toString(args));
        }
        return method.invoke(hello, args);
    }
}

执行代码：

public static void main(String[] args) {

        //      dynamic proxy
        Hello hello = new HelloImpl();
        Hello helloProxy = (Hello) Proxy.newProxyInstance(
                HelloImpl.class.getClassLoader(), 
                hello.getClass().getInterfaces(), 
                new helloInvocationHandler(hello));
        System.out.println(helloProxy.sayHello("OKOKOKOK!"));
    }

运行结果：
dynamic Log : will say Hello [OKOKOKOK!]
Hello OKOKOKOK!

  上述代码的关键是Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler)方法，该方法会根据指定的参数动态创建代理对象。三个参数的意义如下：
loader，指定代理对象的类加载器；
interfaces，代理对象需要实现的接口，可以同时指定多个接口；
handler，方法调用的实际处理者，代理对象的方法调用都会转发到这里（）。
  newProxyInstance()会返回一个实现了指定接口的代理对象，对该对象的所有方法调用都会转发给InvocationHandler.invoke()方法。理解上述代码需要对Java反射机制有一定了解。动态代理神奇的地方就是：

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

CGLIB动态代理

  虽然Java动态代理为我们提供了非常灵活的代理机制，但Java动态代理是基于接口的，如果对象没有实现接口我们该如何代理呢？CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB以继承的方式实现代理。通过CGLIB的动态代理实现方式如下：

1. 实现一个MethodInterceptor，方法调用会被转发到该类的intercept()方法。
2. 在需要使用CglibHello的时候，通过CGLIB动态代理获取代理对象。
     具体可以参考如下示例：

class CglibHello{
    public String sayHello(String str) {
        return "Hello " + str;
    }
}

class CglibProxy implements MethodInterceptor{

    /** 
     * 重写方法拦截在方法前和方法后加入业务 
     * Object obj为目标对象 
     * Method method为目标方法 
     * Object[] params 为参数， 
     * MethodProxy proxy CGlib方法代理对象 
     */ 
    @Override
    public Object intercept(Object obj, Method method, 
            Object[] params, MethodProxy proxy) throws Throwable {
        System.out.println("before cglib Proxy...");
        Object res = proxy.invokeSuper(obj, params);
        System.out.println("after cglib Proxy...");
        return res;
    }

}

执行代码：
public static void main(String[] args) {
        //cglib dynamic proxy
        Enhancer enhancer =new Enhancer();
        enhancer.setSuperclass(CglibHello.class);
        enhancer.setCallback(new CglibProxy());
        CglibHello hello3 = (CglibHello)enhancer.create();
        System.out.println(hello3.sayHello("ciglib proxy!"));
}

运行结果：
before cglib Proxy...
after cglib Proxy...
Hello ciglib proxy!

总结

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

参考：http://www.importnew.com/27772.html