cglip动态代理和jdk动态代理区别是什么,优缺点是什么

已于 2023-07-31 17:33:07 修改
阅读量1k 收藏 4
点赞数
文章标签： java 开发语言
于 2023-07-31 17:18:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gxy156111/article/details/132026713
版权

CGLIB动态代理和JDK动态代理是两种不同的代理实现方式，它们有一些区别和各自的优缺点。
 区别：
1. 实现方式：CGLIB动态代理通过继承被代理类来创建代理类，而JDK动态代理通过实现被代理接口来创建代理类。
2. 支持的代理对象类型：CGLIB动态代理可以代理任意类，而JDK动态代理只能代理实现了接口的类。
3. 性能：CGLIB动态代理在创建代理类时需要使用ASM字节码操作库来修改字节码，相比之下，JDK动态代理的创建过程更加简单，性能略好一些。
 优点和缺点：
CGLIB动态代理的优点：
1. 可以代理任意类，不需要被代理类实现接口。
2. 在方法调用前后可以添加额外的逻辑，实现更加灵活的方法拦截和增强。
 CGLIB动态代理的缺点：
1. 由于是通过继承被代理类来创建代理类，因此无法代理被标记为final的类和方法。
2. 由于使用了字节码操作，创建代理类的过程相对较慢，性能较差。
 JDK动态代理的优点：
1. 创建代理类的过程相对简单，性能较好。
2. JDK动态代理是Java自带的标准库，无需额外依赖。
 JDK动态代理的缺点：
1. 只能代理实现了接口的类，无法代理未实现接口的类。
2. 在方法调用前后添加额外的逻辑的能力相对较弱。
 综上所述，CGLIB动态代理适用于代理任意类，对性能要求不是很高的场景；JDK动态代理适用于代理实现了接口的类，对性能要求较高的场景。

CGLIB（Code Generation Library）是一个基于ASM（一个Java字节码操作和分析框架）的代码生成库，它可以在运行时动态生成代理类。相比于JDK动态代理，CGLIB动态代理不要求被代理类实现接口，可以代理任意类。
 CGLIB动态代理的原理是通过继承被代理类来创建一个子类作为代理类。在子类中，重写被代理类的方法，并在方法调用前后添加额外的逻辑。CGLIB通过修改字节码的方式实现了这一过程。
 下面是使用CGLIB动态代理的代码实现示例：
 1. 添加CGLIB依赖：
xml

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>


2. 创建被代理类：

public class UserService {
    public void addUser() {
        System.out.println("添加用户");
    }
}


3. 创建代理类：

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import net.sf.cglib.proxy.Enhancer;
 public class UserServiceProxy implements MethodInterceptor {
    private Object target; // 被代理的对象
     public Object getProxyInstance(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
     @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("方法调用前");
        Object result = method.invoke(target, args);
        System.out.println("方法调用后");
        return result;
    }
}


4. 测试代码：

public class Main {
    public static void main(String[] args) {
        UserService userService = new UserService();
        UserServiceProxy proxy = new UserServiceProxy();
        UserService userServiceProxy = (UserService) proxy.getProxyInstance(userService);
        userServiceProxy.addUser();
    }
}


运行以上代码，输出结果为：

方法调用前
添加用户
方法调用后


通过CGLIB动态代理，我们成功地对UserService类进行了方法拦截和增强。在代理类的intercept方法中，我们可以在方法调用前后添加额外的逻辑，实现了AOP的横切关注点。

JDK（Java Development Kit）动态代理是Java提供的一种动态代理技术，它通过反射机制在运行时动态生成代理类。JDK动态代理要求被代理类实现接口。
 JDK动态代理的原理是通过Proxy类和InvocationHandler接口实现的。Proxy类用于创建代理对象，InvocationHandler接口用于定义代理对象的方法调用处理逻辑。
 下面是使用JDK动态代理的代码实现示例：
 1. 创建被代理接口：

