代理模式的分类和使用

已于 2023-08-06 16:39:52 修改
阅读量70 收藏
点赞数
分类专栏： 编程思想 文章标签： 代理模式 设计模式
于 2023-08-05 14:32:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fu_Cong/article/details/132119568
版权

代理的定义

对其他对象提供一种代理，以控制对这个对象的访问。

静态代理

静态代理是最基本的代理模式，它需要手动编写代理类。在 Java 中，可以通过实现或继承相同的接口或父类，使得代理对象拥有与实际对象相同的方法和属性。代理对象在调用实际对象的方法时，可以在方法前或方法后添加一些额外的操作，以实现特定的功能。

继承

代理对象继承目标对象，重写需要增强的方法。

如何使用

  1. 计算器接口
/**
 * 计算器接口
 *
 * @author 付聪
 * @time 2023/7/30 17:10
 */
public interface Calculator {

    int add(int a, int b);
    int sub(int a, int b);
    int mul(int a, int b);
    int div(int a, int b);

}
  1. 真正的计算器类
/**
 * 真正的计算器类
 *
 * @author 付聪
 * @time 2023/7/30 17:10
 */
public class RealCalculator01 implements Calculator {

    @Override
    public int add(int a, int b) {
        System.out.println("我是计算器：RealCalculator01");
        return a + b;
    }

    @Override
    public int sub(int a, int b) {
        System.out.println("我是计算器：RealCalculator01");
        return a - b;
    }

    @Override
    public int mul(int a, int b) {
        System.out.println("我是计算器：RealCalculator01");
        return a * b;
    }

    @Override
    public int div(int a, int b) {
        System.out.println("我是计算器：RealCalculator01");
        if (b == 0) {
            throw new IllegalArgumentException("除数不能为零！");
        }
        return a / b;
    }

}
  1. 计算器代理类（继承）
/**
 * 计算器代理类（继承）
 *
 * @author 付聪
 * @time 2023/7/30 17:12
 */
public class CalculatorProxy01 extends RealCalculator01 {

    @Override
    public int add(int a, int b) {
        System.out.println("CalculatorProxy01执行加法操作......");
        return super.add(a, b);
    }

    @Override
    public int sub(int a, int b) {
        System.out.println("CalculatorProxy01执行减法操作......");
        return super.sub(a, b);
    }

    @Override
    public int mul(int a, int b) {
        System.out.println("CalculatorProxy01执行乘法操作......");
        return super.mul(a, b);
    }

    @Override
    public int div(int a, int b) {
        System.out.println("CalculatorProxy01执行除法操作......");
        return super.div(a, b);
    }

}
  1. 测试
/**
 * 代理测试
 *
 * @author 付聪
 * @time 2023/7/30 17:14
 */
public class ProxyTest01 {
    public static void main(String[] args) {

        CalculatorProxy01 calculatorProxy01 = new CalculatorProxy01();
        calculatorProxy01.add(1, 1);

    }
}
  1. 结果

image.png

聚合

通过在代理类中引用接口进行灵活使用的方式

如何使用

  1. 计算器接口
/**
 * 计算器接口
 *
 * @author 付聪
 * @time 2023/7/30 17:10
 */
public interface Calculator {

    int add(int a, int b);
    int sub(int a, int b);
    int mul(int a, int b);
    int div(int a, int b);

}
  1. 真正的计算器类
/**
 * 真正的计算器类
 *
 * @author 付聪
 * @time 2023/7/30 17:10
 */
public class RealCalculator02 implements Calculator {

    @Override
    public int add(int a, int b) {
        System.out.println("我是计算器：RealCalculator02");
        return a + b;
    }

    @Override
    public int sub(int a, int b) {
        System.out.println("我是计算器：RealCalculator02");
        return a - b;
    }

    @Override
    public int mul(int a, int b) {
        System.out.println("我是计算器：RealCalculator02");
        return a * b;
    }

