浅谈Spring中JDK动态代理与CGLIB动态代理

最新推荐文章于 2024-05-27 16:21:54 发布
最新推荐文章于 2024-05-27 16:21:54 发布
阅读量1w 收藏 61
点赞数 14
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangzhihao1994/article/details/80913210
版权

前言

Spring是Java程序员基本不可能绕开的一个框架，它的核心思想是IoC(控制反转)和AOP(面向切面编程)。

在Spring中这两个核心思想都是一种设计模式，IoC的思想基于工厂模式，AOP的思想则是基于代理模式。

代理模式：代理类和被代理类实现共同的接口（或继承），代理类中存有指向被代理类的索引，实际执行时通过调用代理类的方法、实际执行的是被代理类的方法。

代理解决的问题当两个类需要通信时，引入第三方代理类，将两个类的关系解耦，让我们只了解代理类即可，而且代理的出现还可以让我们完成与另一个类之间的关系的统一管理，但是切记，代理类和委托类要实现相同的接口，因为代理真正调用的还是委托类的方法。

代理模式常见的实现有两种，静态代理和动态代理。

静态代理：编译时增强，AOP 框架会在编译阶段生成 AOP 代理类，在程序运行前代理类的.class文件就已经存在了。常见的实现：JDK静态代理，AspectJ 。

动态代理：运行时增强，它不修改代理类的字节码，而是在程序运行时，运用反射机制，在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。常见的实现：JDK、CGLIB、Javassist(Hibernate中使用的动态代理)

不过Spring AOP的实现没有用到静态代理，而是采用了动态代理的方式，有两种，JDK动态代理和CGLIB（Code Generator Library）动态代理。下面简述二者的差异。

Spring中如何判断使用哪种动态代理方式？

version：spring-aop-5.0.7.RELEASE.jar
class：org.springframework.aop.framework.ProxyFactoryBean

类源码上对类的说明:

implementation that builds an AOP proxy based on beans in Spring
翻译一下：
在Spring中基于bean构建AOP代理的实现

这个类就是Spring中对于bean构建AOP代理的实现，跟踪下源码流程，翻译下执行流程:

	/**
	 * Return a proxy. Invoked when clients obtain beans from this factory bean.
	 * Create an instance of the AOP proxy to be returned by this factory.
	 * The instance will be cached for a singleton, and create on each call to
	 * {@code getObject()} for a proxy.
	 * @return a fresh AOP proxy reflecting the current state of this factory
	 */
	@Override
	@Nullable
	public Object getObject() throws BeansException {
		//初始化拦截器链
		initializeAdvisorChain();
		//Spring中有singleton类型和prototype类型这两种不同的Bean
		//是否是singleton类型，是，返回singleton类型的代理对象
		if (isSingleton()) {
			return getSingletonInstance();
		}
		//否，返回prototype类型的代理对象
		else {
			if (this.targetName == null) {
				logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
						"Enable prototype proxies by setting the 'targetName' property.");
			}
			return newPrototypeInstance();
		}
	}

singleton作用域：当把一个Bean定义设置为singleton作用域是，Spring IoC容器中只会存在一个共享的Bean实例，并且所有对Bean的请求，只要id与该Bean定义相匹配，则只会返回该Bean的同一实例。值得强调的是singleton作用域是Spring中的缺省作用域。

prototype作用域：prototype作用域的Bean会导致在每次对该Bean请求（将其注入到另一个Bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的Bean实例。根据经验，对有状态的Bean应使用prototype作用域，而对无状态的Bean则应该使用singleton作用域。

对于具有prototype作用域的Bean，有一点很重要，即Spring不能对该Bean的整个生命周期负责。具有prototype作用域的Bean创建后交由调用者负责销毁对象回收资源。
简单的说：

  • singleton只有一个实例，也即是单例模式。
  • prototype访问一次创建一个实例，相当于new。