public interface UserService {
    void addUser();
}


2. 创建被代理类：

public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("添加用户");
    }
}


3. 创建代理类：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 public class UserServiceProxy implements InvocationHandler {
    private Object target; // 被代理的对象
     public Object getProxyInstance(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
     @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法调用前");
        Object result = method.invoke(target, args);
        System.out.println("方法调用后");
        return result;
    }
}
4. 测试代码：
public class Main {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        UserServiceProxy proxy = new UserServiceProxy();
        UserService userServiceProxy = (UserService) proxy.getProxyInstance(userService);
        userServiceProxy.addUser();
    }
}


运行以上代码，输出结果为：

方法调用前
添加用户
方法调用后


通过JDK动态代理，我们成功地对UserServiceImpl类进行了方法拦截和增强。在代理类的invoke方法中，我们可以在方法调用前后添加额外的逻辑，实现了AOP的横切关注点。

使用Spring AOP实现CGLIB动态代理的代码如下：
 1. 首先，需要添加CGLIB的依赖包。在Maven项目中，可以在pom.xml文件中添加以下依赖：
xml

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>


2. 创建被代理类：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>


3. 创建切面类：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>


4. 配置Spring AOP：
xml

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>


5. 测试代码：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.addUser();
    }
}


运行以上代码，输出结果为：

添加用户
方法调用后


通过Spring AOP结合CGLIB动态代理，我们成功地对UserService类的addUser方法进行了方法拦截和增强。在切面类的logAfter方法中，我们可以在方法调用后添加额外的逻辑，实现了AOP的横切关注点。

使用Spring AOP实现JDK动态代理的代码如下：
1. 创建被代理接口：

public interface UserService {
    void addUser();
}


2. 创建被代理类实现该接口：

public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("添加用户");
    }
}


3. 创建切面类：

public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("添加用户");
    }
}


4. 配置Spring AOP：
xml

<bean id="userService" class="com.example.UserServiceImpl"/>
<bean id="loggingAspect" class="com.example.LoggingAspect"/>
<aop:config>
    <aop:aspect ref="loggingAspect">
        <aop:pointcut id="userServicePointcut" expression="execution(* com.example.UserService.addUser(..))"/>
        <aop:after pointcut-ref="userServicePointcut" method="logAfter"/>
    </aop:aspect>
</aop:config>


5. 测试代码：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.addUser();
    }
}


运行以上代码，输出结果为：

添加用户
方法调用后


通过Spring AOP结合JDK动态代理，我们成功地对UserService接口的addUser方法进行了方法拦截和增强。在切面类的logAfter方法中，我们可以在方法调用后添加额外的逻辑，实现了AOP的横切关注点。