    @Override
    public int div(int a, int b) {
        System.out.println("我是计算器：RealCalculator02");
        if (b == 0) {
            throw new IllegalArgumentException("除数不能为零！");
        }
        return a / b;
    }

}
  1. 计算器代理类（聚合）
/**
 * 计算器代理类（聚合）
 *
 * @author 付聪
 * @time 2023/7/30 17:12
 */
public class CalculatorProxy02 implements Calculator {

    private final Calculator calculator;

    // 装饰着模式
    public CalculatorProxy02(Calculator calculator) {
        this.calculator = calculator;
    }

    @Override
    public int add(int a, int b) {
        System.out.println("CalculatorProxy02执行加法操作......");
        return calculator.add(a, b);
    }

    @Override
    public int sub(int a, int b) {
        System.out.println("CalculatorProxy02执行减法操作......");
        return calculator.sub(a, b);
    }

    @Override
    public int mul(int a, int b) {
        System.out.println("CalculatorProxy02执行乘法操作......");
        return calculator.mul(a, b);
    }

    @Override
    public int div(int a, int b) {
        System.out.println("CalculatorProxy02执行除法操作......");
        return calculator.div(a, b);
    }

}
  1. 测试
/**
 * 代理测试
 *
 * @author 付聪
 * @time 2023/7/30 17:14
 */
public class ProxyTest01 {
    public static void main(String[] args) {

        CalculatorProxy02 calculatorProxy01 = new CalculatorProxy02(new RealCalculator01());
        calculatorProxy01.add(1, 1);

        CalculatorProxy02 calculatorProxy02 = new CalculatorProxy02(new RealCalculator02());
        calculatorProxy02.add(1, 1);

    }
}
  1. 结果

image.png

静态代理的优缺点

优点

  1. 业务类只需要关注业务逻辑本身，保证了业务类的重用性。

缺点

  1. 需要手动编写代理类，工作量较大；
  2. 目标对象必须实现接口；
  3. 代理类和目标类的关系在编译时就确定了，无法动态改变。

动态代理

JDK动态代理

JDK动态代理是Java标准库提供的一种动态代理实现方式，它基于接口代理实现。在 JDK 动态代理中，我们需要通过java.lang.reflect.Proxy类来生成代理对象。

如何使用

  1. 计算器接口
/**
 * 计算器接口
 *
 * @author 付聪
 * @time 2023/7/30 17:10
 */
public interface Calculator {

    int add(int a, int b);
    int sub(int a, int b);
    int mul(int a, int b);
    int div(int a, int b);

}
  1. 真正的计算器类
/**
 * 真正的计算器类
 *
 * @author 付聪
 * @time 2023/7/30 17:10
 */
public class RealCalculator02 implements Calculator {

    @Override
    public int add(int a, int b) {
        System.out.println("我是计算器：RealCalculator02");
        return a + b;
    }

    @Override
    public int sub(int a, int b) {
        System.out.println("我是计算器：RealCalculator02");
        return a - b;
    }

    @Override
    public int mul(int a, int b) {
        System.out.println("我是计算器：RealCalculator02");
        return a * b;
    }

    @Override
    public int div(int a, int b) {
        System.out.println("我是计算器：RealCalculator02");
        if (b == 0) {
            throw new IllegalArgumentException("除数不能为零！");
        }
        return a / b;
    }

}
  1. 使用JDK动态代理来生成代理对象

示例代码

/**
 * JDK动态代理类处理器
 *
 * @author 付聪
 * @time 2023/7/31 21:49
 */
public class CalculatorInvocationHandler implements InvocationHandler {

    private final Object target;

    public CalculatorInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("执行【invoke】方法前......");
        Object result = method.invoke(target, args);
        System.out.println("执行【invoke】方法后......");
        return result;
    }

}

代码说明

在这里插入图片描述
在这里插入图片描述

  1. 测试

