【Java设计模式】——代理模式_接口增加方法的实现不修改其他实现类

2401_84519663

于 2024-04-20 20:23:28 发布

阅读量843

点赞数 29

分类专栏： 2024年程序员学习文章标签： java 设计模式代理模式

本文链接：https://blog.csdn.net/2401_84519663/article/details/138010267

版权

2024年程序员学习专栏收录该内容

22 篇文章 0 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：xhs1999xhs （备注Java）

正文

💻个人简介

⌨️作者简介：大家好，我是〖雪月清〗 ❄️
🎉个人主页：〖雪月清〗🌸
📣往期链接：原型模式工厂模式单例模式
参考黑马Java设计模式

🍉 代理模式

🍊1.概述

由于某些原因需要给一些对象提供一个代理来控制对该对象的访问。此时，访问对象不是直接访问目标对象而是通过代理对象作为中介进行访问。（类似于租房找中介，中介就相当于代理对象）

Java中的代理按照代理类生成时机不同又分为静态代理和动态代理。静态代理代理类在编译期生成，而动态代理代理类在Java运行时动态生成。动态代理又有JDK代理 和CGLib代理两种

🍊2.结构

抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。（规定代理类代理目标对象的规则）
真实主题（Real Subject）类：实现抽象主题中的具体业务，是代理对象所代表的真实对象，即目标对象
代理（Proxy）类：提供与真实主题相同的接口，其内部含有对真实主题的引用，可以访问、控制、扩展真实主题的功能

🍊3.静态代理

火车站售票例子

卖火车票的接口（抽象主题类）

public interface SellTickets {
//卖火车票的接口

    /\*\*
 \* 卖票
 \*/
    void sell();
}

火车站类(真实主题类)

public class TrainStation implements SellTickets{
    //火车站类
    @Override
    public void sell() {
        System.out.println("买票成功.....");
    }
}

火车票代售点（代理类）

//代理类
public class ProxyPoint implements SellTickets{

    /\*\*
 声明火车站类对象
 \*/
    private TrainStation trainStation = new TrainStation();

    @Override
    public void sell() {
        System.out.println("代售点收取服务费");
           trainStation.sell();
    }

}

客户类(访问类)

public class Client {
    public static void main(String[] args) {
        //创建代理对象
        ProxyPoint proxyPoint = new ProxyPoint();
        //买票
        proxyPoint.sell();
    }
}

运行结果：

🍊4.动态代理

🍋4.1JDK动态代理

Java中提供一个动态代理类Proxy，Proxy不是上述的代理对象的类，而是创建代理对象类的类，Proxy类中提供的静态方法newProxyInstance可以获取代理对象类（这是由于动态代理代理类在Java程序运行时动态生成这一特性决定的）

🌰JDK动态代理实现

卖火车票的接口（抽象主题类）

public interface SellTickets {
//卖火车票的接口

    /\*\*
 \* 卖票
 \*/
    void sell();
}

火车站类(真实主题类)

public class TrainStation implements SellTickets{
    //火车站类
    @Override
    public void sell() {
        System.out.println("买票成功.....");
    }
}

代理对象工厂类


/\*\*
 \*
 获取代理对象的工厂类
 代理类也实现了对应的接口
 \*/
public class ProxyFactory {

    //声明目标对象
    private  TrainStation trainStation = new TrainStation();

    public SellTickets getProxyObject(){
    //返回代理对象
        SellTickets proxyObject = (SellTickets) Proxy.newProxyInstance(trainStation.getClass().getClassLoader(),
                trainStation.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        System.out.println("invoke方法执行了");
                        return null;
                    }
                }
        );
        /\*\*
 \* newProxyInstance方法中的三个参数
 \* ClassLoader loader : 类加载器，用于加载代理类，可以通过目标对象获得类加载器
 \* Class<?>[] interfaces : 代理类实现的接口的字节码对象
 \*InvocationHandler h :代理对象的调用处理程序
 \*/
        return  proxyObject;
    }
}

客户类（访问类）

public class Client {
    public static void main(String[] args) {
        //获取代理对象

        //创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        //使用代理工厂对象获取代理对象
        SellTickets proxyObject = factory.getProxyObject();

        proxyObject.sell();

    }
}

运行结果：

说明我们在使用代理工厂获取代理对象然后访问目标对象，其实是调用了invoke()方法

