从生活场景、业务场景剖析代理模式(JDK、CGLIB、spring)

最新推荐文章于 2024-10-08 11:10:51 发布
原创 最新推荐文章于 2024-10-08 11:10:51 发布 · 701 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #设计模式 #代理模式 #cglib动态代理 #jdk动态代理

本文详细介绍了代理模式的概念、应用场景及分类，包括静态代理和动态代理，并通过明星与经纪人关系的类比，深入浅出地讲解了JDK动态代理与CGLib动态代理的区别。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

代理模式应用场景

代理模式就是一层代理，日常生活中的中介、经纪人，代码中的事务代理、非侵入式日志等都是代理。
代理模式就是代理对象持有被代理对象的引用，在代理类中访问代理对象的时候，在方法前后做一些处理逻辑。
比如经纪人持有明星的访问权，记者要采访明星，经纪人会对记者的访问做一些筛选、档期判断等操作，之后符合条件的话才会进入到访问明星的阶段。
代理模式属于结构型模式。

代理模式与之后的装饰模式结构有相似的地方，处理逻辑的重心不同，不必太拘泥于两者的区别

代理模式的分类

代理模式总体上分为两种，静态代理和动态代理，可以理解为静态代理是一对一的代理，动态代理是利用反射等技术实现的一对多的通用代理，一个是手写的代理类，一个是动态生成的代理类

静态代理

静态代理理解起来比较简单，用两个例子来说明下

明星-经纪人之静态代理

这是个比较通俗的例子

package com.luhui.pattern.proxy;

/**
 * 通用接口，以备后患
 */
public interface Person {
}

package com.luhui.pattern.proxy.staticproxy;
import com.luhui.pattern.proxy.Person;

/**
 * 明星1号
 */
public class Star1 implements Person{

    public void interviewed(){
        System.out.println("明星1号接受记者采访");
    }

}

package com.luhui.pattern.proxy.staticproxy;
import com.luhui.pattern.proxy.Person;

/**
 * 经纪人类
 */
public class Agent implements Person {
    private Star1 star1;

    public Agent(Star1 star1){
        this.star1 = star1;
    }

    public void interviewed(){
        before();
        this.star1.interviewed();
        after();
    }

    private void before(){
        System.out.println("查看明星档期");
    }

    private void after(){
        System.out.println("与记者沟通采访结果");
    }
}

package com.luhui.pattern.proxy.staticproxy;

/**
 * 测试类
 */
public class AgentProxyTest {
    public static void main(String[] args) {
        Agent agent = new Agent(new Star1());
        agent.interviewed();
    }

这里的经纪人就是明星1号的一个代理类，因为这个代理类是我们手写的，所以是静态代理。

分库分表中的业务问题

这个比较接近生产中的场景了，比如我们面对与日俱增的订单量，需要对产生的数据根据年份进行分库分表，不同年份的订单放到不同的数据库中。这个时候就需要有个代理类来对订单进行判断，然后再路由到对应年份的数据据库中进行操作(与此类似的还有日常微服务开发中的开发者模式等)。

package com.luhui.pattern.proxy.dbroute;

import lombok.Getter;
import lombok.Setter;

/**
 * 订单类
 */
@Getter
@Setter
public class Order {

    /**
     * 订单ID
     */
    private String orderId;
    
    /**
     * 订单信息
     */
    private Object orderInfo;

    /**
     * 创建时间(一般而言都是必备字段)
     */
    private Long createTime;
    
}

package com.luhui.pattern.proxy.dbroute;

/**
 * 模拟订单操作的持久层
 */
public class OrderDao {
    public int insert(Order order){
        System.out.println("OrderDao创建Order成功!");
        return 1;
    }
}


package com.luhui.pattern.proxy.dbroute;

public interface IOrderService {
    int createOrder(Order order);
}


package com.luhui.pattern.proxy.dbroute;

public class OrderService implements IOrderService {
    private OrderDao orderDao;

