设计模式之禅之混编【命令模式+责任链模式】

最新推荐文章于 2021-10-26 12:24:35 发布
最新推荐文章于 2021-10-26 12:24:35 发布
阅读量1.8k 收藏 2
点赞数
分类专栏： 设计模式专栏 设计模式之禅
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eieiei438/article/details/79050637
版权

设计模式之禅之混编

命令模式+责任链模式

  • 搬移UNIX命令
    • 在Windows系统上使用UNIX命令
    • UNIX命令
      1. 命令名
      2. 选项
      3. 操作数
    • UNIX规定
      1. 命令名为小写字母
      2. 命令名、选项、操作树之间以空格分隔，空格数量不受限制
      3. 选项之间看可以组合使用，也可以单独拆分使用
      4. 选项以“-”开头
    • 例
      • ls简单列出一个目录下的文件
      • ls-l详细列出目录下的文件
      • ls-a列出目录下包含的隐藏文件，主要是点号（.）开头的文件
      • ls-s列出文件的大小
  • 针对ls命令族，要求如下：
    1. 每一个ls命令都有操作数，默认操作数为当前目录
    2. 选项不可重复
    3. 每个选项返回不同的结果，也就是说每个选项应该由不同的业务逻辑来处理
    4. 为提高扩展性，ls应该对外封闭，减少外界访问ls命令族内部细节的可能性

命令选模式

  • 责任链模式
    • 只需一个参数传递到链首，就可以获得有个结果，中间是如何传递的以及由哪个逻辑解析都不需要外界模块关系
    • 命令族解析类图
    • 类图解释
      1. ComandName抽象类，所有的地命令都继承该类，它就是责任链中的handle类，负责链表的控制
      2. 每个命令族都有一个独立的抽象类，因为每个命令族都有其独特的个性
      3. Context负责建立一条命令链，并返回首节点供高层模块调用

派发命令选模式

  • 命令模式
    • 命令的解析由责任链解析，但是如此多的命令还需要一个派发的角色，输入一个命令，不管后台由谁来解析，返回一个结果就成，这就要用到命令模式，命令模式负责协调各个正确地传递到各个责任链的首节点，这就是它的任务
    • 类图
    • 类图解析
      1. ClassUtils工具类：主要职责是根据一个接口、父类查找到所有的子类，在不考虑的应用中，使用该类可以带来非常好的扩展性
      2. CommandVO：是命令的值对象，它把一个命令解析为命令名、选项、操作数
      3. CommandEnum：是枚举类型，是命令配置文件

整合这个两个模式

  • 类图

具体代码

  • 项目结构

  • 详细代码

    • AbstractLS.java

      package com.peng.zm;

/**
 * @author kungfu~peng
 * @data 2018年1月10日
 * @description
 */
public abstract class AbstractLS extends CommandName {
    // 默认参数
    public final static String DEFAULT_PARAM = "";
    //参数a
    public final static String A_PARAM="a";
    //参数|
    public final static String L_PARAM="|";

}

    • ClassUtils.java

      package com.peng.zm;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;

/**
 * @author kungfu~peng
 * @data 2018年1月10日
 * @description
 */
public class ClassUtils {
    // 根据父类查找到所有的子类，默认情况下是子类和父类在同一个包名下
    public static List<Class> getSonClass(Class fatherClass) {
        // 定义一个返回值
        List<Class> returnClassList = new ArrayList<Class>();
        // 获得包名称
        String packageName = fatherClass.getPackage().getName();
        // 获得包中的所有类
        List<Class> packClasses = getClasses(packageName);
        // 判断是否是子类
        for (Class c : packClasses) {
            if (fatherClass.isAssignableFrom(c) && !fatherClass.equals(c)) {
                returnClassList.add(c);
            }
        }
        return returnClassList;
    }

