【再探】设计模式—职责链模式、命令模式及迭代器模式

 行为型设计模式研究系统在运行时对象之间的交互，进一步明确对象的职责。有职责链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式及访问模式共11种。

1 职责链模式

需求：1) 请求能被多个处理器处理，对处理顺序有要求。2) 请求与处理器解耦，具体被哪个处理器处理未知，可动态决定其处理器。

1.1 职责链模式介绍

通过建立一条链来组织请求的处理者。请求将沿着链进行传递，请求发送者无需知道请求在何时、何处及如何被处理，实现了请求发送者与处理者的解耦。

图 职责链模式UML

public class ChainOfResponsibility {

    public static void main(String[] args) {
        RequestHandler requestHandler = generateChain();
        List<CustomRequest> requestList = generateRequest();
        for (CustomRequest request : requestList) {
            try {
                requestHandler.handle(request);
            } catch (Exception e) {
                System.err.println(e.getMessage());
            }
        }
    }

    private static RequestHandler generateChain() {
        RequestHandler handler = new SubjectHandler();
        RequestHandler usernameHandler = new UserNameHandler(handler);
        return new IpRequestHandler(usernameHandler);
    }

    private static List<CustomRequest> generateRequest() {
        List<CustomRequest> list = new ArrayList<>();
        list.add(new CustomRequest("localhost", "user"));
        list.add(new CustomRequest("172.34.43.32", "admin"));
        list.add(new CustomRequest("172.34.24.24", "user"));
        return list;
    }

    private static class CustomRequest {
        String ip;
        String username;

        public CustomRequest(String ip, String username) {
            this.ip = ip;
            this.username = username;
        }

        @Override
        public String toString() {
            return "CustomRequest{" +
                    "ip='" + ip + '\'' +
                    ", username='" + username + '\'' +
                    '}';
        }
    }

    private static abstract class RequestHandler {

        protected final RequestHandler handler;

        public RequestHandler(RequestHandler handler) {
            this.handler = handler;
        }

        abstract void handle(CustomRequest request);
    }

    private static class IpRequestHandler extends RequestHandler{

        private static final String[] BLACK_IPS = {"localhost","127.0.0.1"};

        public IpRequestHandler(RequestHandler handler) {
            super(handler);
        }

        @Override
        void handle(CustomRequest request) {
            if (request.ip == null) {
                throw new RuntimeException("请求IP 不合法");
            } else {
                for (String str : BLACK_IPS) {
                    if (request.ip.contains(str)) throw new RuntimeException("请求IP 不合法");
                }
            }
            handler.handle(request);
        }
    }

    private static class UserNameHandler extends RequestHandler {

        public UserNameHandler(RequestHandler handler) {
            super(handler);
        }

        @Override
        void handle(CustomRequest request) {
            if (request.username == null) {
                throw new RuntimeException("用户名不能为空");
            } else {
                if (request.username.contains("admin")) throw new RuntimeException("用户名不合法");
            }
            handler.handle(request);
        }
    }

    private static class SubjectHandler extends RequestHandler {

        public SubjectHandler() {
            super(null);
        }

        @Override
        void handle(CustomRequest request) {
            System.out.println("请求到达目标处理器：" + request);
        }
    }

}

纯职责链模式

要求一个具体处理者对象只能在两个行为中选择一个：要么承担全部责任，要么将责任推给下家，而且一个请求必须被某一个处理者对象所处理。

不纯职责链模式

允许一个具体处理者部分被处理好再向下传递，或者一个具体处理者处理完某请求后，后继处理者可以继续处理改请求。一个请求最终可以不被处理。

图 职责链模式的两种类型

1.2 优缺点

优点：

  1. 将请求发送者与接收者解耦，请求发送者无需知道请求会被哪个处理器处理。
  2. 当系统需要增加一个新的处理者时，无需修改原有系统代码，符合开闭原则。

缺点：

  1. 不能保证请求一定会被处理。如果职责链没有被正确配置，则请求可能得不到处理。
  2. 如果建链不当，则可能会造成循环调用。
  3. 如果职责链较长，系统性能将受到一定影响，代码调试也不方便。

2 命令模式

需求：1）将命令发送者与命令接收者解耦，命令发送者不必关系接收者的接口、命令何时被处理等。2）能对命令发送者发出的命令进行记录、撤销等。3）发送者能发出一系列命令，这些命令能按某种顺序被处理。

