深入剖析动态代理--性能比较

原文：http://blog.csdn.net/liutengteng130/article/details/46565309

动态代理是指在运行时，动态生成代理类。代理类的字节码将在运行时生成并载入当前的ClassLoader.

生成动态代理类的方法很多，如JDK自带的动态代理、CGLIB、Javassist或者ASM库。

JDK动态代理使用简单，它内置在JDK中，因此不需要引入第三方Jar包，但相对功能比较弱。CGLIB和Javassist都是高级的字节码生成库，总体性能比JDK自带的动态代理好，而且功能十分强大。ASM是低级的字节码生成工具，使用ASM已经近乎在于使用Javabytecode编程，对开发人员要求较高，也是性能最好的一种动态代理生辰工具。但ASM的使用是在过于繁琐，而且性能也没有数量级的提升，与CGLIB等高级字节码生成工具相比，ASM程序的可维护性也较差。

JDK实现

1、步骤

1）通过实现InvocationHandler接口创建自己的调用处理器

2）通过为Proxy类指定ClassLoader对象和一组interface来创建动态代理类

3）通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型

4）通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入

2、创建代理

//InvocationHandlerImpl实现了InvocationHandler接口，并能实现方法调用从代理类到委托类的分派转发
//其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
InvocationHandlerhandler=newInvocaitonHandlerImpl(..);

//通过Proxy为包括Interface接口在内的一组接口动态创建代理类的对象
Classclazz=Proxy.getProxyClass(classLoader,newClass[]{Interface.class,...});

//通过反射从生成的类对象获得构造函数对象
Constructorconstructor=clazz.getConstructor(newClass[]{InvocationHandler.class});

//通过构造函数对象创建动态代理类实例
InterfaceProxy=(Interface)constructor.newInstance(newObject[]{handler});

//Proxy类的静态方法newProxyInstance对上面具体步骤的后三步做了封装，简化了动态代理对象的获取过程。
//InvocationHandlerImpl实现了InvocaitonHandler接口，并能实现方法调用从代理类到委托类的分派转发
InvocaitonHandlerhandler=newInvocationHandlerImpl(..);
//通过Proxy直接创建动态代理类实例

nterfaceproxy=(Interface)Proxy.newProxyInstance(classLoader,newClass[]{Interface.class},handler);

3、代码

/**
*接口
*@authorEmily
*
*/
publicinterfaceIDBQuery{

Stringrequest();
}

/**
*真实的实现类，具体的目标对象
*@authorEmily
*
*/
publicclassDBQueryimplementsIDBQuery{


publicDBQuery(){
try{
Thread.sleep(1000);//可能包含数据库连接等耗时操作
}catch(InterruptedExceptione){
e.printStackTrace();
}
}

@Override
publicStringrequest(){

return"requeststring";
}

}

/**
*JDK动态代理的实现类
*@authorEmily
*
*/
publicclassJdkDbQueryHandlerimplementsInvocationHandler{

IDBQueryreal=null;//主题接口

/**
*生成Handler
*/
@Override
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)
throwsThrowable{
if(real==null)
real=newDBQuery();//如果是第一次调用，则生成真实对象
returnreal.request();//使用真实主题完成实际的操作
}

/**
*利用Handler生成动态代理对象
*@return
*/
publicstaticIDBQuerycreateJdkProxy(){

//根据指定的类加载器和接口以及截获器，返回代理类的一个实例对象
//ClassLoaderloader:指定被代理对象的类加载器
//Class[]Interfaces：指定被代理对象所以事项的接口
//InvocationHandlerh:指定需要调用的InvocationHandler对象
IDBQueryjdkProxy=(IDBQuery)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),newClass[]{IDBQuery.class},newJdkDbQueryHandler());
returnjdkProxy;
}


}

执行过程：

如图，目标对象的方法调用被Proxy拦截，在InvocationHandler中的回调方法中通过反射调用，这种动态代理的方法实现了对类的方法的运行时修改。

JDK动态代理有个缺点，那就是不能对类进行代理，只能对接口进行代理，如果我们的类没有实现任何接口，那么就不能使用这种方式进行动态代理（因为$Proxy()这个类集成了Proxy,Java的集成不允许出现多个父类）。准确的说这不应该是缺点，一个良好的系统，每个类都应该有一个接口与之对应。针对接口编程。

CGLIB实现

packagecom.ltt.dynamic;

importjava.lang.reflect.Method;

importnet.sf.cglib.proxy.Enhancer;
importnet.sf.cglib.proxy.MethodInterceptor;
importnet.sf.cglib.proxy.MethodProxy;

