JAVA 设计模式—————— 命令模式和职责链模式

于 2021-11-22 14:11:08 发布
阅读量901 收藏 3
点赞数
分类专栏： 设计模式 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46410481/article/details/121470450
版权

学习 Netty 前的准备工作！！

这里，还是先来复习一下 OOP （面向对象）的七大原则：

  • 开闭原则：对扩展开放，对修改关闭
  • 里氏替换原则：继承必须确保超类所拥有的性质在子类中仍然成立。
  • 依赖倒置原则：要面向接口编程，不要面向实现编程
  • 单一职责原则：要控制类的粒度大小，将对象解耦，提高其内聚性
  • 接口隔离原则：要为各个类创建它们需要的专用接口
  • 迪米特法则：尽量先使用合并或者聚合等关联关系来实现，其次才考虑使用继承关系来实现

命令模式（详解版）

在软件开发系统中，方法的请求者 与 方法的实现者之间经常存在着紧密的耦合关系，这不利于软件功能的扩展与维护。例如：想对方法进行 撤销、重做、记录 等处理都很不方便，因此，如何将方法的请求者与方法的实现者解耦，变得很重要，命令模式由此而生。

在现实生活中，命令模式的例子有很多，比如看电视的时候，我们只需要轻轻一按遥控器就能完成频道的切换，这就是命令模式，将换台请求和换台处理完全解耦了。电视机遥控器（命令发生者）通过按钮（具体命令）来遥控电视机（命令接收者）。

再比如，我们去餐厅吃饭，菜单不是等到客人来了之后才定制的，而是已经预先配置好的。这样，客人来了就只需要点菜，而不是由客人临时定制。餐厅提供的菜单就相当于把请求和处理进行了解耦，这就是命令模式的体现。

命令模式的定义与特点

命令（Command）模式的定义如下：将一个请求封装为一个对象。将发出请求的责任和执行请求的责任分隔开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行储存、传递、调用、增加与管理。

命令模式的主要优点：

  • 通过引入中间件（抽象接口）降低系统的耦合度。
  • 扩展性良好，增加或者删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，其满足开闭原则。
  • 可以实现宏命令。命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令。
  • 方便实现 Undo 和 Redo 操作。命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复。
  • 可以再现有命令的基础上，增加额外的功能。比如日志记录，集合装饰器模式会更加灵活。

其缺点是：

  • 可能产生大量具体的命令类。因为每一个具体操作都需要设计一个具体命令类，这会增加系统的复杂性。
  • 命令模式的结果其实就是接收方的执行结果，但是为了以命令的形式进行架构、解耦请求与实现，引入了额外的类型结构（引入了请求方与抽象命令接口），增加了理解上的困难。不过这也是设计模式的通病，抽象必然会额外导致类的数量，代码抽离肯定比代码聚合更加难理解。

命令模式的结构与实现

可以将系统中的相关操作抽象成命令，使调用者与实现者相关分离，其结构如下：

1、命令模式的结构

命令模式包含以下主要角色：

  • 抽象命令类（Command）角色：声明执行命令的接口，拥有执行命令的抽象方法 execute()。
  • 具体命令类（Concrete Command）角色：是抽象命令类的具体实现类，它拥有接收者对象，并通过调用接收者的功能来完成命令要执行的操作。
  • 实现者 / 接收者（Receiver）角色：执行命令功能的相关操作，是具体命令对象业务的真正实现者。
  • 调用者 / 请求者（Invoker）角色：是请求的发送者，它通常拥有很多的命令对象，并通过访问命令对象来执行相关请求，它不直接访问接收者。

IvzOw4.gif

模式的实现：

/**
 * @author wcc
 * @date 2021/11/22 10:30
 * 命令模式的实现
 */
public class CommandPattern {

    public static void main(String[] args) {

        Receiver receiver = new Receiver();

        Command command = new ConcreteCommand(receiver);

        Invoker invoker = new Invoker(command);

        System.out.println("客户访问调用者的call方法");
        invoker.call();

    }

}

// 调用者
class Invoker {
    private Command command;