2.1 命令模式介绍

引入一个命令类，来降低发送者与接收者的耦合度。将一个命令封装成一个命令对象，发送者只需指定一个命令对象，再通过命令对象来调用接收者的处理方法。

图 命令模式UML

public class CommandPattern {

    public static void main(String[] args) { // 进入餐馆
        String[] food_menu = {"麻婆豆腐","红烧茄子","莴笋炒肉","辣子鸡丁","香干炒肉","黄焖鸡"};
        Cook[] cooks = new Cook[4];
        for (int i = 0; i < cooks.length; i++) { // 招募厨子
            cooks[i] = new Cook();
        }
        for (int i = 0; i < 10; i++) { // 来了客户点单
            Customer order = new Customer(i);
            CookingCommand command = new CookingCommand(cooks);
            order.placeOrder(command,food_menu);
        }
    }


    private static class Customer {

        private final int id;

        public Customer(int id) {
            this.id = id;
        }

        void placeOrder(Command command, String[] foodNames) {
            Random random = new Random();
            int num = random.nextInt(foodNames.length) + 1;
            Set<String> foods = new HashSet<>();
            while (num > 0) {
                String foodName = foodNames[random.nextInt(foodNames.length)];
                if (foods.add(foodName)) num--;
            }
            command.makeOrder(foods,id);
        }
    }

    private interface Command {
        void makeOrder(Collection<String> foodList,int id);
    }

    private static class CookingCommand implements Command {

        private final Cook[] cookList;

        public CookingCommand(Cook[] cookList) {
            this.cookList = cookList;
        }

        @Override
        public void makeOrder(Collection<String> foodList,int id) {
            System.out.println("客户:" + id + ",下单：" + foodList);
            new Thread(() -> {
                Date date = new Date();
                List<String> finished = new ArrayList<>();
                for (String food : foodList) {
                    boolean cooking = true;
                    int pos = 0;
                    while (cooking) {
                        Cook cook = cookList[pos];
                        try {
                            String finishedFood = cook.cooking(food);
                            finished.add(finishedFood);
                            cooking = false;
                        } catch (Exception e) {
                            pos = (pos + 1) % cookList.length;
                        }
                    }
                }
                Date finishedDate = new Date();
                long distance = (finishedDate.getTime() - date.getTime()) / 1000 ;
                System.out.println("订单：" + id + "完成，耗时：" + distance + "秒," + finished);
            }).start();
        }
    }

    private static class Cook {

        private Boolean isBusy = false;

        private String cooking(String foodName) throws Exception {
            if (isBusy) {
                throw new Exception("没空！");
            }
            isBusy = true;
            System.out.println(foodName + "制作中...");
            synchronized (this) {
                Thread.sleep(2000);
            }
            isBusy = false;
            return "f-" + foodName;
        }
    }

}

2.1.1 命令队列模式

当一个请求发送者发送一个请求时，不止一个请求接收者产生响应，这些请求接收者将逐个执行业务方法，完成对请求的处理。

图 命令队列模式 UML

public class CommandQueuePattern {

    public static void main(String[] args) {
        Student student = new Student();
        Teacher teacher = new Teacher();
        Command teacherCommand = new TeacherCommand(teacher);
        Command studentCommand = new StudentCommand(student);

        CommandQueue commandQueue = new CommandQueue();
        commandQueue.addCommand(teacherCommand);
        commandQueue.addCommand(studentCommand);

        School school = new School();
        school.setCommandQueue(commandQueue);
        school.releaseTestNote("3周以后进行考试");
    }

    private static class School {
        private CommandQueue commandQueue;

        public void setCommandQueue(CommandQueue commandQueue) {
            this.commandQueue = commandQueue;
        }

        public void releaseTestNote(String content) {
            if (commandQueue != null) commandQueue.execute(content);
        }
    }

    private static class CommandQueue{
        private final List<Command> commandList = new ArrayList<>();

        public void addCommand(Command command) {
            commandList.add(command);
        }

        public void clearCommand() {
            commandList.clear();
        }

        public void execute(String content) {
            for (Command command : commandList) command.execute(content);
        }
    }

    private static abstract class Command {
        void execute(String content) {
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:sss");
            System.out.println("收到通知:" + content + "," + dateFormat.format(new Date()));
            invoke(content);
        }

