一、背景
今天有小伙伴面试的时候被问到：spring aop中jdk 和 cglib动态代理哪个效率更高？
二、基本概念
首先，我们知道spring aop的底层实现有两种方式：一种是jdk动态代理，另一种是cglib的方式。
自java 1.3以后，java提供了动态代理技术，允许开发者在运行期创建接口的代理实例，后来这项技术被用到了spring的很多地方。
jdk动态代理主要涉及java.lang.reflect包下边的两个类：proxy和invocationhandler。其中，invocationhandler是一个接口，可以通过实现该接口定义横切逻辑，并通过反射机制调用目标类的代码，动态地将横切逻辑和业务逻辑贬值在一起。
jdk动态代理的话，他有一个限制，就是它只能为接口创建代理实例，而对于没有通过接口定义业务方法的类，如何创建动态代理实例哪？答案就是cglib。
cglib采用底层的字节码技术，全称是：code generation library，cglib可以为一个类创建一个子类，在子类中采用方法拦截的技术拦截所有父类方法的调用并顺势织入横切逻辑。
三、jdk 和 cglib动态代理区别
1、jdk动态代理具体实现原理：
- 通过实现invocationhandlet接口创建自己的调用处理器；
- 通过为proxy类指定classloader对象和一组interface来创建动态代理；
- 通过反射机制获取动态代理类的构造函数，其唯一参数类型就是调用处理器接口类型；
- 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数参入；
jdk动态代理是面向接口的代理模式，如果被代理目标没有接口那么spring也无能为力，spring通过java的反射机制生产被代理接口的新的匿名实现类，重写了其中aop的增强方法。
2、cglib动态代理：
cglib是一个强大、高性能的code生产类库，可以实现运行期动态扩展java类，spring在运行期间通过 cglib继承要被动态代理的类，重写父类的方法，实现aop面向切面编程呢。
3、两者对比：
- jdk动态代理是面向接口的。
- cglib动态代理是通过字节码底层继承要代理类来实现（如果被代理类被final关键字所修饰，那么抱歉会失败）。
4、使用注意：
- 如果要被代理的对象是个实现类，那么spring会使用jdk动态代理来完成操作（spirng默认采用jdk动态代理实现机制）；
- 如果要被代理的对象不是个实现类那么，spring会强制使用cglib来实现动态代理。
四、jdk 和 cglib动态代理性能对比-教科书上的描述
我们不管是看书还是看文章亦或是我那个上搜索参考答案，可能很多时候，都可以找到如下的回答：
关于两者之间的性能的话，jdk动态代理所创建的代理对象，在以前的jdk版本中，性能并不是很高，虽然在高版本中jdk动态代理对象的性能得到了很大的提升，但是他也并不是适用于所有的场景。主要体现在如下的两个指标中：
1、cglib所创建的动态代理对象在实际运行时候的性能要比jdk动态代理高不少，有研究表明，大概要高10倍；
2、但是cglib在创建对象的时候所花费的时间却比jdk动态代理要多很多，有研究表明，大概有8倍的差距；
3、因此，对于singleton的代理对象或者具有实例池的代理，因为无需频繁的创建代理对象，所以比较适合采用cglib动态代理，反正，则比较适用jdk动态代理。
结果是不是如上边1、2、3条描述的那样哪？下边我们做一些小实验分析一下！
五、性能测试
1、首先有几个java类
2、target.java
|
1
2
3
4
|
package com.java.proxy.test;
public interface target {
int test(int i);
}
|
3、targetimpl.java
|
1
2
3
4
5
6
7
|
package com.java.proxy.test;
public class targetimpl implements target {
@override
public int test(int i) {
return i + 1;
}
}
|
4、jdkdynamicproxytest.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package com.java.proxy.test;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
public class jdkdynamicproxytest implements invocationhandler {
private target target;
private jdkdynamicproxytest(target target) {
this.target = target;
}
public static target newproxyinstance(target target) {
return (target) proxy.newproxyinstance(jdkdynamicproxytest.class.getclassloader(),
new class<?>[]{target.class},
new jdkdynamicproxytest(target));
}
@override
public object invoke(object proxy, method method, object[] args) throws throwable {
return method.invoke(target, args);
}
}
|
5、cglibproxytest.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package com.java.proxy.test;
import org.springframework.cglib.proxy.enhancer;
import org.springframework.cglib.proxy.methodinterceptor;
import org.springframework.cglib.proxy.methodproxy;
import java.lang.reflect.method;
public class cglibproxytest implements methodinterceptor {
private cglibproxytest() {
}
public static <t extends target> target newproxyinstance(class<t> targetinstanceclazz) {
enhancer enhancer = new enhancer();
enhancer.setsuperclass(targetinstanceclazz);
enhancer.setcallback(new cglibproxytest());
return (target) enhancer.create();
}
@override
public object intercept(object obj, method method, object[] args, methodproxy proxy) throws throwable {
return proxy.invokesuper(obj, args);
}
}
|
6、proxyperformancetest.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
package com.java.proxy.test;
import java.util.linkedhashmap;
import java.util.map;
public class proxyperformancetest {
public static void main(string[] args) {
//创建测试对象
target nativetest = new targetimpl();
target dynamicproxy = jdkdynamicproxytest.newproxyinstance(nativetest);
target cglibproxy = cglibproxytest.newproxyinstance(targetimpl.class);
//预热一下
int preruncount = 10000;
runwithoutmonitor(nativetest, preruncount);
runwithoutmonitor(cglibproxy, preruncount);
runwithoutmonitor(dynamicproxy, preruncount);
//执行测试
map<string, target> tests = new linkedhashmap<string, target>();
tests.put("native ", nativetest);
tests.put("dynamic ", dynamicproxy);
tests.put("cglib ", cglibproxy);
int repeatcount = 3;
int runcount = 1000000;
runtest(repeatcount, runcount, tests);
runcount = 50000000;
runtest(repeatcount, runcount, tests);
}
private static void runtest(int repeatcount, int runcount, map<string, target> tests) {
system.out.println(
string.format("\n===== run test : [repeatcount=%s] [runcount=%s] [java.version=%s] =====",
repeatcount, runcount, system.getproperty("java.version")));
for (int i = 0; i < repeatcount; i++) {
system.out.println(string.format("\n--------- test : [%s] ---------", (i + 1)));
for (string key : tests.keyset()) {
runwithmonitor(tests.get(key), runcount, key);
}
}
}
private static void runwithoutmonitor(target target, int runcount) {
for (int i = 0; i < runcount; i++) {
target.test(i);
}
}
private static void runwithmonitor(target target, int runcount, string tag) {
long start = system.currenttimemillis();
for (int i = 0; i < runcount; i++) {
target.test(i);
}
long end = system.currenttimemillis();
system.out.println("[" + tag + "] total time:" + (end - start) + "ms");
}
}
|
7、测试结果
（1）jdk 1.6
（2）jdk 1.7
（3）jdk 1.8
经过多次试验，可以看出平均情况下的话，jdk动态代理的运行速度已经逐渐提高了，在低版本的时候，运行的性能可能不如cglib，但是在1.8版本中运行多次，基本都可以得到一致的测试结果，那就是jdk动态代理已经比cglib动态代理快了！
但是jdk动态代理和cglib动态代理的适用场景还是不一样的哈！
六、总结
最终的测试结果大致是这样的，在1.6和1.7的时候，jdk动态代理的速度要比cglib动态代理的速度要慢，但是并没有教科书上的10倍差距，在jdk1.8的时候，jdk动态代理的速度已经比cglib动态代理的速度快很多了，希望小伙伴在遇到这个问题的时候能够有的放矢！
spring aop中的jdk和cglib动态代理关于这个知识点很重要，关于两者之间性能的对比经过测试实验已经有了一个初步的结果，以后再有人问你spring aop，不要简单的说jdk动态代理和cglib这两个了，是时候的可以抛出来对两者之间区别的理解，是有加分的哦！
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对服务器之家的支持。如果你想了解更多相关内容请查看下面相关链接
原文链接：https://blog.csdn.net/xlgen157387/article/details/82497594