    public Invoker(Command command) {
        this.command = command;
    }

    public void setCommand(Command command) {
        this.command = command;
    }

    public void call(){
        System.out.println("调用者执行命令 Command...");
        command.execute();
    }
}

// 抽象命令
interface Command {
    public abstract void execute();
}

// 具体命令
class ConcreteCommand implements Command {

    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.action();
    }

}

// 接收者
class Receiver {
    public void action() {
        System.out.println("接收者的action()方法被调用...");
    }
}

测试运行结果如下：

IxPu5Q.png

命令模式的应用实例

【例1】：用命令模式实现客户区餐馆吃早餐的实例

分析：客户去餐馆可选择的早餐有肠粉、河粉和混沌等，客户可以向服务员选择以上早餐中的若干种，服务员将客户的请求交给相关的厨师去做。这里的早餐相当于命令，服务员相当于调用者，厨师相当于接收者，所以用命令模式比较合适。

  • 首先，定义一个早餐类（Breakfast），它是抽象命令类，有抽象方法 cooking()，说明要做什么
  • 再定义其子类肠粉（ChangFen）、馄饨类（HunTun）和河粉类（HeFen），它们是具体命令类，实现早餐类的 cooking() 方法，但是它们不会具体做，而是交给具体的厨师去做；
  • 具体厨师类有肠粉厨师（ChangFenChef）、馄饨厨师（HunTunChef）和河粉厨师（HeFenCef），它们是命令的接收者。

最后，定义服务员类（ Waiter），它接收客户的做菜请求，并发出做菜的命令。客户类是通过服务员类来实现点菜的

IxE64U.gif

/**
 * @author wcc
 * @date 2021/11/22 11:02
 */
public class CookingCommand {

    public static void main(String[] args) {

        BreakFast food1 = new ChangFen();
        BreakFast food2 = new HUnTun();
        BreakFast food3 = new HeFen();

        Waiter waiter = new Waiter();

        waiter.setChangFen(food1);
        waiter.setHUnTun(food2);
        waiter.setHeFen(food3);

        waiter.chooseChangFen();
        waiter.chooseHunTun();
        waiter.chooseHeFen();
    }

}

// 调用者 服务员
class Waiter {
    private BreakFast ChangFen,HUnTun,HeFen;

    public Waiter() {
    }

    public void setChangFen(BreakFast changFen) {
        ChangFen = changFen;
    }

    public void setHUnTun(BreakFast HUnTun) {
        this.HUnTun = HUnTun;
    }

    public void setHeFen(BreakFast heFen) {
        HeFen = heFen;
    }

    public void chooseChangFen(){
        ChangFen.cooking();
    }

    public void chooseHunTun(){
        HUnTun.cooking();
    }

    public void chooseHeFen(){
        HeFen.cooking();
    }
}

// 抽象命令：早餐
interface BreakFast {
    public abstract void cooking();
}

// 具体命令：肠粉
class ChangFen implements BreakFast {

    private ChangFenChef changFenChef = new ChangFenChef();

    @Override
    public void cooking() {
        changFenChef.cooking();
    }

}

// 具体命令：馄饨
class HUnTun implements BreakFast {

    private HunTunChef hunTunChef = new HunTunChef();

    @Override
    public void cooking() {
        hunTunChef.cooking();
    }

}

// 具体命令：肠粉
class HeFen implements BreakFast {

    private HeFenChef heFenChef = new HeFenChef();

    @Override
    public void cooking() {
        heFenChef.cooking();
    }

}

// 接收者：肠粉厨师
class ChangFenChef {

    public void cooking(){
        System.out.println("做肠粉...");
    }

}

// 接收者：馄饨厨师
class HunTunChef {

    public void cooking() {
        System.out.println("做馄饨...");
    }

}

// 接收者：河粉厨师
class HeFenChef {

    public void cooking() {
        System.out.println("做河粉...");
    }

}

IxeRgg.png

命令模式的应用场景