        abstract void invoke(String content);
    }

    private static class TeacherCommand extends Command {

        private final Teacher teacher;

        public TeacherCommand(Teacher teacher) {
            this.teacher = teacher;
        }

        @Override
        void invoke(String content) {
            if (teacher != null) teacher.developPlan();
        }
    }

    private static class StudentCommand extends Command {

        private final Student student;

        public StudentCommand(Student student) {
            this.student = student;
        }

        @Override
        void invoke(String content) {
            if (student != null) student.review();
        }
    }

    private static class Teacher {
        public void developPlan() {
            System.out.println("老师开始制定复习计划");
        }
    }

    private static class Student {
        public void review() {
            System.out.println("学生开始复习");
        }
    }

}

2.2 优缺点

优点：

  1. 将请求调用者与请求接收者解耦，使得调用者不必关心接收者的接口、请求何时被处理等。
  2. 将请求封装成一个对象，可以对这请求进行处理。例如记录日志。
  3. 增加新的命令很容易，无须修改原有系统代码结构，甚至客户端代码，符合开闭原则。
  4. 可以比较容易设计成一个命令队列。

缺点：

  1. 会导致系统有过多的具体命令类，同时可能会降低系统性能。

3 迭代器模式

需求：1）将聚合对象存储职责与遍历职责分离开。2）为一个聚合对象提供多种遍历方式。

3.1 迭代器模式介绍

提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示。

图 迭代器模式 UML

public class CustomList<T> {

    public static void main(String[] args) {
        CustomList<Integer> list = new CustomList<>();
        for (int i = 0; i < 21; i++) list.addItem(i);
        Iterator<?> iterate = list.createIterate();
        while (iterate.hasNext()) System.out.println(iterate.next());
    }

    public Iterator<T> createIterate() {
        return new CustomIterator();
    }

    public interface Iterator<E> {
        E first();

        E next();

        boolean hasNext();

        E currentItem();
    }

    private class CustomIterator implements Iterator<T> {

        private int pos = 0;

        @SuppressWarnings("unchecked")
        @Override
        public T first() {
            if (currentPos <= 0) {
                throw new RuntimeException("访问超出界限");
            }
            return (T)items[0];
        }

        @SuppressWarnings("unchecked")
        @Override
        public T next() {
            if (hasNext()) {
                return (T)items[pos++];
            }
            return null;
        }

        @Override
        public boolean hasNext() {
            return pos < currentPos;
        }

        @SuppressWarnings("unchecked")
        @Override
        public T currentItem() {
            if (pos == 0) return first();
            return (T)items[pos-1];
        }
    }

    private static final int INIT_LENGTH = 20;

    Object[] items;

    private int currentPos = 0;

    public CustomList() {
        this.items = new Object[INIT_LENGTH];
    }

    public void addItem(T item) {
        checkArrayLength();
        items[currentPos++] = item;
    }

    @SuppressWarnings("unchecked")
    public T getItem(int pos) {
        if (pos >= currentPos) {
            throw new RuntimeException("访问超出界限");
        }
        return (T)items[pos];
    }

    private void checkArrayLength() {
        if (currentPos == items.length) {
            items = Arrays.copyOf(items,items.length * 2);
        }
    }

}

3.2 优缺点

优点：

  1. 支持以不同方式遍历一个聚合对象。
  2. 简化聚合类的职责，将聚合对象的访问和数据的存储分离，使得访问聚合对象无须了解其内部实现细节。

缺点：

  1. 增加了类的个数，设计难度较大。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/648991.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

2024可信赖的企业级生成式 AI 白皮书

2024可信赖的企业级生成式 AI 白皮书

来源&#xff1a;COPU&IBM&#xff1a; 近期历史回顾&#xff1a;
阅读更多...
[随笔] 在CSDN的6周年纪念日随笔

[随笔] 在CSDN的6周年纪念日随笔

纪念 转眼已过6年&#xff0c;大一的时候学习编程&#xff0c;潜水 CSDN 学习各类博文&#xff0c;才学浅薄就没有主动写博文记录自己的学习历程。 过了段时间刚刚到了大二&#xff0c;很喜欢 Todolist&#xff0c;意气风发的写下《一份清爽的编程计划》&#xff0c;哈哈。 …
阅读更多...
新浪测试社招要个25K，第一次面大厂挂了

