设计模式之代理模式（结构型）

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量287 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 代理模式 java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wk_java_1619/article/details/122992079
版权

在介绍代理模式之前，博主想说点儿“题外”话，博主喜欢玩游戏，特别喜欢玩英雄联盟，尤其喜欢玩压缩，博主的压缩玩的可以说“出神入化”，博主的朋友都叫博主“托儿索”，话说回来，博主的压缩虽然玩的出神入化，特别喜欢浪，但是补刀不咋滴，作为一个程序员，博主决定统计一下楼主的补刀数。

上代码：

public class YaSuo implements Mendable{

    @Override
    public int mend() {
        int killNum = new Random().nextInt(100);
        return killNum;
    }

    public static void main(String[] args) {
        new YaSuo().mend();
    }
}

interface Mendable {
    int mend();
}

代码很简单，说这个“YaSuo”，有一个补刀的方法，在随缘的补刀。问题来了，我想记录一下这个“YaSuo”补刀的个数，我想大家已经想出来了，不就是加个日志，打印一下补刀的个数嘛，来上代码：

public class YaSuo implements Mendable{

    @Override
    public int mend() {
        System.out.println("YaSuo killing batman...");
        int killNum = new Random().nextInt(100);
        System.out.println("YaSuo 10 min mend:" + killNum);
        return killNum;
    }

    public static void main(String[] args) {
        new YaSuo().mend();
    }
}

interface Mendable {
    int mend();
}

来看下结果，博主的随缘补刀大法：

YaSuo killing batman...
YaSuo 10 min mend:67

及格了，博主的补刀能力大增，话说以前都是10 min 补刀 四五十刀。

那么问题又来了，博主不想修改源码或者根本无法修改源码，那怎么办呢 ？

有人说了可以用继承嘛，来上继承：

public class YaSuo implements Mendable {

    @Override
    public int mend() {
        int killNum = new Random().nextInt(100);
        return killNum;
    }

    public static void main(String[] args) {
        new YaSuo1().mend();
    }
}

class YaSuo1 extends YaSuo {

    @Override
    public int mend() {
        System.out.println("YaSuo killing batman...");
        int killNum = super.mend();
        System.out.println("YaSuo 10 min mend:" + killNum);
        return killNum;
    }
}

interface Mendable {
    int mend();
}

继承虽然可以实现结果，但是继承有缺点，耦合度太高，破坏了封装性，我们应该慎用继承。

那该怎么办呢？回到我们今天的重点：代理模式。

用代理来实现，上代码：

public class YaSuo implements Mendable {

    @Override
    public int mend() {
        int killNum = new Random().nextInt(100);
        return killNum;
    }

    public static void main(String[] args) {
        new YaSuoProxy(new YaSuo()).mend();
    }
}

class YaSuoProxy implements Mendable {

    YaSuo yaSuo;

    public YaSuoProxy(YaSuo yaSuo) {
        this.yaSuo = yaSuo;
    }

    @Override
    public int mend() {
        System.out.println("YaSuo killing batman...");
        int killNum = yaSuo.mend();
        System.out.println("YaSuo 10 min mend:" + killNum);
        return killNum;
    }
}

interface Mendable {
    int mend();
}

这就是静态代理。

那么问题又来了，作为一个好的程序应该具备良好 的扩展性，现在我统计补刀数，那我们还想统计杀人数、助攻数，那怎么办呢？

那我们可以再加一个代理类来代理统计助攻数，代码如下：

public class YaSuo implements Mendable {

    @Override
    public int mend() {
        int killNum = new Random().nextInt(100);
        return killNum;
    }

    public static void main(String[] args) {
        new YaSuoProxy(new YaSuo()).mend();
    }
}

class YaSuoProxy implements Mendable {

    YaSuo yaSuo;

    public YaSuoProxy(YaSuo yaSuo) {
        this.yaSuo = yaSuo;
    }

    @Override
    public int mend() {
        System.out.println("YaSuo killing batman...");
        int killNum = yaSuo.mend();
        System.out.println("YaSuo 10 min mend:" + killNum);
        return killNum;
    }
}

class YaSuoAssistProxy implements Mendable {

    Mendable m;

    public YaSuoAssistProxy(Mendable m) {
        this.m = m;
    }

    @Override
    public int mend() {
        System.out.println("YaSuo assist...");
        int killNum = m.mend();
        System.out.println("YaSuo assist:" + killNum);
        return killNum;
    }
}

interface Mendable {
    int mend();
}

那我们现在想灵活组合统计补刀数、助攻数，怎么 做呢？来看代码：

public class YaSuo implements Mendable {

    @Override
    public int mend() {
        int killNum = new Random().nextInt(100);
        return killNum;
    }

    public static void main(String[] args) {
        new YaSuoProxy(new YaSuoAssistProxy(new YaSuo())).mend();
    }
}

class YaSuoProxy implements Mendable {

    Mendable m;

    public YaSuoProxy(Mendable m) {
        this.m = m;
    }

    @Override
    public int mend() {
        System.out.println("YaSuo killing batman...");
        int killNum = m.mend();
        System.out.println("YaSuo 10 min mend:" + killNum);
        return killNum;
    }
}