示例代码

/**
 * 代理测试
 *
 * @author 付聪
 * @time 2023/7/30 17:14
 */
public class ProxyTest02 {
    public static void main(String[] args) {

        Calculator calculator = new RealCalculator01();
        CalculatorInvocationHandler calculatorInvocationHandler = new CalculatorInvocationHandler(calculator);
        Calculator proxy = (Calculator) Proxy.newProxyInstance(calculator.getClass().getClassLoader(), calculator.getClass().getInterfaces(), calculatorInvocationHandler);
        proxy.add(1,1);

    }
}

代码说明

在这里插入图片描述

  1. 结果

image.png

CGLB动态代理

CGLIB动态代理是一种不基于接口的动态代理实现方式，它可以代理没有实现接口的类。在CGLIB动态代理中，我们需要通过net.sf.cglib.proxy.Enhancer类来生成代理对象。

如何使用

  1. 真正的计算器类
/**
 * 真正的计算器类（没有实现任何接口）
 *
 * @author 付聪
 * @time 2023/7/30 17:10
 */
public class RealCalculator03 {

    public int add(int a, int b) {
        System.out.println("我是计算器：RealCalculator03");
        return a + b;
    }

    public int sub(int a, int b) {
        System.out.println("我是计算器：RealCalculator03");
        return a - b;
    }

    public int mul(int a, int b) {
        System.out.println("我是计算器：RealCalculator03");
        return a * b;
    }

    public int div(int a, int b) {
        System.out.println("我是计算器：RealCalculator03");
        if (b == 0) {
            throw new IllegalArgumentException("除数不能为零！");
        }
        return a / b;
    }

}
  1. 创建类CGLB动态代理类拦截器实现cglib下的MethodInterceptor接口，并重写intercept方法。

示例代码

/**
 * CGLB动态代理类拦截器
 *
 * @author 付聪
 * @time 2023/7/31 21:49
 */
public class CalculatorInterceptor implements MethodInterceptor {

    private Object target;

    public CalculatorInterceptor(Object target) {
        this.target = target;
    }

    @Override
    public Object intercept(Object object, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("执行【invokeSuper】方法前......");
        Object result = methodProxy.invokeSuper(object, objects);
        System.out.println("执行【invokeSuper】方法后......");
        return result;
    }

}

代码说明

在这里插入图片描述
在这里插入图片描述

  1. 测试

示例代码

/**
 * 代理测试
 *
 * @author 付聪
 * @time 2023/7/30 17:14
 */
public class ProxyTest02 {
    public static void main(String[] args) {

        RealCalculator03 target = new RealCalculator03();
        // Enhancer是cglib中使用频率很高的一个类，它是一个字节码增强器，可以用来为无接口的类创建代理。
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(RealCalculator03.class);
        // 设置enhancer的回调对象
        enhancer.setCallback(new CalculatorInterceptor(target));
        // 创建代理对象
        RealCalculator03 realCalculator03 = (RealCalculator03)enhancer.create();
        realCalculator03.add(1, 1);

    }
}

代码说明

image.png
image.png
image.png

  1. 结果

image.png

动态代理的优缺点

优点

  1. 动态代理与静态代理相比较，最大的好处是增强的方法转移到了统一的方法处理（invoke方法和intercept方法），在方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样在每一个方法里处理。而且动态代理的应用使我们的类职责更加单一，复用性更强。

缺点

  1. JDK动态代理只能基于接口进行代理；
  2. JDK动态代理不能代理private、static修饰的方法：因为在JDK动态代理中，代理类和被代理类需要实现共同的接口，而private、static方法都是无法修饰接口方法的；
  3. CGLB不能代理private、final、static方法： 因为cglib代理类是通过继承被代理类实现的，如果方法被private修饰，那么子类是无法调用超类的私有方法的；如果被final修饰，那也就无法重写需要代理的方法；如果被static修饰，从技术的角度是可以实现的，但是被排除了，因为从程序的设计角度来讲，静态方法是属于类的，而不是属于某个对象的。