由于singleton作用域是Spring中的缺省作用域，则继续追踪getSingletonInstance()方法。

	/**
	 * Return the singleton instance of this class's proxy object,
	 * lazily creating it if it hasn't been created already.
	 * @return the shared singleton proxy
	 */
	private synchronized Object getSingletonInstance() {
		if (this.singletonInstance == null) {
			this.targetSource = freshTargetSource();
			if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
				// Rely on AOP infrastructure to tell us what interfaces to proxy.
				Class<?> targetClass = getTargetClass();
				if (targetClass == null) {
					throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
				}
				setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
			}
			// Initialize the shared singleton instance.
			super.setFrozen(this.freezeProxy);
			//获取代理对象实例
			this.singletonInstance = getProxy(createAopProxy());
		}
		return this.singletonInstance;
	}

很明显，核心就在getProxy(createAopProxy())方法中的createAopProxy()，追踪createAopProxy()创建AOP代理实例方法

/**
	 * Subclasses should call this to get a new AOP proxy. They should <b>not</b>
	 * create an AOP proxy with {@code this} as an argument.
	 */
	protected final synchronized AopProxy createAopProxy() {
		//active:在创建第一个AOP代理时设置为true
		if (!this.active) {
			//激活此代理配置。
			activate();
		}
		//this：AdvisedSupport config，AOP形式配置
		//获取AOP代理工厂，以指定AOP形式配置创建代理实例
		return getAopProxyFactory().createAopProxy(this);
	}

可以看到，createAopProxy(AdvisedSupport config)就是创建AOP代理实例。

不过这里戳进去是接口，Spring中对默认实现类是org.springframework.aop.framework.DefaultAopProxyFactory，看看里面的实现逻辑。

	@Override
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
			Class<?> targetClass = config.getTargetClass();
			if (targetClass == null) {
				throw new AopConfigException("TargetSource cannot determine target class: " +
						"Either an interface or a target is required for proxy creation.");
			}
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}

终于看到JDK和CGLIB的字样了，这个方法决定了是使用JDK动态代理还是CGLIB动态代理。

下面对if中的判断逻辑逐个翻译解释：

  • config.isOptimize()：是否优化
  • config.isProxyTargetClass()：是否直接代理目标类以及任何接口
  • hasNoUserSuppliedProxyInterfaces(config)：是否没有指定代理接口
  • targetClass.isInterface()：确定指定的对象是否表示接口类型
  • Proxy.isProxyClass(targetClass)：是否是代理类

再看看这个类的说明:

In general, specify {@code proxyTargetClass} to enforce a CGLIB proxy,or specify one or more interfaces to use a JDK dynamic proxy.
谷歌翻译一下
通常，指定{@code proxyTargetClass}来强制执行CGLIB代理，或指定一个或多个接口以使用JDK动态代理

结合类说明和判断逻辑，可以得出结论：

  • 在代理对象不是借口类型或不是代理类时，指定proxyTargetClass=true后，执行CGLIB代理
  • 代理对象是接口类型或是代理类，使用JDK代理

两种动态代理的使用

下方代码是使用JDK动态代理和CGLIB动态代理的示例，这里不探究其底层实现，而是从API的使用比较二者的差异。

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;

import java.lang.reflect.Proxy;

public class ProxyService {

    /**
     * jdk动态代理
     *
     * @param object 被代理类对象
     * @return 代理实例
     */
    public static Object jdkProxyObject(Object object) {
        //拦截器
        SimpleInterceptor interceptor = new SimpleInterceptor();
        return Proxy.newProxyInstance(
                object.getClass().getClassLoader(),
                object.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    //拦截器 - 前置处理
                    interceptor.before();
                    Object result = method.invoke(object, args);
                    //拦截器 - 后置处理
                    interceptor.after();
                    return result;
                });
    }

    /**
     * cglib动态代理
     *
     * @param object 被代理类对象
     * @return 代理实例
     */
    public static Object cglibProxyObject(Object object) {
        //模拟拦截器
        SimpleInterceptor interceptor = new SimpleInterceptor();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(object.getClass());
        enhancer.setCallback((MethodInterceptor) (o, method, objects, methodProxy) -> {
            //拦截器 - 前置处理
            interceptor.before();
            Object result = method.invoke(object, objects);
            //拦截器 - 后置处理
            interceptor.after();
            return result;
        });
        return enhancer.create();
    }

}

public class SimpleInterceptor {