    // 从一个包中查出所有的类，在jar包中不能查找
    private static List<Class> getClasses(String packageName) {
        ClassLoader classLoader = Thread.currentThread()
                .getContextClassLoader();
        String path = packageName.replace('.', '/');
        Enumeration<URL> resources = null;
        try {
            resources = classLoader.getResources(path);

        } catch (IOException e) {
            e.printStackTrace();
        }
        List<File> dirs = new ArrayList<File>();
        while (resources.hasMoreElements()) {
            URL resource = resources.nextElement();
            dirs.add(new File(resource.getFile()));
        }
        ArrayList<Class> classes = new ArrayList<Class>();
        for (File directory : dirs) {
            classes.addAll(findClasses(directory, packageName));
        }
        return classes;
    }

    private static List<Class> findClasses(File directory, String packageName) {
        List<Class> classes = new ArrayList<Class>();
        if (!directory.exists()) {
            return classes;
        }
        File[] files = directory.listFiles();
        for (File file : files) {
            if (file.isDirectory()) {
                assert !file.getName().contains(".") : classes
                        .addAll(findClasses(file,
                                packageName + "." + file.getName()));
            } else if (file.getName().endsWith(".class")) {
                try{
                    classes.add(Class.forName(packageName+"."+file.getName().substring(0,file.getName().length()-6)));
                }catch(ClassNotFoundException e){
                    e.printStackTrace();
                }
            }

        }
        return classes;
    }
}

    • Client.java

      package com.peng.zm;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author kungfu~peng
 * @data 2018年1月10日
 * @description
 */
public class Client {
    public static void main(String[] args) throws IOException {
        Invoker invoker = new Invoker();
        while (true) {
            System.out.println("#");
            String input = (new BufferedReader(new InputStreamReader(System.in)))
                    .readLine();
            // 输入exit或quit则退出
            if (input.equals("quit") || input.equals("exit")) {
                return;
            }
            System.out.println("执行结果：" + invoker.exec(input));
        }
    }
}

    • Command.java

      package com.peng.zm;

import java.util.ArrayList;
import java.util.List;

/**
 * @author kungfu~peng
 * @data 2018年1月10日
 * @description
 */
public abstract class Command {
    public abstract String execute(CommandVO vo);

    // 建立链表
    protected final List<? extends CommandName> buildChain(
            Class<? extends CommandName> abstractClass) {
        // 取出所有命令下的子类
        List<Class> classes = ClassUtils.getSonClass(abstractClass);
        // 存放命令的实例，并建立链表关系
        List<CommandName> commandNameList = new ArrayList<CommandName>();
        for (Class c : classes) {
            CommandName commandName = null;
            try {
                // 产生实例
                commandName = (CommandName) Class.forName(c.getName())
                        .newInstance();
            } catch (Exception e) {
                // 异常处理
            }
            // 建立链表
            if (commandNameList.size() > 0) {
                commandNameList.add(commandName);
            }
        }
        return commandNameList;

    }
}

    • CommandEnum.java

      package com.peng.zm;

import java.util.ArrayList;
import java.util.List;

/**
 * @author kungfu~peng
 * @data 2018年1月10日
 * @description
 */
public enum CommandEnum {
    ls("com.peng.zm.LSCommand");

    private String value = "";

    // 定义构造函数，目的是Data（value）类型相匹配

    private CommandEnum(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    // 方式所有的enum对象
    public static List<String> getNames() {
        CommandEnum[] commandEnum = CommandEnum.values();
        List<String> names = new ArrayList<String>();
        for (CommandEnum commandEnum2 : commandEnum) {
            names.add(commandEnum2.name());
        }
        return names;
    }
}

    • CommandName.java

      package com.peng.zm;

/**
 * @author kungfu~peng
 * @data 2018年1月10日
 * @description 抽象命名类
 */
public abstract class CommandName {
    private CommandName nextOperator;

