【再探】设计模式—代理模式

🕗 发布于 2024-05-25 11:53 代理模式装饰器模式 java

代理是指授权代理人在一定范围内代表其向第三方进行处理有关事务。

1 代理模式

需求：1）将业务代码与非业务代码分离，在不改变代码结构的基础上，为其添加新的功能。2）为系统中的某些操作做同一处理，例如进行鉴权、监控、日志、统计等。

1.1 代理模式介绍

增加一个代理对象，在客户端和目标对象之间起到中介作用，去掉客户不能看到的内容和服务，或者添加客户想要的额外服务。

图代理模式UML

public class StaticProxy {

    public static void main(String[] args) {
        Subject request = new SimpleRequest();
        Subject proxy = new LogProxy(request);
        proxy.request("applet","123456");
    }

    private interface Subject {
        void request(String source,String token);
    }

    private static class LogProxy implements Subject {

        private final Subject subject;

        private LogProxy(Subject subject) {
            this.subject = subject;
        }

        @Override
        public void request(String source, String token) {
            System.out.println("记录访问日志,source=" + source + ",token=" + token);
            subject.request(source,token);
        }
    }

    private static class SimpleRequest implements Subject {
        @Override
        public void request(String source, String token) {
            System.out.println("接收请求:" + source + "," + token);
        }
    }

}

代理模式	侧重控制对目标对象的访问，及扩展不同于目标对象纬度的功能。
装饰模式	侧重于增强目标对象本身的功能，是继承方案的一个代替。

表代理模式与装饰模式对比

1.1.1 动态代理

静态代理模式，需要为每个目标对象创建一个代理类，会造成系统中类的数量增多，而且当这些代理类提供的功能相同时，将会造成代码的冗余。动态代理是指在运行时动态创建代理对象。

JDK

JDK自带的一种动态代理方法，要求被代理类必须要实现接口。

原理：动态生成实现目标接口的代理类，调用代理方法时，通过反射的形式来调用目标对象方法。

CGLIB

是CGLIB提供的一种动态代理方法。被代理类可为普通类及接口。

原理：动态生成继承目标类的代理类，通过fastclass 的策略来找到目标方法。

与JDK方式对比，其动态生成的类会比较多，但执行效率会比反射更快。

表 Java中两种动态代理

JDK 方式：

public class JdkDynamicProxy {

    private interface Subject {
        void request(String source,String token);
    }

    private static class RealRequest implements Subject{

        @Override
        public void request(String source, String token) {
            System.out.println("请求网络");
        }
    }

    private static class RequestIntercept implements InvocationHandler {

        private final Subject subject;

        private RequestIntercept(Subject subject) {
            this.subject = subject;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("请求参数:" + Arrays.asList(args));
            Object result = method.invoke(subject, args);
            System.out.println("记录访问日志");
            return result;
        }
    }

    public static void main(String[] args) {
        Subject realSubject = new RealRequest();
        Subject subject = (Subject) Proxy.newProxyInstance(JdkDynamicProxy.class.getClassLoader(), new Class[]{Subject.class}, new RequestIntercept(realSubject));
        subject.request("小程序","1344");
    }

}

CGLIB方式

public class CglibDynamicProxy {

    private static class RealRequest {

        public RealRequest() {
        }

        public void request(String source, String token) {
            System.out.println("请求成功，source=" + source + ",token=" + token);
        }
    }

    private static class RequestIntercept implements MethodInterceptor {
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("拦截请求：" + Arrays.asList(objects));
            Object result = methodProxy.invokeSuper(o, objects);
            System.out.println("记录请求日志");
            return result;
        }
    }


    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(RealRequest.class);
        enhancer.setCallback(new RequestIntercept());
        RealRequest realRequest = (RealRequest) enhancer.create();
        realRequest.request("小程序","1344");
    }
}

1.1.2 远程代理

使得客户端可以访问远程机，将网络细节隐藏起来，客户端可完全认为被代理的远程对象是局域的而非远程的。

远程代理对象承担了大部份网络通信工作，并负责对远程业务方法的调用。

RMI，Remote Method Invocation,远程方法调用，是JDK 实现的一种远程代理。

表 RMI 内部实现步骤

客户端通过一个桩（Stub）,相当于代理类对象，与远程主机上的业务对象进行通信。而远程主机端有个Skeleton(骨架)对象来负责与Stub对象通信。