    public void before() {
        System.out.println("-----" + this.getClass().getSimpleName() + "do before" + "-----");
    }

    public void after() {
        System.out.println("-----" + this.getClass().getSimpleName() + "do after" + "-----");
    }

}

JDK动态代理

使用JDK动态代理需要使用：
Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)。

源码方法说明：

Returns an instance of a proxy class for the specified interfaces that dispatches method invocations to the specified invocation handler

谷歌翻译一下：

返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。

参数说明：

  • ClassLoader loader: the class loader to define the proxy class，用于定义代理类的类加载器
  • Class<?>[] interfaces: the list of interfaces for the proxy class，代理类的接口列表
  • InvocationHandler h: to implement，由代理实例的调用处理程序实现的接口

根据说明传参，可以看出JDK动态代理的实现原理是实现代理对象的接口生成兄弟类。

所以使用JDK动态代理必须满足以下条件:

  • 代理对象必须实现一个或多个接口
  • 返回的代理实例是指定接口的代理类的实例，也就是必须以对象实现的接口接收实例，而不是代理类

CGLIB动态代理

使用Spring CGLIB动态代理需要使用：
org.springframework.cglib.proxy.Enhancer。

由于spring的Sources下载下来并没有Javadoc，没法展示源码上的方法说明。。。

不过从enhancer.setSuperclass(Class superclass) 可以看出cglib代理的特点:。

  1. 代理对象不能被final修饰,因为cglib代理的实现原理是操作字节码生成代理对象子类，而被final修饰的类不能被继承
  2. 因为是子类，所以不必像jdk代理一样必须以对象实现的接口接收实例，代理对象类同样可以接收代理实例

实现原理

  • JDK动态代理：基于反射，生成实现代理对象接口的匿名类，通过生成代理实例时传递的InvocationHandler处理程序实现方法增强。
  • CGLIB动态代理：基于操作字节码，通过加载代理对象的类字节码，为代理对象创建一个子类，并在子类中拦截父类方法并织入方法增强逻辑。底层是依靠ASM（开源的java字节码编辑类库）操作字节码实现的。

性能比较

性能比较分为两个部分：生成代理实例性能、代理实例运行性能。

由于看到网上有博客提到jdk版本升级会提高动态代理的性能，秉持着实事求是的原则，必须要测试下版本升级后的比较结果，测试的jdk版本为jdk1.8.0_171和jdk-10.0.1，count数分别定义为100、1000、10000，100000。

为避免干扰，方法都是单独执行，每个count执行三次，结果聚合，方便比较。

定义一个简单的service及实现

public interface SimpleService {
   void consumer();
}

import java.util.Date;

public class SimpleServiceImpl implements SimpleService {
    @Override
    public void consumer() {
        new Date();
    }
}

比较生成代理实例性能

JDK

public class JdkTest {

    public static void main(String[] args) {
        /*----------jdk----------*/
        int count = 100000;
        long jdkStart = System.currentTimeMillis();
        for (int j = 0; j < count; j++) {
            SimpleService service = new SimpleServiceImpl();
            SimpleService proxy = (SimpleService) ProxyService.jdkProxyObject(service);
        }
        long jdkEnd = System.currentTimeMillis();

        System.out.println("==================================================");
        System.out.println("java.version:" + System.getProperty("java.version"));
        System.out.println("new count:" + count);
        System.out.println("jdk new proxy spend time(ms):" + (jdkEnd - jdkStart));
    }

}

CGLIB

public class CglibTest {
    public static void main(String[] args) {
        /*----------cglib----------*/
        int count = 100000;
        long cglibStart = System.currentTimeMillis();
        for (int j = 0; j < count; j++) {
            SimpleService service = new SimpleServiceImpl();
            SimpleService proxy = (SimpleService) ProxyService.cglibProxyObject(service);
        }
        long cglibEnd = System.currentTimeMillis();

        System.out.println("==================================================");
        System.out.println("java.version:" + System.getProperty("java.version"));
        System.out.println("new count:" + count);
        System.out.println("cglib new proxy spend time(ms):" + (cglibEnd - cglibStart));
    }
}

count分别为100，1000，10000，100000，打印结果聚合：