在明白以上所述的基础上，我们再来看invoke()方法

 /\*\*
 \* Object proxy :代理对象,和proxyObject是同一个对象，在invoke中基本不用
 \* Method method : 对接口中的方法 (sell()方法) 进行封装的method对象
 \* Object[] args : 调用方法 (sell()方法) 的实际参数, 本例中sell()方法无参数
 \*
 \*返回值 就是sell()方法的返回值 ,由于sell()方法没有返回值 因此就是返回null
 \*/
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {


                        //代理对象对目标对象进行增强
                        System.out.println("代售点收取服务费....");

                        /\*\*
 \*执行目标对象的方法 method就表示sell()方法
 \* 通过反射调用method对象中的invoke方法
 \* 参数表示 : trainStation要调用的sell方法所属类的实例对象 ,args发放的参数
 \*/
                        Object obj = method.invoke(trainStation, args);
                        return obj;
                    }

代理对象工厂类（完整代码）

/\*\*
 \*
 获取代理对象的工厂类
 代理类也实现了对应的接口
 \*/
public class ProxyFactory {

    //声明目标对象
    private  TrainStation trainStation = new TrainStation();

    public SellTickets getProxyObject(){
    //返回代理对象
        /\*\*
 \* newProxyInstance方法中的三个参数
 \* ClassLoader loader : 类加载器，用于加载代理类，可以通过目标对象获得类加载器
 \* Class<?>[] interfaces : 代理类实现的接口的字节码对象
 \*InvocationHandler h :代理对象的调用处理程序
 \*/
        SellTickets proxyObject = (SellTickets) Proxy.newProxyInstance(trainStation.getClass().getClassLoader(),
                trainStation.getClass().getInterfaces(),
                new InvocationHandler() {
                    /\*\*
 \* Object proxy :代理对象,和proxyObject是同一个对象，在invoke中基本不用
 \* Method method : 对接口中的方法 (sell()方法) 进行封装的method对象
 \* Object[] args : 调用方法 (sell()方法) 的实际参数, 本例中sell()方法无参数
 \*
 \*返回值 就是sell()方法的返回值 ,由于sell()方法没有返回值 因此就是返回null
 \*/
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {


                        //代理对象对目标对象进行增强
                        System.out.println("代售点收取服务费....");

                        /\*\*
 \*执行目标对象的方法 method就表示sell()方法
 \* 通过反射调用method对象中的invoke方法
 \* 参数表示 : trainStation要调用的sell方法所属类的实例对象 ,args发放的参数
 \*/
                        Object obj = method.invoke(trainStation, args);
                        return obj;
                    }
                }
        );

        return  proxyObject;
    }
}

客户端运行结果：

🌰JDK动态代理底层实现

JDK动态代理代理类是在程序运行过程中动态的在内存中生成的类，我们通过阿里巴巴开源的Java诊断工具 （Arthas【阿尔萨斯】） 查看代理类的结构

public class Client {
    public static void main(String[] args) {
        //获取代理对象

        //创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        //使用代理工厂对象获取代理对象
        SellTickets proxyObject = factory.getProxyObject();

        proxyObject.sell();
        
        //获取代理类名称
        System.out.println(proxyObject.getClass());

        //让程序一直执行，在内存中获取动态生成的代理类
        while (true){
            
        }
    }

}

执行结果：

在arthas-boot.jar 包所在目录下启动cmd

使用第二种解决方案，直接复制粘贴执行

jad+类名执行

获取 $Proxy0类

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

    public $Proxy0(InvocationHandler invocationHandler) {
        super(invocationHandler);
    }

    static {
        try {
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.xue.jdk\_proxy.SellTickets").getMethod("sell", new Class[0]);
            return;
        }
        catch (NoSuchMethodException noSuchMethodException) {
            throw new NoSuchMethodError(noSuchMethodException.getMessage());
        }
        catch (ClassNotFoundException classNotFoundException) {
            throw new NoClassDefFoundError(classNotFoundException.getMessage());
        }
    }

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

    public final String toString() {
        try {
            return (String)this.h.invoke(this, m2, null);
        }
        catch (Error | RuntimeException throwable) {
            throw throwable;
        }
        catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final int hashCode() {
        try {
            return (Integer)this.h.invoke(this, m0, null);
        }
        catch (Error | RuntimeException throwable) {
            throw throwable;
        }
        catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final void sell() {
        try {
            this.h.invoke(this, m3, null);
            return;
        }
        catch (Error | RuntimeException throwable) {
            throw throwable;
        }
        catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }
}

代理类（$Proxy0）实现了SellTickets ，说明了真实类和代理类实现同样的接口
代理类（$Proxy0）将我们提供的匿名内部类对象传递给了父类

仅保留关键代码进行分析

public final class $Proxy0 extends Proxy
implements SellTickets {

    private static Method m3;

    public $Proxy0(InvocationHandler invocationHandler) {
        //将invocationHandler 赋值给父类Proxy中的属性 protected InvocationHandler h
        super(invocationHandler);
    }

    static {
             // 通过反射获取接口类中的sell方法，并赋值给 (method) m3
            m3 = Class.forName("com.xue.jdk\_proxy.SellTickets").getMethod("sell", new Class[0]);
           
        }
       
    }
   
    public final void sell() {
     //通过调用父类Proxy中的h 调用我们自己实现的匿名内部类InvocationHandler(子实现类)然后调用子实现类中的invoke()方法
            this.h.invoke(this, m3, null);

    }
}