代理的使用场景

  1. 当我们想要隐藏某个类时，可以为其提供代理类；
  2. 当一个类需要对不同的调用者提供不同的调用权限时，可以使用代理类来实现（代理类不一定只有一个，我们可以建立多个代理类来实现，也可以在一个代理类中进行权限判断来进行不同权限的功能调用）；
  3. 当我们要扩展某个类的某个功能时，可以使用代理模式，在代理类中进行简单扩展。
付聪1210
关注
专栏目录
C++设计模式之代理模式(Proxy)
12-26
代理模式是一种程序设计最为重要的一种模式，其具体的使用非常广泛，根据它的作用，其实我们可以直接理解为中间件或者中间层，比如各类软件的中间件，软件与硬件中的中间层。 作用 为其他对象提供一种代理以控制对...
代理模式Demo
05-31
2. **代理模式的分类** - **远程代理（Remote Proxy）**：为远程对象提供一个本地代表，使得客户端可以像调用本地对象一样操作远程对象。 - **虚拟代理（Virtual Proxy）**：根据需要创建开销大的对象，例如在图片...
代理模式的优缺点和使用场景
m0_51982191的博客
08-30 1467
代理模式的优缺点和使用场景
代理模式（详解）
weixin_67417798的博客
06-04 3019
代理模式是一种结构型设计模式，它为对象提供了一个代理，并由代理对象控制对原对象的访问。这可以是出于安全、性能、事务等多种原因。简单来说，代理模式就是通过代理对象来控制对实际对象的访问。代理对象在客户端和目标对象之间起到了中介的作用。代理模式通过引入代理对象，在不修改原始对象的情况下，为其添加额外的功能或控制。无论是静态代理、动态代理还是CGLIB代理，它们都有各自的优缺点，开发者可以根据具体的需求选择合适的代理方式。希望本文能帮助你更好地理解代理模式，并在实际项目中灵活应用。
设计模式--工厂模式、适配器模式和代理模式
Baizeh的博客
07-10 2906
工厂模式目的是将创建对象的具体过程屏蔽隔离起来，从而达到更高的灵活性，工厂模式分为三类： 简单工厂模式 || 工厂方法模式 || 抽象工厂模式。
Java代理模式
qq_52519008的博客
09-30 2814
首先, 定义接口和接口的实现类, 然后定义接口的代理对象, 将接口的实例注入到代理对象中, 然后通过代理对象去调用真正的实现类，实现过程非常简单也比较容易理解, 静态代理的代理关系在编译期间就已经确定了的。首先通过 newProxyInstance 方法获取代理类的实例, 之后就可以通过这个代理类的实例调用代理类的方法，对代理类的方法调用都会调用中间类 (实现了 invocationHandle 的类) 的 invoke 方法，在 invoke 方法中我们调用委托类的对应方法，然后加上自己的处理逻辑。
瑞_23种设计模式_代理模式
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
02-19 1978
本文章为瑞_系列专栏之《23种设计模式》的代理模式篇。在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。
Java之代理模式解析
weixin_47936134的博客
01-26 1417
代理模式为目标对象提供代理服务，客户端不直接操作目标对象，而是通过代理类管理对象，是不是有点类似Spring的IoC容器，每错！Spring等框架就是很多技术的融合，设计时融入了许多设计模式的思想。
Java中的代理模式(动态代理和静态代理)
qq_64064246的博客
03-21 1263
我们先了解一下代理模式：在开发中，当我们要访问目标类时，不是直接访问目标类，而是访问器代理类。通过调用完成操作。简单来说就是：把直接访问变为间接访问。比如说：我们可以在方法开始和结束前记录日志：在方法执行前进行额外的参数校验，进行事务管理，如手动提交、权限校验等。代理模式是一种设计思想，实际实现方式上有和之分。
Spring的AOP之代理模式
长安不及十里的博客
08-03 5087
关于两者之间的性能的话，网上有人对于不通版本的jdk进行测试，经过多次试验，测试结果大致是这样的，在1.6和1.7的时候，JDK动态代理的速度要比CGLib动态代理的速度要慢，但是并没有教科书上的10倍差距，在JDK1.8的时候，JDK动态代理的速度已经比CGLib动态代理的速度快很多了，但是JDK动态代理和CGLIB动态代理的适用场景还是不一样的哈！动态代理生成的代理类通常是在运行时通过字节码生成技术生成的，因此在创建代理对象时，需要一个 ClassLoader 来加载这个新生成的代理类。
spring的代理模式
weixin_43723296的博客
07-07 3729
1、何为代理模式 如何实现在不修改源码的基础上实现代码功能的增强呢？spring为我们提供了代理模式。所谓的代理模式通俗来说就是一个中介，它给某一个对象提供一个代理对象，并由代理对象控制原对象的引用，从而实现在不修改源码的基础上实现代码功能的增强。2、分类 按照代理创建的时期进行分类，可以分为两类：静态代理、动态代理。 静态代理的代理类=原始类+增强（额外功能）+和原始类实现同一个接口，即基于接口的代理。 动态代理又分为jdk动态代理，其也是基于接口的
设计模式第4讲——代理模式（Proxy）
让~学习~成为一种习惯（橡 皮 人の技术博客）
05-31 7308
代理模式属于结构型设计模式。一、什么是代理模式二、分类 三、特点 四、应用场景4.1 生活场景4.2 Java场景 五、代码实现5.0 代码结构5.1 静态代理5.2 JDK动态代理5.3 Cglib代理 六、总结
Java设计模式及应用场景之《代理模式》
12-21
**三、代理模式分类** 1. **虚拟代理**：延迟加载大型资源，如图片、视频等，只在真正需要时才加载。 2. **保护代理**：根据用户权限决定是否允许访问真实对象。 3. **远程代理**：为远程对象提供本地接口，如Java的...
设计模式之代理模式
qq_68883928的博客
10-08 475
​ 在代理模式（Proxy Pattern）中，一个类代表另一个类的功能，这种类型的设计模式属于结构型模式。代理模式通过引入一个代理对象来控制对原对象的访问。代理对象在客户端和目标对象之间充当中介，负责将客户端的请求转发给目标对象，同时可以在转发请求前后进行额外的处理。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
LabVIEW提高开发效率技巧----调度器设计模式
bjcyck的博客
10-04 1353
在LabVIEW开发中，针对多任务并行的需求，使用调度器设计模式（Scheduler Pattern）可以有效地管理多个任务，确保它们根据优先级或时间间隔合理执行。这种模式在需要多任务并发执行时特别有用，尤其是在实时系统、数据采集、硬件控制等场景中。
设计模式、系统设计 record part04
最新发布
m0_47505062的博客
10-08 854
结构型。
Prototype(原型模式)
TimerSea的博客
10-06 540
本篇介绍了原型设计模式基础与实现示例
JS设计模式之策略模式：灵活、可扩展的编程利器
前端梦工厂
10-08 983
在 JavaScript 前端开发中，随着代码规模的增长和项目的复杂性，我们常常需要处理各种不同的条件和情况，而这可能导致代码变得冗长、难以维护。这时，我们就需要一种强大而灵活的编程模式来应对这些复杂的逻辑，策略模式就是其中之一。策略模式是一种经典的设计模式，它通过将特定操作封装在独立的策略函数中，使得我们能够轻松地切换和组合不同的算法和策略。在 JavaScript 中，策略模式可以帮助我们处理各种条件判断、算法选择和逻辑分支，提高代码的可读性、可维护性和可扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

付聪1210

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值