当系统的某项操作具备命令语义，且命令实现不稳定（变化）的时候，可以通过命令模式解耦请求与实现。使用抽象命令接口使请求方的代码架构稳定，封装接收方具体命令的实现细节。接收方与抽象命令呈现弱耦合（内部方法无需一致），具备良好的扩展性。

命令模式通常适用于以下场景：

  • 请求调用者需要与请求接收者解耦的时候，命令模式可以使得调用者和接收者不直接交互。
  • 系统随机请求命令或者经常增加、删除命令的时候，命令模式可以方便的实现这些功能。
  • 当系统需要执行一系列操作的时候，命令模式可以定义宏命令来实现该功能。
  • 当系统需要支持命令的撤销（Undo）操作恢复（Redo）操作的时候，可以将命令对象存储起来，采用备忘录模式来实现。

责任链模式（职责链模式）详解

在现实生活中，一个事件需要经过多个对象处理是很常见的场景。例如：采购审批流程、请假流程等。公司员工请假，可批假的有领导有部门有负责人、副总经理、总经理等，但是每个领导能批准的天数不同，员工必须根据需要请假的天数去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地址等信息，这无疑增加了难度。

在计算机软硬件中也有相关的例子，如总线网中数据报传送，每台计算机格局目标地址是否同自己的地址相同来决定是否接收；还有异常处理中，处理程序根据异常的类型决定自己是否处理该异常；还有 Struts2 的拦截器、JSP 和 Servlet 的Filter等，所有这些，都可以考虑使用责任链模式来实现。

责任链模式的定义与特点

责任链（Chain Of Responsibility）模式 的定义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生的时候，可将请求沿着这条链传递，直到有对象处理它为止。

注意：责任链模式也叫做职责链模式。

在责任链模式中，客户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，请求会自动进行传递。所以责任链将请求的发送者和请求的处理者解耦了。

责任链模式是一种对象行为型模式，其主要优点如下：

  • 降低了对象之间的耦合度。该模式使得一个对象无须直到到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无需拥有对方的明确信息。
  • 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
  • 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态的改变链内的成员或者调动它们的次序，也可动态的新增或者删除责任。
  • 责任链简化了对象之间的连接。每个对象只需要保持一个指向其后继者的引用，不需要保持其他所有处理者的引用，这避免了使用众多的 if 或者 if … else 语句。
  • 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

其主要缺点如下：

  • 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
  • 对比较长的职责链，请求的处理可能涉及到多个处理对象，系统性能将受到一定的影响。
  • 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。

职责链模式的结构与实现

通常情况下，可以通过数据链表来实现职责链模式的数据结构。

1、职责链模式的结构

职责链模式主要包含以下角色：

  • 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
  • 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
  • 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

责任链模式的本质是解耦请求与处理，让请求在处理链中能进行传递与被处理；理解责任链模式应当理解其模式，而不是其具体实现。责任链模式的独到之处是将其节点处理者组合成了链式结构，并允许节点自身决定是否进行请求处理或者转发，相当于让请求流动i起来。

结构图：

IxRni9.gif]

IxR1sK.gif

职责链模式的实现：

/**
 * @author wcc
 * @date 2021/11/22 13:46
 */
public class ChainResponsibilityPattern {

    public static void main(String[] args) {

        // 组装责任链
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        handler1.setNext(handler2);

        // 提交请求
        handler1.handleRequest("two");

    }

}

// 抽象处理者角色
abstract class Handler {
    private Handler next;

    public void setNext(Handler next) {
        this.next = next;
    }

    public Handler getNext() {
        return next;
    }

    // 处理请求的方法
    public abstract void handleRequest(String request);
}

// 具体处理者角色1
class ConcreteHandler1 extends Handler {
    public void handleRequest(String request){
        if(request.equalsIgnoreCase("one")){
            System.out.println("具体处理者1负责处理该请求...");
        }else{
            if(getNext()!=null){
                getNext().handleRequest(request);
            }else{
                System.out.println("没有人处理该请求...");
            }
        }
    }
}