    public OrderService(){
        orderDao = new OrderDao();
    }

    public int createOrder(Order order) {
        System.out.println("OrderService调用orderDao创建订单");
        return orderDao.insert(order);
    }
}

如上所述，一个实体类-持久层-业务接口-业务层的简单架子，这个时候再加上分库分表的代理逻辑

package com.luhui.pattern.proxy.dbroute.proxy;

import com.luhui.pattern.proxy.dbroute.IOrderService;
import com.luhui.pattern.proxy.dbroute.Order;
import com.luhui.pattern.proxy.dbroute.db.DynamicDataSourceEntity;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 分库分表的静态代理
 */
public class OrderServiceStaticProxy implements IOrderService {
    private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");

    /**
     * 代理类持有被代理类引用
     */
    private IOrderService orderService;
    public OrderServiceStaticProxy(IOrderService orderService) {
        this.orderService = orderService;
    }

    /**
     * 代理前置工作
     */
    private void before(Order order){
        Long time = order.getCreateTime();
        Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
        System.out.println("静态代理类自动分配到【DB_" +  dbRouter + "】数据源处理数据" );
        // 模拟设置数据源
        DynamicDataSourceEntity.set(dbRouter);
    }

    /**
     * 代理后置工作
     */
    private void after(){
        // 模拟重置数据源
        DynamicDataSourceEntity.restore();
    }

    public int createOrder(Order order) {
        before(order);
        this.orderService.createOrder(order);
        after();
        return 0;
    }
}

以下是个利用ThreadLocal模拟数据源的实体类，如果只是单纯的了解代理模式，不想涉及的太多，可以忽略这个类。如果想再多了解的，可以看我之前的另一个博客
链接: 关于ThreadLocal的使用心得.

package com.luhui.pattern.proxy.dbroute.db;

/**
 * 这是一个模拟数据源设置的实体类
 */
public class DynamicDataSourceEntity {

    public final static String DEFAULE_SOURCE = null;

    private final static ThreadLocal<String> local = new ThreadLocal<String>();

    private DynamicDataSourceEntity(){}


    public static String get(){return  local.get();}

    public static void restore(){
         local.set(DEFAULE_SOURCE);
    }

    //DB_2019
    //DB_2020
    public static void set(String source){local.set(source);}

    public static void set(int year){local.set("DB_" + year);}

}

如上所述就是一个贴近日常业务场景的一个代理模式的例子。
综合两个例子来看，静态代理就是我们手写一个类作为代理类，代理类持有被代理类的引用，在我们使用被代理类的时候，先访问代理类(访问的时候初始化一个被代理类实例)，通过代理类的访问控制逻辑后(比如经纪人的档期判断，订单创建时间的判断)，再来访问代理类的逻辑(访问明星，创建订单)，之后可以根据实际情况选择是否增加对应的后置逻辑(比如流的关闭，ThreadLocal的remove等一些资源的释放)

动态代理

我们已经知道了两者的区别，那么话题紧接上面的静态代理例子。

明星-经纪人之静态代理缺点

众所周知一名强大的经纪人往往是服务于多个明星的，如果是面对这样的场景，我们要按照上面静态代理的思路来实现的话，就需要写很多个经纪人代理类了。

/**
 * 经纪人类-服务于明星1号
 */
public class Agent implements Person {
    private Star1 star1;

    public Agent(Star1 star1){
        this.star1 = star1;
    }

    public void interviewed(){
        before();
        this.star1.interviewed();
        after();
    }

    private void before(){
        System.out.println("查看明星1档期");
    }

    private void after(){
        System.out.println("与记者沟通采访结果");
    }
}

/**
 * 经纪人类-服务于明星2号
 */
public class Agent implements Person {
    private Star2 star2;

    public Agent(Star2 star2){
        this.star2 = star2;
    }

    public void interviewed(){
        before();
        this.star2.interviewed();
        after();
    }

    private void before(){
        System.out.println("查看明星1档期");
    }