/**
*CGLIB动态代理
*@authorEmily
*
*/
publicclassCglibDbQueryInterceptorimplementsMethodInterceptor{
IDBQueryreal=null;

/**
*处理代理逻辑的切入类
*/
@Override
publicObjectintercept(Objectarg0,Methodarg1,Object[]arg2,
MethodProxyarg3)throwsThrowable{
if(real==null){//代理类的内部逻辑
real=newDBQuery();
returnreal.request();
}
returnnull;
}

/**
*生成动态代理
*@return
*/
publicstaticIDBQuerycreateCglibProxy(){
Enhancerenhancer=newEnhancer();
//指定切入器，定义代理类逻辑
enhancer.setCallback(newCglibDbQueryInterceptor());
//指定实现的接口
enhancer.setInterfaces(newClass[]{IDBQuery.class});

IDBQuerycglibProxy=(IDBQuery)enhancer.create();
returncglibProxy;
}


}

Javassist实现

一种是使用代理工厂创建，另一种通过使用动态代码创建。使用代理工厂创建时，方法与CGLIB类似，也需要实现一个用于代理逻辑处理的Handler：例如createJavassistDynProxy()；使用动态代码创建，生成字节码，这种方式可以非常灵活，甚至可以在运行时生成业务逻辑，如createJavassistBytecodeDynamicProxy()方法。

/**
*Javassist动态代理
*@authorEmily
*
*/
publicclassJavassistDynDbQueryHandlerimplementsMethodHandler{

IDBQueryreal=null;

/*
*(non-Javadoc)实现用于代理逻辑处理的Handler
*@seejavassist.util.proxy.MethodHandler#invoke(java.lang.Object,java.lang.reflect.Method,java.lang.reflect.Method,java.lang.Object[])
*/
@Override
publicObjectinvoke(Objectarg0,Methodarg1,Methodarg2,Object[]arg3)
throwsThrowable{
if(real==null)
real=newDBQuery();
returnreal.request();

}

/**
*创建动态代理
*@return
*@throwsException
*/
publicstaticIDBQuerycreateJavassistDynProxy()throwsException{
ProxyFactoryproxyFactory=newProxyFactory();
proxyFactory.setInterfaces(newClass[]{IDBQuery.class});//指定接口
ClassproxyClass=proxyFactory.createClass();
IDBQueryjavassistProxy=(IDBQuery)proxyClass.newInstance();//设置Handler处理器
((ProxyObject)javassistProxy).setHandler(newJavassistDynDbQueryHandler());
returnjavassistProxy;
}

/**
*运行时生成业务逻辑
*@return
*@throwsException
*/
publicstaticIDBQuerycreateJavassistBytecodeDynamicProxy()throwsException{
ClassPoolmPool=newClassPool(true);
//定义类名
CtClassmCtc=mPool.makeClass(IDBQuery.class.getName()+"JavaassistBytecodeProxy");
//需要实现接口
mCtc.addInterface(mPool.get(IDBQuery.class.getName()));
//添加构造函数
mCtc.addConstructor(CtNewConstructor.defaultConstructor(mCtc));

//添加类的字段信息，使用动态Java代码
mCtc.addField(CtField.make("public"+IDBQuery.class.getName()+"real;",mCtc));
StringdbQueryname=DBQuery.class.getName();
//添加方法，这里使用动态Java代码指定内部逻辑
mCtc.addMethod(CtNewMethod.make("publicStringrequest(){if(real==null)real=new"+dbQueryname+"();returnreal.request();}",mCtc));

//基于以上信息，生成动态类
Classpc=mCtc.toClass();
//生成动态类的实例
IDBQuerybytecodeProxy=(IDBQuery)pc.newInstance();
returnbytecodeProxy;
}

}

三种动态代理：JDK动态代理创建速度优于CGLIB动态代理，但是在函数的调用性能上远不如CGLIB和Javassist。故CGLIB和Javassist整体性能上比JDK动态代理好。

性能比较：

CreateJDKProxy:13ms
CreateCGLIBProxy:217ms
CreateJAVAASSISTProxy:99ms
CreateJAVAASSISTBytecodeProxy:168ms
================
RunJDKProxy:2224ms,634,022t/s
RunCGLIBProxy:1123ms,1,255,623t/s
RunJAVAASSISTProxy:3212ms,438,999t/s
RunJAVAASSISTBytecodeProxy:206ms,6,844,977t/s
----------------
RunJDKProxy:2169ms,650,099t/s
RunCGLIBProxy:1059ms,1,331,506t/s
RunJAVAASSISTProxy:3328ms,423,697t/s
RunJAVAASSISTBytecodeProxy:202ms,6,980,521t/s
----------------
RunJDKProxy:2174ms,648,604t/s
RunCGLIBProxy:1032ms,1,366,342t/s
RunJAVAASSISTProxy:3119ms,452,088t/s
RunJAVAASSISTBytecodeProxy:207ms,6,811,910t/s
----------------

Javassist字节码最快，CGLIB次之，是JDK的两倍。

它们都是通过字节码生成来实现动态代理的。只不过是它们生成的字节码不一样，像JDK，CGLIB都考虑了很多因素，以及继承或包装了自己的一些类，所以生成的字节码非常大，而我们很多时候用不上这些，手工生成的字节码非常小（Javassist是手工生成的字节码），所以速度快。

另外，ASM也是手工生成的字节码，速度也很快，但是它没有一个数量级，通常情况下选用Javassist生成字节码的方式。