Java 动态代理以及Cglib代理

代理为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。代理模式通常也作为AOP(面向切面编程)的底层技术实现。通过AOP可以有效的降低模块间的耦合，也可以进一步补充了OOP。

Java本身提供了Proxy和InvocationHandler实现了动态的代理。

InvocationHandler接口中声明了一个方法：

/**
* @param proxy 被代理的对象
* @param method 要调用的方法
* @param args 调用方法所需的参数
* @return
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;

Proxy,通过该类配合InvocationHandler可以生成目标对象的代理。

/**
*
* @param loader 被代理对象的类加载器
* @param interfaces 被代理对象所实现的接口
* @param h 方法调用处理器
* @return
* @throws IllegalArgumentException
*/
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException

代码示例：
首先定义一个接口，Animal:包含吃东西和睡觉两个动作。

package org.antstudio;

/**
* Created by Gavin on 14-7-27.
*/
public interface Animal {

public void eat();
public void sleep();

}

然后定义一个Person，实现Animal接口：

package org.antstudio;

/**
* @author Gavin
* @date 14-7-27 下午2:09
*/
public class Person implements Animal{

private String name;

public Person(String name){
this.name = name;
}
public void eat(){
System.out.println(name+" Eating...");
}

public void sleep(){
System.out.println(name+" Sleeping...");
}

}

Person代理类：

package org.antstudio.proxy;

import org.antstudio.Animal;
import org.antstudio.Person;

import java.io.*;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
* @author Gavin
* @date 14-7-27 13:45
*/
public class SimpleProxy implements InvocationHandler{

private Object target;

public Animal getProxy(Animal o){
this.target = o;
return (Animal)Proxy.newProxyInstance(o.getClass().getClassLoader(), new Class[]{Animal.class}, this);
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
System.out.println("Simple Proxy before method:"+methodName);
Object result = method.invoke(target,args);
//这里如果使用proxy来处理方法的调用会抛出异常,因为proxy方法的调用，会触发拦截器，而拦截器又会触发方法调用，产生死循环
System.out.println("Simple Proxy after method:"+methodName);
return result;
}

public static void main(String[] args) throws IOException {
Person person = new Person("Gavin");
Animal proxy = new SimpleProxy().getProxy(person);
proxy.eat();
proxy.sleep();

}
}

输出：

Simple Proxy before method:eat
Gavin Eating...
Simple Proxy after method:eat
Simple Proxy before method:sleep
Gavin Sleeping...
Simple Proxy after method:sleep

可以看到，调用代理Person的方法，都会经过InvocationHandler里的invoke方法。 

Proxy.newProxyInstance 创建的代理类是class sun.proxy.$Proxy，它具有所有Person的方法，其方法内部则是直接调用InvocationHandler.invoke(xxx)函数。

Cglib动态代理，Java本身提供的动态代理使用也很方便，但有一个缺点，就是被代理的对象必须实现接口。也就是说Java本身的代理不能代理没有实现接口的对象。Cglib是基于ASM字节码操作框架的动态代理生成框架。它可以对没有接口实现的对象进行代理。

Cglib需要使用MethodInterceptor方法拦截器进行，示例代码如下：

AnimalMethodInterceptor 定义一个Animal方法的拦截器：

package org.antstudio.proxy;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
* @author Gavin
* @date 14-7-27 下午4:43
*/
public class AnimalMethodInterceptor implements MethodInterceptor{

@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("Cglib proxy before method:"+method.getName());
Object result =  methodProxy.invokeSuper(o, objects);
//如果这里调用  method.invoke(o,objects)-->会抛出异常,因为调用method时，会触发拦截器，在拦截器里又调用method，会产生死循环
System.out.println("Cglib proxy after method:"+method.getName());
return result;
}
}

代理类：

package org.antstudio.proxy;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import org.antstudio.Person;

/**
* @author Gavin
* @date 14-7-27 下午5:05
*/
public class CglibProxy {

private MethodInterceptor methodInterceptor;

public CglibProxy(MethodInterceptor methodInterceptor){
this.methodInterceptor = methodInterceptor;
}

public <T> T getProxy(T o){
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(o.getClass());
enhancer.setCallback(methodInterceptor);
return (T) enhancer.create(new Class[]{String.class},new Object[]{"Gavin"});
}

public static void main(String[] args) {
CglibProxy cglibProxy = new CglibProxy(new AnimalMethodInterceptor());
Person person = (Person) cglibProxy.getProxy(new Person("Gavin"));
person.eat();
}
}

输出：

Cglib proxy before method:eat
Gavin Eating...
Cglib proxy after method:eat

可以看到Cglib主要以继承的形式进行代理，那么Cglib就相应的无法对final类进行代理了，因为final类无法继承。

源码地址：https://github.com/gavincook/proxy