// 具体处理者角色2
class ConcreteHandler2 extends Handler {
    public void handleRequest(String request){
        if(request.equalsIgnoreCase("two")){
            System.out.println("具体处理者2负责处理该请求...");
        }else{
            if(getNext()!=null){
                getNext().handleRequest(request);
            }else{
                System.out.println("没有人处理该请求...");
            }
        }
    }
}

测试结果如下：
IxWr11.png
在上面代码中，我们吧消息硬编码为 String 类型的，而在真实业务中，消息是具备多样性的，可以是 int、String 或者自定义类型。因此，在上面代码的基础上，可以对消息类型进行抽象 Request，增强了消息的兼容性。

职责链模式的应用实例

【例1】：用责任链模式设计一个请假审批模块。

分析：加入规定学生请假小于或者等于两天，班主任可以批准，小于或者等于7天，系主任可以批准；小于等于10天，院长可以批准；其他情况不予批准；这个实例适合使用职责链模式实现。

首先，定义一个领导类（Leader），它是抽象处理者，包含了一个指向下一位领导的指针 next 和一个处理假条的抽象处理方法 handleRequest（int LeaveDays）；然后，定义班主任类（ClassAdviser）、系主任类（DepartmentHead）和院长类（ Dean），它们是抽象处理者的子类，是具体处理者，必须根据自己的权力去实现父类的 handleRequest（int LeaveDays）方法，如果无权处理就将假条交给下一位具体处理者，直到最后；客户类负责创建处理链，并将假条交给链头的具体处理者（班主任）。

IxhCRA.gif

/**
 * @author wcc
 * @date 2021/11/22 13:59
 */
public class LeaveApprovalTest {

    public static void main(String[] args) {

        //组装责任链
        Leader teacher1 = new ClassAdviser();
        Leader teacher2 = new DepartmentHead();
        Leader teacher3 = new Dean();
        //Leader teacher4=new DeanOfStudies();
        teacher1.setNext(teacher2);
        teacher2.setNext(teacher3);
        //teacher3.setNext(teacher4);
        //提交请求
        teacher1.handleRequest(8);

    }

}

// 抽象处理者：领导类
abstract class Leader {
    private Leader next;

    public Leader getNext() {
        return next;
    }

    public void setNext(Leader next) {
        this.next = next;
    }

    // 处理请求的方法
    public abstract void handleRequest(int leaveDays);
}

// 具体处理者1：班主任类
class ClassAdviser extends Leader {
    public void handleRequest(int LeaveDays) {
        if (LeaveDays <= 2) {
            System.out.println("班主任批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}

// 具体处理者2：系主任
class DepartmentHead  extends Leader {

    @Override
    public void handleRequest(int leaveDays) {
        if(leaveDays <= 7){
            System.out.println("系主任批准您请假" + leaveDays + "天");
        }else{
            if(getNext() != null){
                getNext().handleRequest(leaveDays);
            }else{
                System.out.println("请假天数太多，没有人批准该假条");
            }
        }
    }

}

//具体处理者3：院长类
class Dean extends Leader {
    public void handleRequest(int LeaveDays) {
        if (LeaveDays <= 10) {
            System.out.println("院长批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}
//具体处理者4：教务处长类
class DeanOfStudies extends Leader {
    public void handleRequest(int LeaveDays) {
        if (LeaveDays <= 20) {
            System.out.println("教务处长批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}

测试结果如下：
Ix4ocR.png

职责链模式的应用场景

  • 多个对象可以处理一个请求，但具体由哪个对象处理该请求在运行时自动确定
  • 可动态指定一组对象处理请求，或者添加新的处理者
  • 需要在不明确指定请求处理者的情况下，向多个处理者中的一个提交请求

职责链模式的扩展

职责链模式存在以下两种情况：

  • 纯的职责链模式：一个请求必须被某一个处理者对象所接收，且一个具体处理者对某个请求的处理只能采用以下两种行为之一：自己处理（承担责任）；把责任推给下家处理。
  • 不纯的职责链模式：允许出现某一个具体处理者对象在承担了请求的一部分责任后又将剩余的责任传给下家的情况，且一个请求可以最终不被任何接收端对象所接收。
*吴聪聪*
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值