整个执行流程：

1.在测试类中通过代理对象调用sell（）方法

2.根据多态的特性，执行的是代理类（$Proxy0）中的sell（）方法

3.代理类($Proxy0)中的sell（）方法中又调用了InvocationHandler接口中的子实现对象的invoke（）方法

4.invoke（）方法通过反射执行了真实对象所属类（TrainStation）中的sell（）方法

注意：JDK动态代理要求必须定义接口，对接口进行代理

🍋4.2CGLib动态代理

CGLib是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK动态代理提供了很好的补充

CGLib是第三方提供的包，需要导入jar包

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

🌰CGlib动态代理实现

火车站类

public class TrainStation implements SellTickets {
    //火车站类
    @Override
    public void sell() {
        System.out.println("买票成功.....");
    }
}

代理对象工厂类

public class ProxyFactory implements MethodInterceptor {

    public TrainStation getProxyObject(){
        //创建Enhancer对象,类似与JDK代理中的proxy类
        Enhancer enhancer = new Enhancer();
        //设置父类的字节码对象
        enhancer.setSuperclass(TrainStation.class);
        //设置回调函数 MethodInterceptor子实现类也就是 本类this
        enhancer.setCallback(this);
        //创建代理对象
        TrainStation proxyObject = (TrainStation) enhancer.create();
        return  proxyObject;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("方法执行了...");
        return null;
    }
}

访问类

public class Client {
    public static void main(String[] args) {
        //创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        //获取代理对象
        TrainStation proxyObject = factory.getProxyObject();
        //调用代理对象中的sell方法

       proxyObject.sell();
    }
}

运行结果：

说明代理对象调用了intercept方法

完善代理工厂类

public class ProxyFactory implements MethodInterceptor {

    private TrainStation trainStation = new TrainStation();
    public TrainStation getProxyObject(){
        //创建Enhancer对象,类似与JDK代理中的proxy类
        Enhancer enhancer = new Enhancer();
        //设置父类的字节码对象
        enhancer.setSuperclass(TrainStation.class);
        //设置回调函数 MethodInterceptor子实现类也就是 本类this
        enhancer.setCallback(this);
        //创建代理对象
        TrainStation proxyObject = (TrainStation) enhancer.create();
        return  proxyObject;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("代售点收取服务费...");


        //要调用目标对象的方法
        Object obj = method.invoke(trainStation,objects);

        return null;
    }
}

执行结果：

三种代理的对比

在JDK1.8及之后，JDK代理效率高于CGLib代理。所以如果有接口使用JDK动态代理，如果没有接口使用CGLIE代理。

动态代理和静态代理：

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理(InvocationHandler.invoke)。这样，在接口方法数量比较多的时候，我可以进集中处理，而不需要像静态代理那样每一个方法进行中转。

如果接口增加一个方法，静态代理模式除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。而动态代理不会出现该问题。

🍊5.代理模式的优缺点及使用场景

优点：

代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用
代理对象可以扩展目标对象的功能
代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度

缺点:

增加了系统的复杂度

使用场景：

远程(Remote)代理

本地服务通过网络请求远程服务。为了实现本地到远程的通信，我们需要实现网络通信，处理其中可能的异常。为良好的代码设计和可维护性，我们将网络通信部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问远程服务提供的功能，而不必过多关心通信部分的细节。（RPC思想，例如：dubbo）

防火墙（Firewall)代理