java.version:1.8.0_161

==================================================
java.version:1.8.0_171
new count:100
jdk new proxy spend time(ms):143
jdk new proxy spend time(ms):164
jdk new proxy spend time(ms):154
cglib new proxy spend time(ms):412
cglib new proxy spend time(ms):452
cglib new proxy spend time(ms):428

==================================================
java.version:1.8.0_171
new count:1000
jdk new proxy spend time(ms):151
jdk new proxy spend time(ms):158
jdk new proxy spend time(ms):172
cglib new proxy spend time(ms):489
cglib new proxy spend time(ms):415
cglib new proxy spend time(ms):431

==================================================
java.version:1.8.0_171
new count:10000
jdk new proxy spend time(ms):214
jdk new proxy spend time(ms):218
jdk new proxy spend time(ms):227
cglib new proxy spend time(ms):468
cglib new proxy spend time(ms):486
cglib new proxy spend time(ms):650

==================================================
java.version:1.8.0_171
new count:100000
jdk new proxy spend time(ms):278
jdk new proxy spend time(ms):299
jdk new proxy spend time(ms):304
cglib new proxy spend time(ms):612
cglib new proxy spend time(ms):632
cglib new proxy spend time(ms):684

java.version:10.0.1

==================================================
java.version:10.0.1
new count:100
jdk new proxy spend time(ms):92
jdk new proxy spend time(ms):93
jdk new proxy spend time(ms):85
cglib new proxy spend time(ms):288
cglib new proxy spend time(ms):330
cglib new proxy spend time(ms):347

==================================================
java.version:10.0.1
new count:1000
jdk new proxy spend time(ms):88
jdk new proxy spend time(ms):94
jdk new proxy spend time(ms):105
cglib new proxy spend time(ms):339
cglib new proxy spend time(ms):306
cglib new proxy spend time(ms):341

==================================================
java.version:10.0.1
new count:10000
jdk new proxy spend time(ms):128
jdk new proxy spend time(ms):132
jdk new proxy spend time(ms):125
cglib new proxy spend time(ms):376
cglib new proxy spend time(ms):409
cglib new proxy spend time(ms):446

==================================================
java.version:10.0.1
new count:100000
jdk new proxy spend time(ms):170
jdk new proxy spend time(ms):220
jdk new proxy spend time(ms):196
cglib new proxy spend time(ms):530
cglib new proxy spend time(ms):555
cglib new proxy spend time(ms):633

对比结果，生成代理实例性能：JDK > CGLIB；JDK版本升级后对动态代理生成实例性能有提升。

比较生成代理实例性能

JDK

public class JdkTest {

    public static void main(String[] args) {
        /*----------jdk----------*/
        int count = 100;
        long jdkStart = System.currentTimeMillis();
        SimpleService service = new SimpleServiceImpl();
        SimpleService proxy = (SimpleService) ProxyService.jdkProxyObject(service);
        for (int j = 0; j < count; j++) {
            proxy.consumer();
        }
        long jdkEnd = System.currentTimeMillis();

        System.out.println("==================================================");
        System.out.println("java.version:" + System.getProperty("java.version"));
        System.out.println("new count:" + count);
        System.out.println("jdk proxy consumer spend time(ms):" + (jdkEnd - jdkStart));
    }

}

CGLIB

public class CglibTest {
    
    public static void main(String[] args) {
        /*----------cglib----------*/
        int count = 100;
        long cglibStart = System.currentTimeMillis();
        SimpleService service = new SimpleServiceImpl();
        SimpleService proxy = (SimpleService) ProxyService.cglibProxyObject(service);
        for (int j = 0; j < count; j++) {
            proxy.consumer();
        }
        long cglibEnd = System.currentTimeMillis();

        System.out.println("==================================================");
        System.out.println("java.version:" + System.getProperty("java.version"));
        System.out.println("new count:" + count);
        System.out.println("cglib proxy consumer spend time(ms):" + (cglibEnd - cglibStart));
    }
}

count分别为100，1000，10000，100000，打印结果聚合：

java.version:1.8.0_161