远程机部署代码：

public interface RemoteService extends Remote {

    String service(String requestInfo) throws RemoteException;

}

public class RemoteServiceImpl extends UnicastRemoteObject implements RemoteService{

    public RemoteServiceImpl() throws RemoteException{
    }

    @Override
    public String service(String requestInfo) throws RemoteException {
        System.out.println("请求：" + requestInfo);
        return "RemoteService提供远程服务：" + requestInfo;
    }
}

public class JNDIPublisher {

    public static void main(String[] args) throws RemoteException, MalformedURLException {
        RemoteService remoteService = new RemoteServiceImpl();
        int port = 8080;
        String serviceName = "rmi://localhost:" + port + "/remoteService";
        LocateRegistry.createRegistry(port);
        Naming.rebind(serviceName,remoteService);
    }

}

客户端代码：

public class RmiLocal {

    public static void main(String[] args) throws MalformedURLException, NotBoundException, RemoteException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        String serviceName = "rmi://localhost:" + 8080 + "/remoteService";
        reflectRemote(serviceName);
        interfaceRemote(serviceName);
    }

    // 这种方式仍然需要导入远程服务提供的接口，RemoteService
    private static void reflectRemote(String serviceName) throws MalformedURLException, NotBoundException, RemoteException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Remote lookup = Naming.lookup(serviceName);
        Method method = lookup.getClass().getMethod("service", String.class);
        Object result = method.invoke(lookup, "反射方式");
        System.out.println("反射方式，远程调用结果：" + result);
    }

    private static void interfaceRemote(String serviceName) throws MalformedURLException, NotBoundException, RemoteException{
        RemoteService remoteService = (RemoteService)Naming.lookup(serviceName);
        String result = remoteService.service("接口方式");
        System.out.println("接口方式，远程调用结果：" + result);
    }

}

1.1.3 虚拟代理

主要目标是延迟对象的创建或者复杂计算，直到它们实际需要被创建或计算。这可以提高性能，降低资源消耗。

public class VirtualAgent {

    private interface Image {
        void display();
    }

    private static class RealImage implements Image {

        private String path;

        public RealImage(String path) {
            System.out.println("创建一个图片需要许多资源，耗费时间较长");
            this.path = path;
        }

        @Override
        public void display() {
            System.out.println("展示图片:" + path);
        }
    }

    private static class ProxyImage implements Image {

        private volatile Image image;
        private String path;

        public ProxyImage(String path) {
            System.out.println("虚拟对象，需要资源及时间都很少，用于延迟真实对象的创建与访问");
            this.path = path;
        }

        @Override
        public void display() {
            if (image == null) {
                synchronized (ProxyImage.class) {
                    if (image == null) image = new RealImage(path);
                }
            }
            image.display();
        }
    }

    public static void main(String[] args) {
        Image[] images = new Image[10];
        // 在网页加载过程，先加载这些图片，为了防止陷入卡顿，不直接创建图片，而是先创建虚拟对象
        System.out.println("网页加载中...");
        for (int i = 0; i < images.length; i++) {
            images[i] = new ProxyImage(i + ".png");
        }
        System.out.println("网页加载完成--------");
        // 当网页加载完成后，可以依次加载真实图片了
        for (Image image : images) {
            image.display();
        }
    }

}

1.1.4 缓存代理

为某些目标操作的结果提供临时的存储空间，让后续相同的操作及相同的参数可以直接共享这些结果，而不必再执行计算，以此来提高系统性能。

public class CacheProxy {

    private static class CacheMethodInterceptor implements MethodInterceptor {

        private final static Map<MethodKey,Object> resultMap = new HashMap<>();