    public final String handleMessage(CommandVO vo) {
        // 处理结果
        String result = "";
        // 判断是否是自己处理的参数
        if (vo.getParam().size() == 0
                || vo.getParam().contains(this.getOperateParam())) {
            result = this.echo(vo);
        } else {
            if (this.nextOperator != null) {
                result = this.nextOperator.handleMessage(vo);
            } else {
                result = "命令无法执行";
            }
        }
        return result;
    }

    // 设置剩余参数有谁来处理
    public void setNext(CommandName _operator) {
        this.nextOperator = _operator;
    }

    // 每个处理者都要处理一个后缀参数
    protected abstract String getOperateParam();

    // 每个处理者都要实现必须处理任务
    protected abstract String echo(CommandVO vo);

}

    • CommandVO.java

      package com.peng.zm;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

/**
 * @author kungfu~peng
 * @data 2018年1月10日
 * @description
 */
public class CommandVO {
    // 定义参数名与参数的分隔符，一般是空格
    public final static String DIVIDE_FLAG = " ";
    // 定义参数前的符号，Unix一般是-
    public final static String PREFIX = "-";
    // 命令名
    private String commandName = "";
    // 参数列表
    private ArrayList<String> paramList = new ArrayList<String>();
    // 操作数列表
    private ArrayList<String> dataList = new ArrayList<String>();

    // 通过构造函数来传递进来
    public CommandVO(String commandStr) {
        // 常规判断
        if (commandStr != null && commandStr.length() != 0) {
            // 根据分隔符号拆分出执行符号
            String[] complexStr = commandStr.split(CommandVO.DIVIDE_FLAG);
            // 第一个参数是执行符号
            this.commandName = complexStr[0];
            // 把参数放到List
            for (int i = 1; i < complexStr.length; i++) {
                String str = complexStr[i];
                // 包含前缀符号，认为是参数
                if (str.indexOf(CommandVO.PREFIX) == 0) {
                    this.paramList
                            .add(str.replace(CommandVO.PREFIX, "").trim());
                } else {
                    // 操作数列表
                    this.dataList.add(str.trim());
                }
            }
        } else {
            // 传递的命令错误
            System.out.println("命令解析失败，必须传递一个命令才能执行！");
        }
    }

    // 得到命令名
    public String getCommandName() {
        return this.commandName;
    }

    /**
     * 功能： 返回值类型： 参数列表：
     * 
     * @return
     */
    public List<String> getParam() {
        // 为了方便处理空参数
        if (this.paramList.size() == 0) {
            this.paramList.add("");
        }
        return new ArrayList(new HashSet(this.paramList));
    }

    // 获得操作数
    public ArrayList<String> getaData() {
        return this.dataList;
    }

    /**
     * 功能： 返回值类型： 参数列表：
     * 
     * @return
     */
    public String formatDate() {
        return this.getaData().toString();
    }

}

    • FileManager.java

      package com.peng.zm;

/**
 * @author kungfu~peng
 * @data 2018年1月10日
 * @description
 */
public class FileManager {
    // ls命令
    public static String ls(String path) {
        return "file1\nfile2\nfile3\nfile4";
    }

    // ls-l命令
    public static String ls_l(String path) {
        String str = "drw-rw-rw root system 1024 2018-1-10 18:00 file1/n";
        str += "drw-rw-rw root system 1024 2018-1-10 18:01 file2/n";
        str += "drw-rw-rw root system 1024 2018-1-10 18:02 file3/n";
        return str;
    }

    // ls-a命令
    public static String ls_a(String path) {
        return ".\n..\nfile1\nfile2\nfile3";
    }
}

    • Invoker.java

      package com.peng.zm;

/**
 * @author kungfu~peng
 * @data 2018年1月10日
 * @description
 */
public class Invoker {
    // 执行命令
    public String exec(String _commandStr) {
        // 返回值
        String result = "";
        // 首先解析命令
        CommandVO vo = new CommandVO(_commandStr);
        // 检查命令是否支持该命令
        if (CommandEnum.getNames().contains(vo.getCommandName())) {
            // 产生命令对象
            String className = CommandEnum.valueOf(vo.getCommandName())
                    .getValue();
            Command command;
            try {
                command = (Command) Class.forName(className).newInstance();
                result = command.execute(vo);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            result = "无法执行命令，请检查命令格式!";
        }
        return result;
    }
}