==================================================
java.version:1.8.0_171
new count:100
jdk proxy consumer spend time(ms):148
jdk proxy consumer spend time(ms):137
jdk proxy consumer spend time(ms):168
cglib proxy consumer spend time(ms):464
cglib proxy consumer spend time(ms):447
cglib proxy consumer spend time(ms):438

==================================================
java.version:1.8.0_171
new count:1000
jdk proxy consumer spend time(ms):141
jdk proxy consumer spend time(ms):170
jdk proxy consumer spend time(ms):150
cglib proxy consumer spend time(ms):408
cglib proxy consumer spend time(ms):410
cglib proxy consumer spend time(ms):422

==================================================
java.version:1.8.0_171
new count:10000
jdk proxy consumer spend time(ms):179
jdk proxy consumer spend time(ms):173
jdk proxy consumer spend time(ms):165
cglib proxy consumer spend time(ms):416
cglib proxy consumer spend time(ms):463
cglib proxy consumer spend time(ms):415

==================================================
java.version:1.8.0_171
new count:100000
jdk proxy consumer spend time(ms):176
jdk proxy consumer spend time(ms):158
jdk proxy consumer spend time(ms):187
cglib proxy consumer spend time(ms):637
cglib proxy consumer spend time(ms):459
cglib proxy consumer spend time(ms):436

java.version:10.0.1

==================================================
java.version:10.0.1
new count:100
jdk proxy consumer spend time(ms):79
jdk proxy consumer spend time(ms):90
jdk proxy consumer spend time(ms):85
cglib proxy consumer spend time(ms):281
cglib proxy consumer spend time(ms):352
cglib proxy consumer spend time(ms):338

==================================================
java.version:10.0.1
new count:1000
jdk proxy consumer spend time(ms):89
jdk proxy consumer spend time(ms):97
jdk proxy consumer spend time(ms):106
cglib proxy consumer spend time(ms):304
cglib proxy consumer spend time(ms):303
cglib proxy consumer spend time(ms):359

==================================================
java.version:10.0.1
new count:10000
jdk proxy consumer spend time(ms):113
jdk proxy consumer spend time(ms):99
jdk proxy consumer spend time(ms):108
cglib proxy consumer spend time(ms):347
cglib proxy consumer spend time(ms):339
cglib proxy consumer spend time(ms):349

==================================================
java.version:10.0.1
new count:100000
jdk proxy consumer spend time(ms):106
jdk proxy consumer spend time(ms):102
jdk proxy consumer spend time(ms):107
cglib proxy consumer spend time(ms):342
cglib proxy consumer spend time(ms):380
cglib proxy consumer spend time(ms):385

对比结果，代理实例运行性能：JDK > CGLIB；JDK版本升级后对动态代理的代理实例运行性能有提升。

说实话看到对比结果我是震惊的，我之前一直认为CGLIB动态代理的性能应该优于JDK动态代理，通过对比结果，可以看出，动态代理总体性能：JDK > CGLIB，难怪Spring默认的动态代理方式为JDK。

小结

Spring中动态代理选择逻辑：

这里写图片描述

JDK动态代理特点：

  • 代理对象必须实现一个或多个接口
  • 以接口形式接收代理实例，而不是代理类

CGLIB动态代理特点：

  • 代理对象不能被final修饰
  • 以类或接口形式接收代理实例

JDK与CGLIB动态代理的性能比较：

  • 生成代理实例性能：JDK > CGLIB
  • 代理实例运行性能：JDK > CGLIB