        @Override
        public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            MethodKey methodKey = MethodKey.getKey(method, args);
            Object result = resultMap.get(methodKey);
            if (result != null) {
                return result;
            } else {
                Object result2 = methodProxy.invokeSuper(o, args);
                resultMap.put(methodKey,result2);
                return result2;
            }
        }
    }

    // 根据method 及 参数来生成key
    private static class MethodKey {

        private static final Map<String,MethodKey> methodKeyMap = new HashMap<>();

        private String code;

        private MethodKey(String code) { this.code = code;}

        public static MethodKey getKey(Method method, Object[] objects) {
            String hasCode = "method:" + method.hashCode();
            if (objects != null) hasCode += "args:" + Arrays.hashCode(objects);
            MethodKey methodKey = methodKeyMap.get(hasCode);
            if (methodKey == null) {
                synchronized (MethodKey.class) {
                    methodKey = new MethodKey(hasCode);
                    methodKeyMap.put(hasCode,methodKey);
                }
            }
            return methodKey;
        }

        @Override
        public String toString() {
            return code;
        }
    }

    private static class ComplexCompute {

        public ComplexCompute() {
        }

        long compute(long num) {
            System.out.println("执行复杂计算，参数" + num);
            return num * 2345;
        }
    }

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ComplexCompute.class);
        enhancer.setCallback(new CacheMethodInterceptor());
        ComplexCompute compute = (ComplexCompute) enhancer.create();
        System.out.println(compute.compute(23));
        System.out.println("----------");
        System.out.println(compute.compute(123));
        System.out.println("----------");
        System.out.println(compute.compute(23));
    }

}

1.2 优缺点

优点：

能动态扩展对象的功能，而不需要修改原有代码，符合开闭原则。
能对目标对象的方法访问进行控制与保护。
将耗费系统资源及时间较多的对象延迟到真正需要使用时再创建，能提高系统性能及系统对客户的友好度。
能调用远程对象方法，而不需要考虑复杂的实现细节。
能对运行结果进行缓存，提高系统运行效率。

缺点：

增加了代理对象，可能会造成请求的处理速度变慢。
增加了类的数量，让系统变得更复杂。

原文地址：https://blog.csdn.net/qq_25308331/article/details/139105093

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：STM32硬件接口I2C应用（基于BH1750）
下一篇：文心智能体【焦虑粉碎机】——帮你赶走“坏”情绪

HTML开发小技巧：根据用户浏览器的分辨率调整控件的大小
在Html页面开发中，我们通常会用Style进行控件的宽度高度进行控件的格式设置，如果直接设置像素的话，无法根据用户的浏览器进行宽高的适配，所以我们要做到根据实际使用的浏览器进行控件大小的自动调整，以
阅读更多2024-07-27
如何在Html界面内实现类似ChatGpt的打字效果
在你的代码中添加打字机效果，你可以创建一个函数来逐字展示内容。这个函数会将内容分解成单个字符，然后逐渐显示在页面上。
阅读更多2024-07-27
短剧新纪元：从微电影到小程序的文化飞跃
同时，小程序还融入了社交元素，让观众能够关注自己喜爱的创作者或其他用户，构建起属于自己的社交圈层，进一步推动了短剧的传播与影响。昔日，微电影凭借精炼的叙事与精良的制作，在互联网的浪潮中崭露头角，赢得了
阅读更多2024-07-27
大数据｜使用Apache Spark 删除指定表中的指定分区数据
Apache Spark 是一个强大的分布式数据处理引擎，支持多种数据处理模式。在处理大型数据集时，经常需要对数据进行分区，以提高处理效率。有时，为了维护数据或优化查询性能，需要删除指定表中的指定分区
阅读更多2024-07-27
transformers进行学习率调整lr_scheduler（warmup）
【代码】transformers进行学习率调整lr_scheduler（warmup）
阅读更多2024-07-27
【SpringBoot】5 Swagger
Swagger，统一返回结果，Thymeleaf
阅读更多2024-07-27
【头歌】Spark任务提交答案
Spark任务提交答案第1关：spark-submit提交
阅读更多2024-07-27
rust日常提问
Rust 中的结构体可以拥有关联函数（associated functions），这些函数定义在结构体外部，但与结构体相关联。此外，结构体还可以实现方法（methods），这些方法是定义在结构体上的函
阅读更多2024-07-27
【Rust光年纪】选择适合你的项目：Rust语言云平台SDK大比拼
本文将重点介绍六种用于Rust语言的云平台SDK，分别是aws-sdk-rust、azure-sdk-for-rust、Google Cloud SDK for Rust、DigitalOcean R
阅读更多2024-07-27
Rust 1.80.0发布
为此，我们增强了穷尽性检查功能，以更好地检测模式匹配中的间隙，而新的非连续范围端点（non_contiguous_range_endpoints）和重叠范围端点（overlapping_range_e
阅读更多2024-07-27