新浪测试社招要个25K，第一次面大厂挂了

一面 1、讲下被测系统和你负责测试的模块功能&#xff1f; 2、为什么选择这个测试框架&#xff0c;这个测试框架有什么优缺点&#xff1f; 3、测试文件的目录&#xff0c;包含哪些包&#xff0c;这些之间是怎么调用的&#xff1f; 4、UI自动化和接口自动化都是怎么做的&…
阅读更多...
FFmpeg之转码

FFmpeg之转码

文章目录 概述transcode小结 概述 上一篇说了主要的流程&#xff0c;也就是ffmpeg_parse_options的流程&#xff0c;如下图&#xff1a; 红色箭头的流程说的差不多了&#xff0c;接下来看看绿色框框&#xff0c;也就是transcode的流程。 transcode 还是先给出我画的流程图&…
阅读更多...
SPSS之因子分析

SPSS之因子分析

SPSS中因子分析功能在【分析】--【降维】--【因子分析】中完成&#xff08;在SPSS软件中&#xff0c;主成分分析与因子分析均在【因子分析】模块中完成&#xff09;。 因子分析的求解通常从分析原始变量的协方差矩阵或相关矩阵着手。 &#xff08;1&#xff09;当变量取值的度…
阅读更多...
纯CSS丝滑边框线条动画

纯CSS丝滑边框线条动画

在这个网站&#xff08;minimal-portfolio-swart.vercel.app&#xff09;发现一个不错的交互效果&#xff0c;用户体验效果很不错。如封面图所示&#xff0c;这个卡片上有一根白色的线条围绕着卡片移动&#xff0c;且在线条的卡片内部跟随这一块模糊阴影&#xff0c;特别是在线…
阅读更多...
无线麦克风哪个品牌音质最好，揭示麦克风什么牌子的音质效果好！

无线麦克风哪个品牌音质最好，揭示麦克风什么牌子的音质效果好！

​随着科技的不断发展&#xff0c;无线领夹麦克风已经成为现代演讲、演出和采访中不可或缺的工具。这种小巧便携的设备&#xff0c;能够让我们摆脱线缆的束缚&#xff0c;自由地在舞台上或讲台上移动&#xff0c;同时保持声音的清晰和稳定。在这篇文章中&#xff0c;我们将介绍…
阅读更多...
国产操作系统上telnet命令详解 _ 统信 _ 麒麟 _ 中科方德

国产操作系统上telnet命令详解 _ 统信 _ 麒麟 _ 中科方德

原文链接&#xff1a;国产操作系统上telnet命令详解 | 统信 | 麒麟 | 中科方德 Hello&#xff0c;大家好啊&#xff01;今天给大家带来一篇在国产操作系统上使用telnet命令的详细介绍文章。telnet是一个经典的网络协议和工具&#xff0c;广泛用于测试和管理远程服务器。本文将详…
阅读更多...
低代码与人工智能：改变软件开发的未来

低代码与人工智能：改变软件开发的未来

引言 在当今快速发展的科技时代&#xff0c;软件开发行业也在不断地创新和演进。其中&#xff0c;低代码开发和人工智能技术是两个备受关注的领域&#xff0c;低代码开发通过简化开发流程和降低编码难度&#xff0c;使得软件开发变得更加高效和便捷&#xff0c;而人工智能技术…
阅读更多...
收放卷主从轴速度随动增益计算(CODESYS ST代码)

收放卷主从轴速度随动增益计算(CODESYS ST代码)

收放卷主从轴速度随动控制，我们需要知道随动增益，如果是利用电子齿轮实现速度随动，我们需要通过增益计算电子齿轮比的分子和分母，具体源代码大家可以参考下面文章链接： 收放卷伺服控制系统详细算法介绍(电子齿轮+张力PID卷绕轴控制功能块)_收放卷伺服控制属于-CSDN博客文…
阅读更多...
一文教你如何调用Ascend C算子

一文教你如何调用Ascend C算子

Ascend C是CANN针对算子开发场景推出的编程语言&#xff0c;原生支持C和C标准规范&#xff0c;兼具开发效率和运行性能。基于Ascend C编写的算子程序&#xff0c;通过编译器编译和运行时调度&#xff0c;运行在昇腾AI处理器上。使用Ascend C&#xff0c;开发者可以基于昇腾AI硬…
阅读更多...
Postman快捷功能-快速填写请求头