飞翔的大白菜丶
关注
  • 14
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Spring原理学习（六）：Spring实现动态代理时对jdk和cglib的选择
m0_49499183的博客
04-14 941
spring当中不需要我们直接去用jdk或者cglib，它提供了ProxyFactory来方便地创建代理，那么他如何选择代理方法呢？我打算通过AOP中的切面来讲解这一部分。
spring中cglib动态代理
shijinjins的博客
04-26 3631
java动态代理和cglib动态代理的区别，及实现原理
深度解析 Spring 源码：探秘 CGLIB 代理的奥秘
最新发布
忆~遂愿的博客
05-27 2130
当涉及到Spring框架的AOP（面向切面编程）功能时，CGLIB代理一直扮演着至关重要的角色。本文将深入探讨CGLIB代理的实现细节，从底层原理到实际应用，帮助读者全面了解CGLIB代理的奥秘。文章将首先介绍AOP的基本概念和Spring框架对AOP的支持，然后深入剖析CGLIB代理的实现机制，包括动态生成子类、方法拦截和代理类的创建过程。此外，文章还将讨论CGLIB代理在实际项目中的应用场景和优缺点，以及与JDK动态代理的对比分析。通过本文的深度解析，读者将获得对CGLIB代理技术的全面理解。
Spring AOP 实现原理详解之 CGLIB 动态代理
流华追梦的专栏
02-23 1197
CGLIB 是一个强大的高性能的代码生成包。它广泛的被许多 AOP 的框架使用，例如 Spring AOP 和 dynaop，为他们提供方法的 interception（拦截）。CGLIB 包的底层是通过使用一个小而快的字节码处理框架 ASM，来转换字节码并生成新的类。除了 CGLIB 包，脚本语言例如 Groovy和 BeanShell，也是使用 ASM 来生成 Java 的字节码。当然不鼓励直接使用 ASM，因为它要求你必须对 JVM 内部结构包括 class 文件的格式和指令集都很熟悉。引入 CGLI
springAop使用的动态代理是jdk还是cglib
youngerxsd的博客
09-10 690
需要注意的是，对于final类和方法，无法使用CGLIB动态代理，只能使用JDK动态代理。因此，当目标对象是final的或者目标方法是final的、static的、private的时候，Spring AOP会强制使用JDK动态代理。如果需要明确指定使用哪种代理方式，可以通过配置进行设置。CGLIB动态代理通过继承目标对象创建代理类，并重写目标对象的方法来实现代理功能。Spring AOP使用的动态代理可以是JDK动态代理或CGLIB动态代理，具体选择哪种代理方式取决于被代理的目标对象的类型和配置。
Spring中JDK与Cglib动态代理的区别
qq_29012499的博客
11-30 1069
Spring中JDK与Cglib动态代理的区别
浅谈JDK动态代理与CGLIB代理去区别
03-01
在"通过Configuration文件实现AOP.docx"文档中，可能会详细讲述如何在Spring配置文件中配置AOP代理，包括如何选择使用JDK动态代理还是CGLIB。 总结来说，JDK动态代理简单且高效，适合接口驱动的设计，而CGLIB适用于...
Spring框架中JDK动态代理和cglib动态代理
11-06
Spring 框架中 JDK 动态代理和 CGLIB 动态代理是 Spring AOP 中一个非常重要的知识点。Spring AOP 框架会根据实际情况选择使用 JDK 的动态代理还是 CGLIB 的动态代理。 JDK 动态代理是 Java 自带的动态代理机制，它...
JDK动态代理和Cglib动态代理实例源码
01-04
通过分析`DynamicProxyTest`源码，我们可以更深入地理解JDK和Cglib动态代理的工作原理，以及它们在实际应用中的用法。动态代理在AOP（面向切面编程）、缓存、日志记录、事务管理等多个场景中都有广泛应用，是Java...
动态代理jdk和spring的cglib.emmx
07-18
使用mindmaster打开
JAVA动态代理实现Demo（JDK动态代理和CGLIB动态代理）
12-19
Java提供了两种主要的动态代理实现方式：JDK动态代理和CGLIB动态代理。 **JDK动态代理**： JDK动态代理基于接口实现，也就是说，被代理的对象必须实现至少一个接口。代理机制的核心是`java.lang.reflect.Proxy`类和...
spring导入eclipse时少的spring-cglib-repack-3.2.4.jar和spring-objenesis-repack-2.4.jar
11-25
截至2016.11.25 github最新版spring 导入 myclipse/eclipse时缺少的jar包。找了很久不容易，这里分享给诸位一起学习spring的朋友！
java动态代理实例（jdk动态代理和cglib）
08-24
实现java动态代理的两个实例，jdk动态代理和cglib
Spring的两种代理JDK和CGLIB的区别浅谈
杨春建的博客
10-01 9682
原文地址：http://blog.csdn.net/u013126379/article/details/52121096 一、原理区别： Java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。 而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。 1、如果目标对象实现
【动态代理】—— JDK和cglib的动态代理
1+1=王的博客
03-19 3941
概述 设计模式中有一个代理模式，它为其他对象提供一种代理以控制对这个对象的访问。 关于代理模式可以参考：【每天一个java设计模式（七）】 - 代理模式：https://blog.csdn.net/weixin_43598687/article/details/122072282 代理模式是指的静态代理。使用静态代理很容易就完成了对一个类的代理操作。但是静态代理的缺点也暴露了出来：由于代理只能为一个类服务，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐。 而动态代理可以在程序运行期间，在不修改源
spring 如何通过cglib 生成动态代理
小样
05-03 1068
目标 理解spring中如何通过cglib的方式生成动态代理。 我们都知道，spring中存在两种动态代理的方式，第一个是jdk动态代理的方式，本质是通过反射实现，第二个是cglib的方式，这个是需要操作字节码实现。第一种方式虽然效率会更高，但是却存在硬伤，代理类必须是基于接口的。而方式二则没有这些限制。我们之前有一篇文章是分析jdk动态代理方式实现，这篇文章则重点是cglib方式如何实现动态代理...
Spring—AOP两种代理机制对比（JDK和CGLib动态代理）
qq1723205668的博客
02-22 2万+
Sprign 动态代理机制 Spirng的AOP的动态代理实现机制有两种，分别是: 1）JDK动态代理： 具体实现原理： 1、通过实现InvocationHandlet接口创建自己的调用处理器 2、通过为Proxy类指定ClassLoader对象和一组interface来创建动态代理 3、通过反射机制获取动态代理类的构造函数，其唯一参数类型就是调用处理器接口类型 4、通过构造
Spring spring的cglib动态代理
m0_38068812的博客
11-25 347
一.cglib动态代理 1.CGLIB代理：     1,CGLIB可以生成目标类的子类，并重写父类非final修饰符的方法。     2,要求类不能是final的，要拦截的方法要是非final、非static、非private的。     3,动态代理的最小单位是类(所有类中的方法都会被处理); 2.在Spring中cglib和jdk代理选择：   若目标对象实现了若干接口，Spring就会...
Java两种动态代理JDK动态代理和CGLIB动态代理
热门推荐
Java相关领域
08-07 14万+
目录 代理模式 JDK动态代理 cglib动态代理 测试 代理模式 代理模式是23种设计模式的一种，他是指一个对象A通过持有另一个对象B，可以具有B同样的行为的模式。为了对外开放协议，B往往实现了一个接口，A也会去实现接口。但是B是“真正”实现类，A则比较“虚”，他借用了B的方法去实现接口的方法。A虽然是“伪军”，但它可以增强B，在调用B的方法前后都做些其他的事情。Spring AOP...
Spring Aop中的JDK动态代理和CGLIB动态代理有什么区别
06-10
在 Spring AOP 中，JDK 动态代理和 CGLIB 动态代理都可以用来实现切面的功能，它们的主要区别在于： 1. JDK 动态代理只能代理实现了接口的类，而 CGLIB 动态代理可以代理没有实现接口的类。这是因为 JDK 动态代理是基于接口来实现的，而 CGLIB 动态代理则是通过生成被代理类的子类来实现的。 2. JDK 动态代理相对于 CGLIB 动态代理来说，生成代理对象的速度更快，执行效率也更高。这是因为 JDK 动态代理是使用 Java 自带的反射机制来实现的，而 CGLIB 动态代理则是使用 ASM 字节码操作框架来生成字节码的。 3. JDK 动态代理适用于对单个对象的代理，而 CGLIB 动态代理适用于对类的代理。这是因为 JDK 动态代理生成的代理对象是实现了接口的单个对象，而 CGLIB 动态代理生成的代理对象是被代理类的子类。 需要注意的是，当被代理的类没有实现接口时，Spring AOP 默认会使用 CGLIB 动态代理来生成代理对象，如果被代理的类实现了接口，则可以通过配置来选择使用 JDK 动态代理或 CGLIB 动态代理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值