转载:http://budairenqin.iteye.com/blog/1500366
新项目开始之前领导让研究下公司原有的框架(基于struts1.2.9+spring2.0.6),比较古老了。读service基类时发现竟然将request穿透到了service层(request为BaseService的实例变量),这样service就变成了有状态Bean,使service层变成了非线程安全,导致用Spring容器管理service的时候不得不使用prototype的scope
我们知道,service由于要做事务的包装,需要创建代理对象,spring中使用JDK动态代理或者CGLIB动态代理来创建代理对象,据说JDK动态代理创建对象的时间快于CGLIB,但是性能比CGLIB差(接下来我会测试这个观点),所以我得出以下结论:
1.spring在bean的scope为prototype的情况下,因为是延迟实例化bean,所以最好使用JDK的API创建代理对象;
2.反之对于singleton对象,spring默认是容器启动时就初始化bean,最好使用CGLIB来创建对象
把service配置成singleton我觉得性能方面显然要更好些,如果非要将request穿透到service层,是不是可以考虑用ThreadLocal?
在测试之前,我们先确定spring是以什么方式使用JDK动态代理和CGLIB的,如图:
JDK动态代理:
CGLIB动态代理:
接下来对测试下JDK动态代理和CGLIB动态代理的性能(CGLIB测试代码也和spring一样使用MethodInterceptor)
先贴上测试代码
- public interface CountService {
- int count();
- }
- public class CountServiceImpl implements CountService {
- private int count = 0;
- public int count() {
- return ++count;
- }
- }
- import java.io.File;
- import java.io.FileNotFoundException;
- import java.io.FileOutputStream;
- import java.io.IOException;
- import java.lang.reflect.InvocationHandler;
- import java.lang.reflect.Method;
- import java.lang.reflect.Proxy;
- import java.text.DecimalFormat;
- import net.sf.cglib.core.DefaultGeneratorStrategy;
- import net.sf.cglib.proxy.Enhancer;
- import net.sf.cglib.proxy.MethodInterceptor;
- import net.sf.cglib.proxy.MethodProxy;
- @SuppressWarnings("unused")
- public class DynamicProxyPerformanceTest {
- public static void main(String[] args) throws Exception {
- CountService delegate = new CountServiceImpl();
- long time = System.currentTimeMillis();
- CountService jdkProxy = createJdkDynamicProxy(delegate);
- time = System.currentTimeMillis() - time;
- System.out.println("Create JDK Proxy: " + time + " ms");
- time = System.currentTimeMillis();
- CountService cglibProxy = createCglibDynamicProxy(delegate);
- time = System.currentTimeMillis() - time;
- System.out.println("Create CGLIB Proxy: " + time + " ms");
- for (int i = 0; i < 3; i++) {
- test(jdkProxy, "Run JDK Proxy: ");
- test(cglibProxy, "Run CGLIB Proxy: ");
- System.out.println("-------------------");
- }
- }
- private static void test(CountService service, String label) throws Exception {
- service.count(); // warm up
- int count = 10000000;
- long time = System.currentTimeMillis();
- for (int i = 0; i < count; i++) {
- service.count();
- }
- time = System.currentTimeMillis() - time;
- System.out.println(label + time + " ms, " + new DecimalFormat().format(count * 1000 / time) + " t/s");
- }
- private static CountService createJdkDynamicProxy(final CountService delegate) {
- CountService jdkProxy = (CountService) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
- new Class[] { CountService.class }, new JdkHandler(delegate));
- // 反汇编字节码用,测试的时候注释掉这段代码,不然影响测试结果
- // 下面一行代码参照java.lang.reflect.Proxy
- // byte[] proxyClassFile =
- // sun.misc.ProxyGenerator.generateProxyClass(
- // jdkProxy.getClass().getName(), jdkProxy.getClass().getInterfaces());
- // try {
- // FileOutputStream fos =
- // new FileOutputStream(new File(jdkProxy.getClass().getName() + ".class"));
- // fos.write(proxyClassFile, 0, proxyClassFile.length);
- // } catch (FileNotFoundException e) {
- // e.printStackTrace();
- // } catch (IOException e) {
- // e.printStackTrace();
- // }
- return jdkProxy;
- }
- private static class JdkHandler implements InvocationHandler {
- final Object delegate;
- JdkHandler(Object delegate) {
- this.delegate = delegate;
- }
- public Object invoke(Object object, Method method, Object[] objects) throws Throwable {
- return method.invoke(delegate, objects);
- }
- }
- private static CountService createCglibDynamicProxy(final CountService delegate) throws Exception {
- Enhancer enhancer = new Enhancer();
- enhancer.setSuperclass(CountServiceImpl.class);
- enhancer.setCallback(new MethodInterceptor() {
- @Override
- public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
- return proxy.invokeSuper(obj, args);
- }
- });
- CountServiceImpl cglibProxy = (CountServiceImpl) enhancer.create();
- // 反汇编字节码用,测试的时候注释掉这段代码,不然影响测试结果
- // 下面一行代码参照net.sf.cglib.core.AbstractClassGenerator类中byte[] b = strategy.generate(this);
- // byte[] proxyClassFile = new DefaultGeneratorStrategy().generate(enhancer);
- // try {
- // FileOutputStream fos =
- // new FileOutputStream(new File(cglibProxy.getClass().getName() + ".class"));
- // fos.write(proxyClassFile, 0, proxyClassFile.length);
- // } catch (FileNotFoundException e) {
- // e.printStackTrace();
- // } catch (IOException e) {
- // e.printStackTrace();
- // }
- return cglibProxy;
- }
- }
数据为执行三次,每次调用一千万次代理方法的结果
测试环境1:
JDK:fastdebug1.6
CGLIB:和spring2.0.6 使用同样的cglib-nodep-2.1_3.jar
CPU:P8400 2.53GHz 2.53GHz
测试结果1:
- Create JDK Proxy: 13 ms
- Create CGLIB Proxy: 201 ms
- Run JDK Proxy: 1571 ms, 897,559 t/s
- Run CGLIB Proxy: 824 ms, 1,711,244 t/s
- -------------------
- Run JDK Proxy: 1519 ms, 928,285 t/s
- Run CGLIB Proxy: 576 ms, 2,448,030 t/s
- -------------------
- Run JDK Proxy: 1546 ms, 912,073 t/s
- Run CGLIB Proxy: 590 ms, 2,389,941 t/s
- -------------------
CGLIB创建代理对象速度大概比JDK Proxy慢15倍,执行速度是JDK Proxy的2倍左右
测试环境2:
JDK:fastdebug1.7
CGLIB:和spring2.0.6 使用同样的cglib-nodep-2.1_3.jar
CPU:P8400 2.53GHz 2.53GHz
测试结果2:
- Create JDK Proxy: 14 ms
- Create CGLIB Proxy: 204 ms
- Run JDK Proxy: 1608 ms, 876,906 t/s
- Run CGLIB Proxy: 529 ms, 2,665,530 t/s
- -------------------
- Run JDK Proxy: 1591 ms, 886,276 t/s
- Run CGLIB Proxy: 405 ms, 3,481,642 t/s
- -------------------
- Run JDK Proxy: 1624 ms, 868,266 t/s
- Run CGLIB Proxy: 405 ms, 3,481,642 t/s
- -------------------
CGLIB创建代理对象速度大概比JDK Proxy慢15倍,执行速度是JDK Proxy的4倍左右
测试环境3:
JDK:jdk1.6.0_21
CGLIB:和spring2.0.6 使用同样的cglib-nodep-2.1_3.jar
CPU:P8400 2.53GHz 2.53GHz
测试结果3:
- Create JDK Proxy: 8 ms
- Create CGLIB Proxy: 99 ms
- Run JDK Proxy: 911 ms, 1,547,821 t/s
- Run CGLIB Proxy: 435 ms, 3,241,529 t/s
- -------------------
- Run JDK Proxy: 870 ms, 1,620,764 t/s
- Run CGLIB Proxy: 399 ms, 3,533,998 t/s
- -------------------
- Run JDK Proxy: 894 ms, 1,577,254 t/s
- Run CGLIB Proxy: 404 ms, 3,490,260 t/s
- -------------------
CGLIB创建代理对象速度大概比JDK Proxy慢10倍以上,执行速度是JDK Proxy的2倍左右
测试环境4:
JDK:jdk1.7.0_02
CGLIB:和spring2.0.6 使用同样的cglib-nodep-2.1_3.jar
CPU:P8400 2.53GHz 2.53GHz
测试结果4:
- Create JDK Proxy: 43 ms
- Create CGLIB Proxy: 129 ms
- Run JDK Proxy: 940 ms, 1,500,069 t/s
- Run CGLIB Proxy: 299 ms, 4,715,937 t/s
- -------------------
- Run JDK Proxy: 921 ms, 1,531,015 t/s
- Run CGLIB Proxy: 269 ms, 5,241,878 t/s
- -------------------
- Run JDK Proxy: 932 ms, 1,512,945 t/s
- Run CGLIB Proxy: 265 ms, 5,321,001 t/s
- -------------------
CGLIB创建代理对象速度大概比JDK Proxy慢3倍,执行速度是JDK Proxy的3倍以上
字节码比较:
把测试代码中被注释的部分打开,生成class文件后执行javap -c 类名
JDK动态代理生成的字节码:
- public final int count() throws ;
- Code:
- 0: aload_0
- 1: getfield #16 // Field java/lang/reflect/Proxy.h:Ljava/lang/reflect/InvocationHandler;
- 4: aload_0
- 5: getstatic #50 // Field m3:Ljava/lang/reflect/Method;
- 8: aconst_null
- 9: invokeinterface #28, 4 // InterfaceMethod java/lang/reflect/InvocationHandler.invoke:(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;
- 14: checkcast #52 // class java/lang/Integer
- 17: invokevirtual #55 // Method java/lang/Integer.intValue:()I
- 20: ireturn
- 21: athrow
- 22: astore_1
- 23: new #42 // class java/lang/reflect/UndeclaredThrowableException
- 26: dup
- 27: aload_1
- 28: invokespecial #45 // Method java/lang/reflect/UndeclaredThrowableException."<init>":(Ljava/lang/Throwable;)V
- 31: athrow
- Exception table:
- from to target type
- 0 21 21 Class java/lang/Error
- 0 21 21 Class java/lang/RuntimeException
- 0 21 22 Class java/lang/Throwable
CGLIB生成的字节码:
- public final int count();
- Code:
- 0: aload_0
- 1: getfield #37 // Field CGLIB$CALLBACK_0:Lnet/sf/cglib/proxy/MethodInterceptor;
- 4: dup
- 5: ifnonnull 17
- 8: pop
- 9: aload_0
- 10: invokestatic #41 // Method CGLIB$BIND_CALLBACKS:(Ljava/lang/Object;)V
- 13: aload_0
- 14: getfield #37 // Field CGLIB$CALLBACK_0:Lnet/sf/cglib/proxy/MethodInterceptor;
- 17: dup
- 18: ifnull 52
- 21: aload_0
- 22: getstatic #43 // Field CGLIB$count$0$Method:Ljava/lang/reflect/Method;
- 25: getstatic #45 // Field CGLIB$emptyArgs:[Ljava/lang/Object;
- 28: getstatic #47 // Field CGLIB$count$0$Proxy:Lnet/sf/cglib/proxy/MethodProxy;
- 31: invokeinterface #53, 5 // InterfaceMethod net/sf/cglib/proxy/MethodInterceptor.intercept:(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;Lnet/sf/cglib/proxy/MethodProxy;)Ljava/lang/Object;
- 36: dup
- 37: ifnonnull 45
- 40: pop
- 41: iconst_0
- 42: goto 51
- 45: checkcast #55 // class java/lang/Number
- 48: invokevirtual #58 // Method java/lang/Number.intValue:()I
- 51: ireturn
- 52: aload_0
- 53: invokespecial #35 // Method CountServiceImpl.count:()I
- 56: ireturn
相关推荐
Spring 框架中 JDK 动态代理和 CGLIB 动态代理是 Spring AOP 中一个非常重要的知识点。Spring AOP 框架会根据实际情况选择使用 JDK 的动态代理还是 CGLIB 的动态代理。 JDK 动态代理是 Java 自带的动态代理机制,它...
本篇文章将深入探讨JDK动态代理和CGLIB代理的区别,以及它们在实际应用中的选择。 首先,JDK动态代理主要依赖于java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。Proxy类用于创建一个代理对象...
JDK动态代理和CGLIB代理是两种常用的实现方式。 首先,我们来看看JDK动态代理。JDK动态代理主要通过`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口来实现。Proxy类用于创建一个代理对象...
在Java世界中,面向切面编程(Aspect Oriented Programming,简称AOP)是一种设计模式,它允许程序员在不...在实际开发中,根据业务需求和性能考虑,选择合适的动态代理方式,可以有效地提高代码的可维护性和扩展性。
在实际开发中,如Spring AOP框架就同时支持JDK和CGLIB动态代理,根据目标类是否实现接口自动选择合适的代理方式。 总结来说,JDK动态代理和CGLIB动态代理都是为了在运行时提供对目标对象的增强,它们通过不同的实现...
Java中的动态代理、反射和...总之,理解和掌握JDK动态代理、CGLIB动态代理、反射和拦截器是提升Java开发技能的关键步骤。通过实际操作这些示例,你将能够更好地应用这些技术到实际项目中,提高代码的灵活性和可维护性。
在Java中,代理模式有多种实现方式,包括静态代理、JDK动态代理和CGLIB动态代理。 **静态代理** 静态代理是最早也是最基础的代理实现方式。在静态代理中,我们需要创建一个代理类,这个代理类与原始类(被代理类)...
本文主要介绍 Java 中两种常见的动态代理方式:JDK 原生动态代理和 CGLIB 动态代理。 一、 代理模式 代理模式是指程序通过代理类来访问目标对象,以达到对目标对象的控制和增强。代理模式的优点是可以在不改变目标...
3. **Callback接口**:CGLIB中的`Callback`接口定义了代理对象如何处理方法调用,常见的实现包括`MethodInterceptor`,它允许你在方法调用前后插入自定义逻辑。 4. **示例代码**: ```java import ...
JDK代理和Cglib代理是两种常用的动态代理实现方式。 **JDK代理(Java Dynamic Proxy)** JDK动态代理是Java标准库提供的一种代理机制,位于`java.lang.reflect`包下的`Proxy`类和`InvocationHandler`接口。JDK代理...
总结,JDK动态代理和CGLIB是Java中实现动态代理的两种主要方式。JDK代理基于接口,适用于简单场景;CGLIB通过字节码技术,适用于更复杂的需求。开发者可以根据项目需求选择合适的方法。对于学习和理解这两种动态代理...
在实际应用中,Spring框架就同时使用了JDK动态代理和CGLIB。当目标对象实现了接口时,Spring会选择JDK动态代理;如果没有实现接口,则使用CGLIB。 总结来说,CGLIB和JDK动态代理都是为了实现运行时的方法拦截,但...
Spring AOP则是在Spring框架中对AOP概念的实现,它利用了JDK动态代理或CGLIB(字节码增强)来实现。Spring AOP的主要目标是分离关注点,将非业务逻辑(如日志、事务管理)从核心业务代码中解耦出来。以下是Spring ...
在Java编程领域,Spring框架是应用最广泛的轻量级开源框架之一,它提供了一系列强大的功能,包括依赖注入、面向切面编程(AOP)...在实际项目中,熟练掌握Spring AOP和JDK动态代理,能够有效地提升开发效率和软件质量。
主要存在两种常见的动态代理技术:JDK动态代理和CGLIB(Code Generation Library)动态代理。本文将深入探讨这两种技术的区别和原理。 **JDK动态代理**: JDK动态代理是Java标准库提供的一种代理机制,位于`java....
动态代理主要分为两种:JDK代理和CGLIB代理。 **JDK代理**是基于接口的代理,它通过`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口实现。当我们的目标对象实现了特定的接口时,我们可以...
JDK和CGLIB是Java中实现动态代理的两种主要方式,它们在Spring框架中扮演着关键角色,尤其是在AOP(面向切面编程)中。 1. **JDK动态代理**: JDK动态代理基于Java的接口机制实现,因此,要使用JDK动态代理,被...
Spring AOP 中 JDK 和 CGLib 动态代理哪个更快?
Spring框架提供了两种动态代理机制:JDK动态代理和CGLIB代理,它们分别基于这两种技术。 1. JDK动态代理: - 当被代理的目标对象实现了至少一个接口时,Spring会选择使用JDK动态代理。它通过反射机制生成一个实现...
- Spring支持两种类型的代理:JDK动态代理(如果目标对象实现了接口)和CGLIB代理(如果目标对象没有接口,使用字节码生成技术)。 - 在Spring配置中,可以使用`@Aspect`注解定义切面,`@Before`、`@After`、`@...