gxy410225
关注
【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
浅谈JDK动态代理与CGLIB代理去区别
03-01
NULL 博文链接：https://jummy.iteye.com/blog/255628
JDK动态代理和CGLIB动态代理的区别
越努力越幸运。
01-05 1075
JDK动态代理在方法调用时需要通过反射机制来调用目标方法，因此性能略低于CGLIB，尽管JDK动态代理在Java 8中有了性能改进，但CGLIB动态代理仍然具有更高的方法调用性能。CGLIB动态代理在方法调用时不需要通过反射，直接调用目标方法，通常具有更高的方法调用性能，同时无需类型转换。另外，JDK代理生成的代理类较小，占用较少的内存，而CGLIB生成的代理类通常较大，占用更多的内存。而CGLIB动态代理不依赖于目标对象是否实现接口，可以代理没有实现接口的类，它通过继承或者代理目标对象的父类来实现代理。
JDK动态代理与CGLib动态代理
最新发布
weixin_74261199的博客
08-05 2296
动态代理（Dynamic Proxy）是在程序运行时给目标对象创建代理对象，代理对象可以对方法进行增强、控制等。在生成代理对象的过程中，目标对象不变，代理对象中方法对目标对象方法进行增强。代理对象执行目标方法时会被拦截，转而调用写好的代理方法。JDK代理、CGLib代理。
JDK动态代理与CGLIB动态代理的有什么区别？
康宁的博客
05-13 751
了解了JDK动态代理和CGLIB动态代理的原理后，现在来比较下两者的区别，这也是面试时几乎必问的一道面试题。JDK动态代理生成的代理继承了java.lang.reflect.Proxy,因为Java是单继承的，如果不通过实现接口的形式，无法对类进行扩展。CGLIB动态代理生成的代理类实际上是被代理的子类，所以被代理类可以不实现接口。
JDK 动态代理和 CGLIB 动态代理对比
zhanghuyi2022的博客
11-26 4599
JDK动态代理和CGLIB动态代理是Java中两种常见的动态代理方式，它们都用于在运行时动态地创建代理对象。
JDK动态代理和CGLIB代理的区别
taxusw的博客
08-09 608
总的来说JDK动态代理利用接口实现，CGLIB动态代理基于继承实现。
java动态代理(JDK和cglib)共10页.pdf.z
10-29
Java提供了两种主要的动态代理实现方式：JDK动态代理和CGLIB库。 首先，我们来看JDK动态代理。JDK动态代理基于Java的反射机制，它要求被代理的类必须实现一个或多个接口。通过`java.lang.reflect.Proxy`类和`java....
java动态代理(JDK和cglib)共10页.pdf.zip
10-28
在这个主题中，我们将深入探讨JDK动态代理和CGLIB库的使用。 JDK动态代理主要依赖于`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口。Proxy类用于创建代理实例，而InvocationHandler接口...
JAVA动态代理实现Demo（JDK动态代理和CGLIB动态代理）
12-19
Java提供了两种主要的动态代理实现方式：JDK动态代理和CGLIB动态代理。 **JDK动态代理**： JDK动态代理基于接口实现，也就是说，被代理的对象必须实现至少一个接口。代理机制的核心是`java.lang.reflect.Proxy`类和...
设计模式-代理模式
面对未来，乘风破浪
11-13 356
一、 代理模式 代理模式： 为其他对象提供一种代理以控制对这个对象的方法 代码示例： 1. Subject abstract class Subject { public abstract void Request(){}; } 2. RealSubject public class RealSubject extends Subject{ pub
JDK动态代理和CGLIB动态代理区别
北冥有雨
09-03 324
JDK动态代理被代理的类必须要实现有接口，而CGLIB动态代理被代理的类可实现接口也可不实现接口 声明一个接口 package com.fh.service.aop; public interface AopManager { int add(); void list(); String delete(); void update(); void transfer(); } 2.实现一个接口的被代理类 package com.fh.servi
jdk动态代理和cglib动态代理区别
qq_40263124的博客
01-31 1014
jdk动态代理和cglib动态代理区别
动态代理proxy与CGLib的区别
热门推荐
敬诚为之
09-03 3万+
昨天被人问及动态代理与CGlib的区别，赶紧回顾一下： 什么是代理？静态代理与动态代理静态代理实例JDK动态代理实例CGLib 简介CGLib 与JDK动态代理的区别     代理模式是Java中常见的一种模式，英文名字叫走Proxy或者Surrogate，代理的本意是一个人代表另一个人，或者一个机构代表另一个机构，采取行动，因而，代理和现实生活中的中介有很大的类似，你买房子、卖房
JDK动态代理与Cglib的区别
撸起袖子加油干
05-16 691
一、前言： CGLIB(Code Generation Library)是一个开源项目，是一个强大的,高性能,高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。cglib封装了asm，可以在运行期动态生成新的class，cglib用于AOP； JDK动态代理，是java反射工具包自带的工具类； 简单对比： 从实现机制角度出发： 1）JDK代理类需要实现InvocationHandler接口，重写invoke方法； 2）相比JDK这个特征，cglib却没...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值