当你将浏览器配置成使用代理功能时，防火墙就将你的浏览器的请求转给互联网;当互联网返回响应时，代理服务器再把它转给你的浏览器。（VPN）

保护(Protect or Access)代理

控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。

最后

分享一套我整理的面试干货，这份文档结合了我多年的面试官经验，站在面试官的角度来告诉你，面试官提的那些问题他最想听到你给他的回答是什么，分享出来帮助那些对前途感到迷茫的朋友。

面试经验技巧篇

经验技巧1 如何巧妙地回答面试官的问题
经验技巧2 如何回答技术性的问题
经验技巧3 如何回答非技术性问题
经验技巧4 如何回答快速估算类问题
经验技巧5 如何回答算法设计问题
经验技巧6 如何回答系统设计题
经验技巧7 如何解决求职中的时间冲突问题
经验技巧8 如果面试问题曾经遇见过，是否要告知面试官
经验技巧9 在被企业拒绝后是否可以再申请
经验技巧10 如何应对自己不会回答的问题
经验技巧11 如何应对面试官的“激将法”语言
经验技巧12 如何处理与面试官持不同观点这个问题
经验技巧13 什么是职场暗语

面试真题篇

真题详解1 某知名互联网下载服务提供商软件工程师笔试题
真题详解2 某知名社交平台软件工程师笔试题
真题详解3 某知名安全软件服务提供商软件工程师笔试题
真题详解4 某知名互联网金融企业软件工程师笔试题
真题详解5 某知名搜索引擎提供商软件工程师笔试题
真题详解6 某初创公司软件工程师笔试题
真题详解7 某知名游戏软件开发公司软件工程师笔试题
真题详解8 某知名电子商务公司软件工程师笔试题
真题详解9 某顶级生活消费类网站软件工程师笔试题
真题详解10 某知名门户网站软件工程师笔试题
真题详解11 某知名互联网金融企业软件工程师笔试题
真题详解12 国内某知名网络设备提供商软件工程师笔试题
真题详解13 国内某顶级手机制造商软件工程师笔试题
真题详解14 某顶级大数据综合服务提供商软件工程师笔试题
真题详解15 某著名社交类上市公司软件工程师笔试题
真题详解16 某知名互联网公司软件工程师笔试题
真题详解17 某知名网络安全公司校园招聘技术类笔试题
真题详解18 某知名互联网游戏公司校园招聘运维开发岗笔试题

资料整理不易，点个关注再走吧

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：xhs1999xhs （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

真题详解2 某知名社交平台软件工程师笔试题
真题详解3 某知名安全软件服务提供商软件工程师笔试题
真题详解4 某知名互联网金融企业软件工程师笔试题
真题详解5 某知名搜索引擎提供商软件工程师笔试题
真题详解6 某初创公司软件工程师笔试题
真题详解7 某知名游戏软件开发公司软件工程师笔试题
真题详解8 某知名电子商务公司软件工程师笔试题
真题详解9 某顶级生活消费类网站软件工程师笔试题
真题详解10 某知名门户网站软件工程师笔试题
真题详解11 某知名互联网金融企业软件工程师笔试题
真题详解12 国内某知名网络设备提供商软件工程师笔试题
真题详解13 国内某顶级手机制造商软件工程师笔试题
真题详解14 某顶级大数据综合服务提供商软件工程师笔试题
真题详解15 某著名社交类上市公司软件工程师笔试题
真题详解16 某知名互联网公司软件工程师笔试题
真题详解17 某知名网络安全公司校园招聘技术类笔试题
真题详解18 某知名互联网游戏公司校园招聘运维开发岗笔试题

[外链图片转存中…(img-d30HwCVA-1713615795863)]

资料整理不易，点个关注再走吧

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：xhs1999xhs （备注Java）
[外链图片转存中…(img-6c0Xxrp4-1713615795863)]

2401_84519663

关注

29
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
【Java设计模式】——代理模式_接口增加方法的实现不修改其他实现类

由于某些原因需要给一些对象提供一个代理来控制对该对象的访问。此时，访问对象不是直接访问目标对象而是通过代理对象作为中介进行访问。类似于租房找中介，中介就相当于代理对象Java中的代理按照代理类生成时机不同又分为静态代理和动态代理。静态代理代理类在编译期生成，而动态代理代理类在Java运行时动态生成。动态代理又有JDK代理和CGLib代理两种。
复制链接

扫一扫