    private void after(){
        System.out.println("与记者沟通采访结果");
    }
}

/**
 * 经纪人类-服务于明星3号
 */
public class Agent implements Person {
    private Star2 star2;
    ......

诸如此类，如果数量繁多的话，我们要写很多代理类，写很多重复代码，显然不符合我们使用设计模式的初衷。这时候就需要动态代理

明星-经纪人之JDK动态代理

package com.luhui.pattern.proxy.dynamicproxy.jdkproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 使用JDK动态代理实现的经纪人类(注意，这个不是真正的代理类)
 */
public class JDKAgent implements InvocationHandler {

    private Object target;

    /**
     * 获取一个代理类
     *
     * @param target 为了实现动态，这里肯定不能传具体的代理类，所以是Object
     * @author ngls.luhui 2020-12-22 15:03
     * @return java.lang.Object
     */
    public Object getInstance(Object target) throws Exception{
        // 1.0 获得被代理类的实例对象并存储
        this.target = target;
        // 2.0 获得被代理类的字节码对象
        Class<?> clazz = target.getClass();
        // 3.0 根据被代理类的字节码对象生成并返回代理类
        return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }

    /**
     * 实现InvocationHandler接口所必须实现的方法，用来写代理的逻辑
     *
     * @author ngls.luhui 2020-12-22 15:06
     * @return java.lang.Object
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object obj = method.invoke(this.target,args);
        after();
        return obj;
    }
    
    private void before(){
        System.out.println("查看明星档期");
    }

    private void after(){
        System.out.println("与记者沟通采访结果");
    }
}

package com.luhui.pattern.proxy.dynamicproxy.jdkproxy;

import com.luhui.pattern.proxy.Person;
import sun.misc.ProxyGenerator;

import java.io.FileOutputStream;
import java.lang.reflect.Method;

public class JDKProxyTest {

    public static void main(String[] args) {
        try {
            // 访问代理类被代理的方法
            Object obj = new JDKAgent().getInstance(new Star1());
            Method method = obj.getClass().getMethod("interviewed",null);
            method.invoke(obj);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

这个时候会发现getMethod这一步报错了，不急。
我们先debug看一下
在这里插入图片描述
可以发现，我们获得的代理类对象是一个很奇怪的$Proxy0类型，这个其实是一个动态生成的代理类。
我们可以把这个class从内存中输出到磁盘里看一看，加上如下代码

public class JDKProxyTest {
    public static void main(String[] args) {
        try {

            Person obj = (Person)new JDKAgent().getInstance(new Star1());
            // Method method = obj.getClass().getMethod("interviewed",null);
            // method.invoke(obj);

            //用于打印出 $Proxy0的class文件
            byte [] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{Person.class});
            FileOutputStream os = new FileOutputStream("E://$Proxy0.class");
            os.write(bytes);
            os.close();

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

执行以后找到如下文件，进行反编译(反编译的手段多样，可使用jad，也可使用idea自带的反编译插件)

在这里插入图片描述
反编译打开后，发现生成的代理类中并没有interviewed方法，所以执行以下这行代码必然会出错

Method method = obj.getClass().getMethod("interviewed",null);

在这里插入图片描述
原因其实是，jdk动态代理是根据代理类和被代理类的统一接口而实现的，只有接口中有的方法，才会生成在代理类中。所以在Person接口中增加interviewed()方法后，执行成功。
在编写JDKAgent的时候其实也有体现
在这里插入图片描述

在这里插入图片描述
再次反编译动态生成的代理类，interviewed方法已经有了
在这里插入图片描述
所以通过这个bug，也能体会到jdk动态代理的最大特点了。

明星-经纪人之CGLib动态代理

上述例子中，为了解决jdk代理带来的bug，我们给People接口增加了interviewed方法。
但是，从逻辑上讲，是有点牵强的，这样的话所有继承People接口的类都要实现interviewed方法，但不是每个人都要有被采访的方法的。
所以，我们来看另一种代理方法-cglib的动态代理

package com.luhui.pattern.proxy.dynamicproxy.cglibproxy;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CGlibAgent implements MethodInterceptor {


    public Object getInstance(Class<?> clazz) throws Exception{
        //相当于Proxy，代理的工具类
        Enhancer enhancer = new Enhancer();
        //要把哪个设置为即将生成的新类父类
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

	/**
     * 我们调用的所有的原始方法都会被替代为调用该方法
     * 我们可以在该方法中使用反射的形式来调用原始方法（比较费时）
     * 或者使用MethodProxy，使用MethodProxy性能更好
     * @param o: 代理类对象
     * @param method : 原始方法对象
     * @param objects : 方法参数
     * @param proxy : MethodProxy,该参数涉及到Cglib的FastClass机制
     */
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object obj = methodProxy.invokeSuper(o,objects);
        after();
        return obj;
    }