    • LS_A.java

      package com.peng.zm;

/**
 * @author kungfu~peng
 * @data 2018年1月10日
 * @description
 */
public class LS_A extends AbstractLS {
    @Override
    protected String getOperateParam() {
        return super.A_PARAM;
    }

    @Override
    protected String echo(CommandVO vo) {
        return FileManager.ls_a(vo.formatDate());
    }

}

    • LS_L.java

      package com.peng.zm;

/**
 * @author kungfu~peng
 * @data 2018年1月10日
 * @description
 */
public class LS_L extends AbstractLS {
    @Override
    protected String getOperateParam() {
        return super.L_PARAM;
    }

    @Override
    protected String echo(CommandVO vo) {
        return FileManager.ls_l(vo.formatDate());
    }

}

    • LS.java

      package com.peng.zm;

/**
 * @author kungfu~peng
 * @data 2018年1月10日
 * @description
 */
public class LS extends AbstractLS {

    // 参数为空
    @Override
    protected String getOperateParam() {
        return super.DEFAULT_PARAM;
    }

    // 最简单的ls命令
    @Override
    protected String echo(CommandVO vo) {
        return FileManager.ls(vo.formatDate());
    }

}

    • LSCommand.java

      package com.peng.zm;

/**
 * @author kungfu~peng
 * @data 2018年1月10日
 * @description
 */
public class LSCommand extends Command {
    @Override
    public String execute(CommandVO vo) {
        String result = "";
        if (vo.getCommandName().equalsIgnoreCase("ls")
                && vo.getParam().size() == 1 && vo.getaData().size() == 0) {
            if (vo.getParam().contains("") || vo.getParam().contains("A")) {
                AbstractLS al = new LS();
                result = al.echo(vo);
            } else if (vo.getParam().contains("a")
                    || vo.getParam().contains("A")) {
                AbstractLS al = new LS_A();
                result = al.echo(vo);
            } else if (vo.getParam().contains("l")
                    || vo.getParam().contains("L")) {
                AbstractLS al = new LS_L();
                result = al.echo(vo);
            }
        } else {
            result = "../../file/all../";
        }
        return result;
    }
}

    • 执行结果

      #
ls
执行结果：file1
file2
file3
file4
#
ls -a
执行结果：.
..
file1
file2
file3
#
ls -l
执行结果：drw-rw-rw root system 1024 2018-1-10 18:00 file1/ndrw-rw-rw root system 1024 2018-1-10 18:01 file2/ndrw-rw-rw root system 1024 2018-1-10 18:02 file3/n
#

最佳实践

  • 责任链模式
    • 负责对命令参数进行解析，而且所有的扩展都是增加链数量和节点，不涉及原有的代码变更
  • 命令模式
    • 负责命令的分发，把适当的命令发送到指定的链上
  • 模板方法模式
    • 建立链的方法作为模板办法，调用基本方法，基本方法由各个实现类实现，非常有利于扩展
  • 迭代器模式
    • 在for循环中我们多次用到类似for(Class c:classes)的结构，是谁来支撑该方法运行？当然是迭代器模式

未处理的项

  • ls-l-a
    • 处理方式
      1. 独立处理：“is-l-a”等同于“ls-a”命令，可以把“ls-la”中的选项“la”作为一个参数来进行处理，扩展一个类就可以了，该方法的缺点就是类膨胀的太大，但是简单
      2. 混合处理：修正命令链处理链，每个命令处理节点运行完毕后，继续由后续节点处理，最终由Command类组装结果，根据每个节点处理结果，组合后生产完整的返回信息

关于该框架