Postman快捷功能-快速填写请求头

大家好&#xff0c;之前给大家分享关于 Postman 工具的基础使用&#xff0c;今天给大家介绍一个快捷功能&#xff0c;可以一定程度提高我们使用 Postman 工具的效率&#xff0c;在我们进行接口测试时&#xff0c;几乎每个接口都需要填写 Headers&#xff0c;且 Headers 中的参数…
阅读更多...
MySQL--联合索引应用细节应用规范

MySQL--联合索引应用细节应用规范

目录 一、索引覆盖 1.完全覆盖 2.部分覆盖 3.不覆盖索引-where条件不包含联合索引的最左则不覆盖 二、MySQL8.0在索引中的新特性 1.不可见索引 2.倒序索引 三、索引自优化--索引的索引 四、Change Buffer 五、优化器算法 1.查询优化器算法 2.设置算法 3.索引下推 …
阅读更多...
如何使用OutputStream类实现文件的读写操作？

如何使用OutputStream类实现文件的读写操作？

哈喽&#xff0c;各位小伙伴们&#xff0c;你们好呀&#xff0c;我是喵手。运营社区&#xff1a;C站/掘金/腾讯云&#xff1b;欢迎大家常来逛逛 今天我要给大家分享一些自己日常学习到的一些知识点&#xff0c;并以文字的形式跟大家一起交流&#xff0c;互相学习&#xff0c;一…
阅读更多...
如何提升项目经理的汇报能力？从这四点做起

如何提升项目经理的汇报能力？从这四点做起

项目经理不仅需要管理项目进度、预算和资源&#xff0c;更需要与各方进行有效的沟通&#xff0c;确保项目的顺利进行。而在所有沟通形式中&#xff0c;当众演讲无疑是难度最大的一种。 他们需要向团队成员传达项目的最新进展和要求&#xff0c;向领导和客户汇报工作成果&…
阅读更多...
Java 定义类型处理MySQL point类型数据

Java 定义类型处理MySQL point类型数据

1.三个类来处理 引入maven依赖 <!-- 引入 jts 库解析 POINT --><dependency><groupId>com.vividsolutions</groupId><artifactId>jts</artifactId><version>1.13</version></dependency>import javax.validation.constr…
阅读更多...
推送邮件接口设置的方法？邮件接口的作用？

推送邮件接口设置的方法？邮件接口的作用？

推送邮件接口如何与现有系统集成&#xff1f;怎么调试邮件接口&#xff1f; 通过推送邮件接口&#xff0c;应用程序可以自动向用户发送邮件通知&#xff0c;提醒他们重要事件或更新。AokSend将介绍如何设置推送邮件接口&#xff0c;以便您的应用程序能够充分利用这一功能。 推…
阅读更多...
和为k的子数组 ---- 前缀和

和为k的子数组 ---- 前缀和

题目链接 题目: 分析: 思考: 此题能否用滑动窗口来解决? 滑动窗口的适用前提是具有单调性, left和right指针是不回退的, 此题中数组有负数和零, 很难保证指针不回退, 所以不能用滑动窗口利用前缀和的思想, 计算以i结尾的所有子数组, 前缀和为sum[i] 想要找到和为k的数组, 我…
阅读更多...
基于图鸟UI的圈子商圈：一个全栈前端模板的探索与应用

基于图鸟UI的圈子商圈：一个全栈前端模板的探索与应用

摘要&#xff1a; 本文介绍了一个基于图鸟UI的纯前端模板——圈子商圈&#xff0c;它支持微信小程序、APP和H5等多平台开发。该模板不仅包含丰富的UI组件和页面模板&#xff0c;还提供了详尽的使用文档&#xff0c;旨在帮助开发者快速构建出酷炫且功能齐全的前端应用。本文将从…
阅读更多...
让WSL内核使用BBR拥塞控制算法

让WSL内核使用BBR拥塞控制算法

使用git命令从Linux内核的Git仓库中获取源代码，$ git clone https://github.com/microsoft/WSL2-Linux-Kernel.git，找到对应的内核版本$ git log --grep="5.15.146.1-microsoft-standard-WSL2"，回退到本机安装的内核版本$ git checkout <commit-id> ee5b8e3…
阅读更多...
最新文章

Copyright @ 2022~2023