class YaSuoAssistProxy implements Mendable {

    Mendable m;

    public YaSuoAssistProxy(Mendable m) {
        this.m = m;
    }

    @Override
    public int mend() {
        System.out.println("YaSuo assist...");
        int killNum = m.mend();
        System.out.println("YaSuo assist:" + killNum);
        return killNum;
    }
}

interface Mendable {
    int mend();
}

有没有觉得眼熟呢？不错，就是装饰者模式--Decorator。很像装饰者模式。

作为一个优秀的程序，它不应该只能代理一个方法、一种类型，应该还可以代理任何其他可以代理的类型 Object，该怎么办呢？既然有静态代理，有没有动态代理？回答是肯定的。来看动态代理：

public class YaSuo implements Mendable {

    @Override
    public int mend() {
        int killNum = new Random().nextInt(100);
        return killNum;
    }

    public static void main(String[] args) {
        YaSuo yaSuo = new YaSuo();
        Mendable m = (Mendable)Proxy.newProxyInstance(YaSuo.class.getClassLoader(),
                new Class[]{Mendable.class}, (proxy, method, args1) -> {
                    System.out.println("YaSuo killing batman...");
                    Object o = method.invoke(yaSuo, args1);
                    System.out.println("YaSuo 10 min mend:" + o);
                    return o;
                }
        );
        m.mend();
    }
}

interface Mendable {
    int mend();
}

我们也可以写成这样：

public class YaSuo implements Mendable {

    @Override
    public int mend() {
        int killNum = new Random().nextInt(100);
        return killNum;
    }

    public static void main(String[] args) {
        YaSuo yaSuo = new YaSuo();
        Mendable m = (Mendable)Proxy.newProxyInstance(YaSuo.class.getClassLoader(),
                new Class[]{Mendable.class}, new MyHandler(yaSuo));
        m.mend();
    }
}

class MyHandler implements  InvocationHandler {

    Mendable m;

    public MyHandler(Mendable m) {
        this.m = m;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("YaSuo killing batman...");
        Object o = method.invoke(m,args);
        System.out.println("YaSuo 10 min mend:" + o);
        return o;
    }
}

interface Mendable {
    int mend();
}

可以看到代码量很少，我们上面的代码有自己实现的代理类，如：YaSuoProxy、YaSuoAssistProxy，那动态代理有没有实现代理类呢？有的，在内存里，当然我们也可以生成出来。通过以下方式：