  • 该框架还有一个名字，叫做命令链模式，具体来说就是命令模式作为责任链模式的排头兵，由命令模式分发具体的消息到责任链模式。
乘风御浪云帆之上
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
设计模式之（命令+责任链）
08-03
命令模式和责任链模式的java代码，先了解这两个模式，才比较清楚这的代码；
java设计模式之模板方法模式详解
08-30
"java设计模式之模板方法模式详解" 模板方法模式是一种行为设计模式，主要用于定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。...
浅谈简单工作流设计——责任链模式配合策略与命令模式的实现
tansitongba
01-07 722
本文以项目中的一个工作流模块，演示责任链模式、策略模式、命令模式的组合实现！ 流程简介 最近在做的一个项目，涉及到的是一个流程性质的需求。关于工程机械行业的服务流程：服务任务流程和备件发运流程。 项目之初，需求不是很清晰，算是演化模型吧。先出一个简单版本，然后根据用户的使用情况，再进一步探测新需求。所以也就是说这两个流程中的每一步暂时都不是固定的，而应该是可配置、可增减的。 目前暂定的...
命令模式+责任链模式。
孤芳不自赏
10-08 1180
搬移UNIX的命令 在操作系统的世界里，有两大阵营一直在PK着：*nix（包括UNIX和Linux）和Windows。从目前的统计数据来看，*nix在应用服务器领域占据相对优势，不过Windows也不甘示弱，国内某些小型银行已经在使用PC Server（安装Windows操作系统的服务器）集群来进行银行业务运算，而且稳定性、性能各方面的效果不错；而在个人桌面方面，Windows是占绝对优势的，大...
Activiti 中的 命令模式与责任链模式
xyzroundo的专栏
10-26 1041
类图： 命令模式：CommandInvoker -》Command-》Receiver(Command实现) 责任链模式：CommandInterceptor 一个自循环实现 CommandInvoker 连接把两种模式连接起来。 public class CommandInvoker extends AbstractCommandInterceptor { private static final Logger logger = LoggerFactory.getLogger(Comma
混合模式：命令模式+责任链模式
肥羊汤
05-19 1496
这里我们使用命令模式、责任链模式、模板方法模式，制作一个把UNIX上的命令移植到Windows上的工具。 UNIX下的命令，一条命令分为命令名、选项和操作数，例如命令"ls-l/usr"。其中，ls是命令名，l是选项，/usr是操作数，后两项都是可选项。 UNIX命令一定遵守以下几个规则： 命令名为小写字母。 命令名、选项、操作数之间以空格分隔，空格数量不受限制。 选项之间可以组合使用，也可以单独拆分使用。 选项以横杠（-）开头。 其中，ls命令中有几个常用的命令： ls：简单列出一个目录..
QFramer UI框架之混合模式.7z
03-31
QFramer UI框架之混合模式源代码
设计模式 混搭 鸭子叫 Demo
04-29
设计模式 混搭 鸭子叫 Demo
“互联网+”商务英语混合教学模式分析.doc
07-07
“互联网+”商务英语混合教学模式分析.doc
Java设计模式（九）责任链模式 命令模式
fanyun7654的专栏
07-11 1485
（十七）责任链模式 责任链模式的目的是通过给予多个对象处理请求的机会，已解除请求发送者与接受者之间的耦合关系。面对对象的开发力求对象之前保持松散耦合，确保对象各自的责任最小化，这样的设计可以使得系统更加容易修改，同时降低产生缺陷的风险。 （十八）命令模式 command 命令模式将请求封装在一个对象中，可以像管理对象一样去管理方法，传递并在合适的时机调用。 命令模式允许在服务执行的上下文使用客户端代码，所
快速迭代业务背景下：设计模式混编的一次尝试
程序猿的十万个为什么
11-13 321
​一、业务背景 在现有集团业务中，快速迭代已经是家常便饭了，立项需求，评估排期，进入开发，提前进入测试。作为项目任何一个环节的小伙伴应该都有体会，快速反应快速迭代已经成为常态。如果假如你参与的是一个稳定服务的中台项目，那么还好一些能够持续的思考优化项目。如果只是一种活动性质的项目，这次做完下次业务就完全不一样了加上时间短任务重，导致没有那么多时间去做设计，设计模式的作用在这种类型的项目中作用就被削弱了。设计模式的使用比较常见是中间件、技术框架中。因为设计模式的主要能力是解耦，所以在中间件和技术框架中便发挥
命令模式和职责链模式
World-wang
08-26 729
#include #include #include using namespace std; /* 命令模式和职责链模式 把这两个模式放在一起学习，因为觉得对比起来学习更有效果。 前者是多个命令交付给一个指定的处理者去处理 后者是将一个请求，按链式方式交付给多个执行者，找到其中适合执行的执行者去操作。 命令模式中主要是处理多个命令，通过中间人对命令的整理与修改，最后将命令名单发送给执行
设计模式--混合模式--事件触发器
测试小鸡的博客
03-04 2885
昨天懈怠了，没有写什么内容！今天主要还是想写设计模式： 在阅读源码的过程中我们会接触到越来越多的设计模式，所以我觉得是时候来认真的来写一写了！今天主要完成的是： 事件触发器的测试，就是相当于我们自己设计了一个框架来专门完成触发器这个功能！首先我列出元模型，然后我在后面一节会根据这个模型进行改编成浏览器中大量出现的或者swing中也大量出现的事件类型，例如按钮事件：点击、释放等然后这个按钮是通过工厂...
设计模式 - 状态模式、职责链模式
等等... 大雄，有啦！
06-07 1360
UML 状态模式 职责链模式 区别 我一直无法分析出两者真正的区别是什么，两者确实非常相似，他俩都代表着转移，甚至同一个问题都可以由两者分别完成。所以，我在网上搜了一个分析两者区别的文章，如下： 职责链模式：当客户提交一个请求时，请求是沿链传递直至有一个ConcreteHander对象负责处理它。接收者和发送者都没有对方的明确信息，且链
设计模式之禅之混编【工厂方法模式+策略模式】
菜鸟零号 kungfu~peng
01-18 1958
设计模式之禅混编2工厂方法模式+策略模式迷你版的交易系统“一卡通”项目联机交易子系统集团公司的架构总部省级分部市级机构业务要求推广到全国，在山西能做的事在全国的其他地方也能做对于联机子项目，异地分支机构与总部之间的通讯联机交易系统有一个非常重要的子模块--扣款子模块从业务上说：扣款失败就代表着所有的商业交易关闭，这是不允许发生的从技术上说：扣款子模块的异常处理、事物处理、鲁棒性都是不容忽视的详细分
使用责任链、命令模式
yszbrzdd的博客
06-22 1155
实验目的与任务 目的：熟悉UML的使用,熟悉责任链、命令模式。 任务：按照实验内容要求，完成使用责任链、命令模式实现实验内容 预习内容 复习课程的内容，熟悉责任链、命令模式的使用。 实验内容及要求 责任链模式： 1、学生请假一般为班主任1天，系主任3天，院长7天，请结合责任链模式给出类图并实现。 命令模式： 磁带式录音...
责任链模式（Chain of Responsibility）--命令模式（Command）
02-04 486
17、责任链模式（Chain of Responsibility） 有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。 MyHandle类是核心，实例化后生成一系列相互持有的对象，构成一条链。 public interface Handler {       public void operator();   }   p...
go实现混合责任链和工厂模式demo
最新发布
05-31
好的，下面是一个简单的示例代码，实现了混合责任链和工厂模式： ```go package main import ( "fmt" ) // 定义一个接口，表示责任链节点 type Handler interface { Handle(data interface{}) (interface{}, ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

乘风御浪云帆之上

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

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

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

打赏作者

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

抵扣说明：

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

余额充值