    private void before(){
        System.out.println("查看明星档期");
    }

    private void after(){
        System.out.println("与记者沟通采访结果");
    }
}

package com.luhui.pattern.proxy.dynamicproxy.cglibproxy;

/**
 * 明星1号，不需要继承接口了
 */
public class Star1{

    public void interviewed(){
        System.out.println("明星1号接受记者采访");
    }

}

package com.luhui.pattern.proxy.dynamicproxy.cglibproxy;

import net.sf.cglib.core.DebuggingClassWriter;

public class CglibTest {
    public static void main(String[] args) {

        try {
        	// 用来打印生成的代理类信息
            //System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"E://cglib_proxy_classes");

            Star1 star1 = (Star1) new CGlibAgent().getInstance(Star1.class);
            star1.interviewed();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果如下
在这里插入图片描述
可以看到，这次的Star1并没有实现任何接口，所以可以看出cglib的代理是不依赖接口的。而且从下面的setSuperclass可以猜测一下，cglib的实现原理是生成一个被代理类的子类来进行代理的。

在这里插入图片描述
接下来反编译一下生成的代理类，通过调试或者打印类信息我们可以得到，这个就是生成的代理类信息

在这里插入图片描述
首先第一个关键点，确实是通过继承来实现的，而且生成的代理类，继承了被代理类Star1的全部方法。
在这里插入图片描述
我们看下interviewed方法
在这里插入图片描述
可以看下，其实其他的equals和toString等方法也是一样的，所以我们在CGlibAgent中重写的intercept方法相当于给所有方法加了个截面
在这里插入图片描述
如果要仅对interviewed方法生效，可以通过method参数对before和after的调用进行控制。
关于cglib的原理，其实使用了fastClass的机制，上面三个class文件中

在这里插入图片描述
这里的FastCalss简单来说就是：为代理类和被代理类各生成一个 Class，这个 Class 会为代 理类或被代理类的方法分配一个 index(int 类型)。这个 index 当做一个入参，FastClass 就可以直接定位要调用的方法直接进行调用，这样省去了反射调用，所以调用效率比 JDK 动态代理通过反射调用高。
在这里插入图片描述

CGLib 和 JDK 动态代理对比

  1. JDK 动态代理是实现了被代理对象的接口，CGLib 是继承了被代理对象。
  2. JDK 和 CGLib 都是在运行期生成字节码，JDK 是直接写 Class 字节码，CGLib 使用 ASM 框架写 Class 字节码
  3. JDK Proxy生成代理的逻辑简单，执行效率相对要低，每次都要反射动态调用，CGLib 生成代理逻辑更复杂，调用效率更高，生成一个包含了所有的逻辑的FastClass，不再需要反射调用。

代理模式与Spring

  1. 当 Bean 有实现接口时，Spring 就会用 JDK 的动态代理
  2. 当 Bean 没有实现接口时，Spring 选择 CGLib
  3. Spring 可以通过配置强制使用 CGLib，只需在 Spring 的配置文件中加入如下代码
<aop:aspectj-autoproxy proxy-target-class="true"/>

静态代理和动态的本质区别

  1. 静态代理只能通过手动完成代理操作，如果被代理类增加新的方法，代理类需要同步新增，违背开闭原则。
  2. 动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则。
  3. 若动态代理要对目标类的增强逻辑扩展，结合策略模式，只需要新增策略类便可完成， 无需修改代理类的代码。

代理模式的优缺点

优点

  1. 代理模式能将代理对象与真实被调用的目标对象分离。
  2. 一定程度上降低了系统的耦合度，扩展性好。
  3. 可以起到保护目标对象的作用。
  4. 可以对目标对象的功能增强。

缺点

  1. 代理模式会造成系统设计中类的数量增加。
  2. 在客户端和目标对象增加一个代理对象，会造成请求处理速度变慢。
  3. 增加了系统的复杂度。
深入理解动态代理：JDK动态代理与CGLIB动态代理
qq_40254606的博客
06-28 2635
动态代理是一种在运行时创建代理对象的技术，通过代理对象来控制对原对象的访问，能够在不修改原对象的情况下添加额外的功能。JDK动态代理：基于Java反射机制，只能代理实现了接口的类。CGLIB动态代理：基于字节码生成技术，可以代理没有实现接口的类。// 抽象主题接口动态代理在Java中提供了一种灵活而强大的机制，能够在运行时为目标对象添加额外的功能。JDK动态代理和CGLIB动态代理各有优势和适用场景，开发者可以根据具体需求选择合适的代理机制。希望这篇文章对你理解动态代理有所帮助。
JDK动态代理和CGLIB动态代理
努力努力再努力的小笼包
05-30 8534
在SpringAOP中基于动态代理实现功能的增强，也就是动态的生成代理类，在代理类中织入增强的逻辑然后调用目标对象的方法。动态代理中用的比较多的两种：JDK动态代理、CGLIB动态代理。 JDK动态代理 使用JDK的java.lang.reflect.Proxy类的newProxyInstance方法实现的代理。 用一个测试接口看下具体实现： public interface JdkProxyDemoService { void queryTrs(); } @Service public
使用JDK动态代理与CGLIB：介绍一下这两种常用的动态代理技术，并通过示例明确它们的应用场景。
哎 你看的博客
05-21 746
动态代理简介 为什么需要动态代理 动态代理和静态代理的区别 JDK动态代理 JDK动态代理基本原理 如何创建JDK动态代理 示例：使用JDK动态代理增强方法 JDK动态代理的应用场景 CGLIB动态代理 CGLIB动态代理基本原理 如何创建CGLIB动态代理 示例：使用CGLIB动态代理增强方法 CGLIB动态代理的应用场景 JDK动态代理和CGLIB动态代理的比较 工作机制的比较 性能的比较 应用场景的比较 结论 如何选择JDK动态代理和CGLIB动态代理
面试官：说说你对代理模式的理解？应用场景？
weixin_44475093的博客
11-05 1143
一、是什么代理模式（Proxy Pattern）是为一个对象提供一个代用品或占位符，以便控制对它的访问代理模式的关键是，当客户不方便直接访问一个对象或者不满足需要时，提供一个替身对象来控制...
只有掌握了这三种代理模式，才能进军Spring AOP哦！
weixin_34381687的博客
04-02 123
代理模式定义 首先我们来看看代理模式： 所谓代理模式，是指客户端(Client)并不直接调用实际的对象(下图右下角的RealSubject)，而是通过调用代理(ProxySubject)，来间接的调用实际的对象。 代理模式的使用场合，一般是由于客户端不想直接访问实际对象，或者访问实际的对象存在技术上的障碍，因而通过代理对象作为桥梁，来完成间接访问。 业务场景 首先有个UserService接口,...
代理模式 spring简单应用
阿萨的专栏
06-09 353
当前有M个场景S1,S2…Sm，他们有相同的行为和方法，假设有N种方法，所以总共有如下在外部每次调用接口时候，都会根据入参来决定场景是哪个？所以说决定场景的是方法级别。现在我们需要一个类提供外部使用，他需要满足下面的要求相同的行为，不同的场景实现不同，对外一个共同的接口，一看就知道使用设计模式中的Proxy模式，那就我们先看看代理模式的简单UML图吧（图侵删：参考 https://www.runoob.com/design-pattern/proxy-pattern.html） 假设我们有个共同的类，定义
代理模式及在spring中的应用
lonely_baby的博客
02-22 812
UserServiceProxy 是一个代理类，它实现了 UserService 接口，通过在 saveUser 方法中包含了目标对象 UserServiceImpl 的调用，以在目标对象的基础上实现了开启事务和提交事务的功能。Java 动态代理是一种运行时创建代理对象的机制，与静态代理不同，它不需要手动编写代理类，而是在运行时通过 Java API 自动创建代理对象。静态代理是一种常见的设计模式，它通过在代理对象中包含一个目标对象的引用，以在目标对象的基础上实现额外的功能。1.基于接口的动态代理。
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...
Java Spring代理模式AOP-IOC分析
10-01
Java Spring代理模式AOP-IOC分析 一、代理模式概述 在软件设计中，代理模式是一种常用的设计模式。它可以在不修改原始代码的情况下，扩展或修改原始对象的行为。代理模式可以分为静态代理和动态代理两种。静态代理...
【面试】代理模式+动态代理+静态代理+那些使用场景？
m0_64210833的博客
08-08 1304
MyBaits的Mapper接口没有实现类为什么可以用@Autowired直接注入? 使用了JDK动态代理，赋值给mapper接口的对象其实是一个代理对象，这个代理对象是由 JDK 动态代理创建的。在解析mapper的时候，mybatis会通过java反射，获取到接口所有的方法。当调用接口中方法时，将通过接口全限定名+方法名对应找到映射文件中namespace和id匹配的sql，然后进行执行sql语句。..................
java设计模式【之】Cglib动态代理【源码】【场景：帮爸爸买菜】
03-31
java设计模式【之】Cglib动态代理【源码】【场景：帮爸爸买菜】 /** * 代理模式 * 在开发者的角度来看，创建一个代理对象，提供给用户使用，避免用户直接访问真正的对象 * 在用户角度来看，就是普通的类方法调用 * <p> * 作用 * 1.保护被代理对象 * 2.增强被代理对象 * 3.完全替换被代理对象 * <p> * Cglib代理（子类代理） * 可以在运行期，扩展java类与实现接口，在内存中创建一个子类对象，实现代理功能 * 底层通过字节码处理框架ASM,转换字节码并生成新的类 * 被代理类都不需要实现接口 * 代理类需要实现 MethodInterceptor（方法拦截器） * <p> * 1.创建被代理类、创建代理类、代理类内部聚合被代理类 * 2.创建返回代理类实例方法 Enhancer.create(object.getClass(), this); * (1.创建工具类，2.设置工具类的父类为被代理类 3.设计监听回调为当前this 4.return 创建代理类实例对象) * 3.实现接口方法（调用 method.
SpringAOP 代理模式的应用
qq_26185495的博客
05-10 264
SpringAOP 代理模式的应用 代理模式通俗理解： 跟 MM 在网上聊天，一开头总是 “hi, 你好”,“你从哪儿来呀？”“你多大了？”“身高多少呀？” 这些话，真烦人，写个程序做为我的 Proxy 吧，凡是接收到这些话都设置好了自己的回答，接收到其他的话时再通知我回答，怎么样，酷吧。 代理模式：代理模式给某一个对象提供一个代理对象，并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。某些情况下，客户不想或者不能够直接引用一个对象，代理对象可以在客户和目标对象直接
深度理解Spring AOP底层实现：探索代理模式和切面编程的实际运用场景
2201_75630288的博客
03-19 209
Spring AOP是Spring框架的核心组件之一，通过代理模式和切面编程实现对组件的横切关注点的增强，使得业务逻辑更加清晰、可维护和可扩展。本文深度理解了Spring AOP底层实现，探索了代理模式和切面编程的实际运用场景，如日志记录、事务管理、安全控制、性能监控等。通过了解AOP的实现方式和应用场景，可以更好地理解Spring框架的工作原理和优势，提高代码质量和可维护性。
Spring AOP的实现原理及应用场景（通过动态代理）
Java笔记虾
07-05 270
点击关注公众号，利用碎片时间学习AOP的作用作用：在不修改源代码的情况下，可以实现功能的增强。传统的纵向体系代码复用：横向抽取机制（AOP思想）：AOP 思想：基于代理思想，对原来目标对象...
Java中Cglib动态代理介绍、应用场景和示例代码
最新发布
a_beiyo的博客
10-08 701
CGLIB（Code Generation Library）是一个强大的高性能代码生成库，广泛用于在运行时动态生成字节码。它主要用于创建和管理动态代理和字节码操作，尤其是在 Java 中对类的增强和扩展。CGLIB 是一个强大的字节码生成库，适用于需要动态代理和类增强的场景，尤其是在没有接口的情况下。
Spring使用cglib模拟Aop的动态代理对象，以及在Spring其他地方的应用场景
a1032722788的博客
03-26 890
前言 小编在spring的beanPostProcessor详解以及模拟Aop中讲到springBean创建的最后一步调用BeanPostProcessor的postProcessAfterInitialization来进行Aop的处理，Aop的模拟是使用了JDK的动态代理，这次小编使用cglib来实现。 问题 spring在面试的时候总是会问到AOP的原理，事务的原理等，然后继续会问动态代理的实现以及场景？这些相信大家都会容易回答，但是大家有具体看过cglib到底是怎么产生一个代理对象的吗，接下来跟着小编
CGLIB动态代理
待到山花烂漫时
01-16 244
回顾 满足动态代理模式应用场景的三个必要条件，穷举法 1.2个角色：执行者，被代理对象 2.注重过程，必须要做，被代理对象没时间做或者不想做，自己做不专业 3.执行者必须拿到被代理对象的个人资料（持有被代理对象的引用） 媒婆，黄牛，经纪人，中介等 总结：做了一件什么事？字节码重组 上次我用jdk写的动态代理 这次我用cglib 可以做一件什么事？可以再每一个方法调用之前加一些代码，在方法调用之后再...
慌了，老大突然问我基于JDK和CGLib实现动态代理的区别和适用场景
duan18888的博客
05-17 396
在日常的开发中，Spring AOP 是一个非常常用的功能。谈到 AOP，自然离不开动态代理。 那么，基于 JDK 和 CGLib 如何实现动态代理，他们之间的区别和适用场景是什么呢？接下来，我们一起来探讨一下这个问题。 JDK 如何实现动态代理？ 话不多说，我们直接对照着代码来查看。 代码示例 Hello 接口 public interface HelloInterface { /** * 代理的目标方法 */ void sayHello();
基于 JDK 和 CGLib 如何实现动态代理，他们之间的区别和适用场景是什么呢？
JAVA88866的博客
05-17 495
在日常的开发中，Spring AOP 是一个非常常用的功能。谈到 AOP，自然离不开动态代理。 那么，基于 JDK 和 CGLib 如何实现动态代理，他们之间的区别和适用场景是什么呢？接下来，我们一起来探讨一下这个问题。 JDK 如何实现动态代理？ 话不多说，我们直接对照着代码来查看。 代码示例 Hello 接口 public interface HelloInterface { /** * 代理的目标方法 */ void sayHello();
深入理解JDK与CGlib动态代理源码解析
由于不需要目标对象实现接口，CGlib更适合在复杂的业务场景中实现AOP，例如在Spring框架中大量使用CGlib来实现面向切面编程。 ### 总结 理解JDK和CGlib动态代理的实现原理，对于深入掌握Java编程和面向切面编程是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

unhappy404

感谢老板打赏！！！爱您

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值