public class ProxyTest {
    public static void main(String[] args) {
        byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Mendable.class});
        try {
        FileOutputStream fileOutputStream = new FileOutputStream("D://$Proxy0.class");
            fileOutputStream.write(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

生成到D盘。用反编译工具打开来。

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

public final class $Proxy0 extends Proxy implements Mendable {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int mend() throws  {
        try {
            return (Integer)super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.wangkai.design.structure.proxy.v4.Mendable").getMethod("mend");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

 这就是我们生成的代理类。可以看到把 InvocationHandler 传到了构造函数当中，生成了equals方法、toString方法、hashCode方法。当然必须有我们的mend方法。当我们生成的代理对象$Proxy0调用mend方法的时候，会去调用InvocationHandler的invoke方法，在invoke方法调用了我们被代理类的mend方法，所以我们才可以在调用被代理类的mend方法前后加自己的代码，比如统计接口时间，比如添加权限校验等等一系列操作，这就是jdk动态代理的逻辑。

可以看到的是，jdk动态代理  被代理类是需要实现接口的。

看完动态代理，再看一下cglib代理：

cglib（Code Generation Library），是一个强大的，高性能，高质量的Code生成类库。

public class Client {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(YaSuo.class);
        enhancer.setCallback(new TimeMethodInterceptor());
        YaSuo yaSuo = (YaSuo)enhancer.create();
        yaSuo.mend();
    }
}

class TimeMethodInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println(o.getClass().getSuperclass().getName());
        System.out.println("YaSuo killing batman...");
        Object result = methodProxy.invokeSuper(o, objects);
        System.out.println("YaSuo 10 min mend:" + result);
        return result;
    }
}

class YaSuo {
    public int mend() {
        int killNum = new Random().nextInt(100);
        return killNum;
    }
}

用cglib代理，需要在pom.xml文件加上

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

CGLIB底层使用了ASM（一个短小精悍的字节码操作框架）来直接操作字节码生成新的类。除了CGLIB库外，脚本语言（如Groovy何BeanShell）也使用ASM生成字节码。

cglib代理是通过一个Enhancer和一个MethodInterceptor来实现对方法的拦截，这里的TimeMethodInterceptor 相当于jdk动态代理的InvocationHandler，被代理类没有实现任何接口，那么我们怎么知道生成的代理对象要生成哪个方法呢？其实我们生成的代理对象是被代理类的子类，也就是intercept方法中的参数o，我们打印一下o的父类：

com.wangkai.design.structure.proxy.v5.YaSuo
YaSuo killing batman...
YaSuo 10 min mend:49

可以看到生成的代理类的父类是YaSuo这个类。那么现在问题来了，既然生成的代理类是被代理类的子类，那么如果被代理类是final的话，还能用cglib代理生成代理类吗？我们试一下：

 可以看到报错了。所以是不能的。

jdk代理和cglib代理都介绍完了，我们来对比一下它们：

1、jdk动态代理是实现了被代理对象的接口，在调用具体方法前调用InvokeHandler来处理。如果被代理对象实现了接口，默认情况下会采用jdk的动态代理实现AOP。

cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。并且cglib不可以代理final修饰的类。

2、jdk动态代理是Java自带的，cglib动态代理是第三方jar包提供的。

3、jdk动态代理实现的逻辑是目标类和代理类都实现同一个接口，目标类和代理类是平级的。而cglib动态代理实现的逻辑是继承目标类，是目标类的子类，目标类和代理类是父子继承关系。

wk_java_231214
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式——代理模式（结构型）
小张的记录
07-22 106
观察者模式 （1）模式动机 建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应做出反应。在此，发生改变的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，可以根据需要增加和删除观察者，使得系统更易于扩展，这就是观察者模式的模式动机。 （2）模式定义 观察者模式(Observer Pattern)：定义对象...
设计模式（一）代理模式
White
09-09 359
1 内容 客户端不直接调用实际对象方法.而是通过调用代理对象方法，来间接调用实际对象方法.类似现实生活中租房子的人去房产中介公司找中介人员获取房源信息，签订租房合约. 2 为什么用代理模式？ （1）隔离作用 租房客户只关心房源在哪儿不关心房主是什么. （2）开闭原则 代理类不光是客户类和委托类的中介，还可以增加额外功能.中介公司工作人员还可以提供房屋水管家具维修服务. 3 优缺点 优点 （1）将代理对与真是对象被调用的目标对象分离 （2）降低系统耦合性，扩展性好 （3）保护目标对象 （4）增强目标对象 缺
设计模式 - 结构型设计模式小结
热门推荐
了解➔熟悉➔掌握➔精通
02-02 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net Definition Specify the kind of objects to create using a prototypical instance, and create new objects by copying this prot...
结构型设计模式（7种）
qq_52793248的博客
12-14 3552
结构型设计模式（7种）
设计模式之代理模式(C++)
翟天保的博客
04-04 2万+
介绍设计模式之代理模式
c++设计模式-结构型模式-代理模式
06-12
代理模式是一种在面向对象设计中广泛应用的结构型设计模式，它提供了一种对目标对象进行间接访问的方式，使得客户端可以通过代理对象与真实对象进行交互，而无需直接接触真实对象。这样做的好处包括增加灵活性、控制...
设计模式原理与应用之结构型模式.pptx
09-28
结构型模式是设计模式的一种分类，它关注如何组合类和对象，构建更大的结构。本篇主要讨论了七种结构型模式：Adapter、Bridge、Composite、Decorator、Façade、Flyweight和Proxy。 1. **Adapter模式**： - 适配器...
JAVA-设计模式-结构型模式-代理模式
08-10
JAVA-设计模式-结构型模式-代理模式
浅谈C#设计模式之代理模式
12-26
代理模式是常用的结构型设计模式之一,当无法直接访问某个对象或访问某个对象存在困难时可以通过一个代理对象来间接访问,为了保证客户端使用的透明性,所访问的真实对象与代理对象需要实现相同的接口.根据代理模式的...
一文总结代理：代理模式、代理服务器
lonelymanontheway的博客
07-25 856
概述、角色、UML类图、调用顺序示意图、分类（虚拟代理、远程代理、保护代理、同步代理、智能引用代理）、静态代理、动态代理、JDK动态代理（实例、源码分析）、cglib动态代理（实例、源码分析）、JDK和cglib动态代理区别、Spring AOP； 代理服务器、正向代理、反向代理。
【Leetcode】十八、动态规划：不同路径 + 全1的最大正方形
llg___的博客
07-23 929
因为只能向下、向右走，所以从起始点走到点（R，C），路径数等于，以起始点到点（R，C）为对角线的矩形里，到点（R，C）左侧点的路径数 + 到点（R，C）上边点的路径数。从起始状态（0，0），到终止状态（R，C），中间每个格子的值（到达它的路径数），都会算出来，这些中间结果，可存入一个数组，这题可用二维数组存。前面已经分析过了，这儿的方程式为：F(m，n）= F(m - 1，n）+ F(m，n - 1），初始状态为（1，1），终止状态为（m，n）只能向下、向右的走，从图中左上角走到右下角，有几条路径。
2024.7.24
m0_66929001的博客
07-24 986
总的来说，预处理是为了使后续的主要处理过程更加高效、简洁和准确。
golang 接口
m0_70982551的博客
07-24 927
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 502
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 617
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 581
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 358
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 418
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
设计模式解析：结构型模式之适配器模式详解
设计模式结构型模式是一种用于软件设计的模式，它们关注如何组织类和对象，以便更好地构建系统结构。本文主要讨论的是适配器模式，它是结构型模式的一种，主要解决接口不兼容问题。 适配器模式由三个关键角色组成：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值