【设计模式四】行为型模式（模版方法/命令）

最新推荐文章于 2024-10-06 09:53:07 发布

土味儿~

最新推荐文章于 2024-10-06 09:53:07 发布

阅读量118

点赞数

分类专栏：设计模式文章标签：设计模式 java python 接口数据库

本文链接：https://blog.csdn.net/tu_wer/article/details/120192793

版权

设计模式专栏收录该内容

12 篇文章 1 订阅

订阅专栏

六、行为型模式

1、模版方法模式

Template Method Pattern

又叫模板模式 Template Pattern

1)基本介绍

模板方法模式(Template Method Pattern)，又叫模板模式(Template Pattern)，在一个抽象类中公开定义了执行它的方法的模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。
简单说，模板方法模式定义了操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构，就可以重定义该算法的某些特定步骤
属于行为型模式

2)原理类图

AbstractClass 抽象类，类中实现了模板方法(template)，定义了算法的骨架，具体子类需要去实现其它的抽象方法 operationr2、3、4
ConcreteClass 实现抽象方法 operationr2、3、4，以完成算法中特定子类的步骤

3)案例分析

制作豆浆

流程：选材--->添加配料--->浸泡--->放到豆浆机打碎

通过添加不同的配料，可以制作出不同口味的豆浆；选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的(红豆、花生豆浆。。。)

豆浆 SoyaMilk

抽象模版类

package template;

/**
 * @author ajun
 * Date 2021/7/27
 * @version 1.0
 * 豆浆
 * 抽象模版类
 */
public abstract class SoyaMilk {
    /**
     * 制作流程模板
     * final：子类不能修改
     */
    final void make(){
        // 选料
        select();
        // 添加配料
        addCondiments();
        // 浸泡
        soak();
        // 打碎
        beat();
    }

    /**
     * 选料
     */
    private void select(){
        System.out.println("选主料：新鲜黄豆");
    }

    /**
     * 添加配料
     * 不同豆浆有不同的配料
     * 具体的豆浆子类去实现
     */
    abstract void addCondiments();

    /**
     * 浸泡
     */
    private void soak(){
        System.out.println("浸泡：3小时");
    }

    /**
     * 打碎
     */
    private void beat(){
        System.out.println("打碎");
    }
}

红豆豆浆 RedBeanSoyaMilk

package template;

/**
 * @author ajun
 * Date 2021/7/27
 * @version 1.0
 * 红豆豆浆
 */
public class RedBeanSoyaMilk extends SoyaMilk{
    @Override
    void addCondiments() {
        System.out.println("添加配料：红豆");
    }
}

花生豆浆 PeanutSoyaMilk

package template;

/**
 * @author ajun
 * Date 2021/7/27
 * @version 1.0
 * 花生豆浆
 */
public class PeanutSoyaMilk extends SoyaMilk{
    @Override
    void addCondiments() {
        System.out.println("添加配料：花生");
    }
}

客户 Client

package template;

/**
 * @author ajun
 * Date 2021/7/27
 * @version 1.0
 */
public class Client {
    public static void main(String[] args) {
        System.out.println("-----红豆豆浆-----");
        SoyaMilk redBeanSoyaMilk = new RedBeanSoyaMilk();
        redBeanSoyaMilk.make();

        System.out.println("-----花生豆浆-----");
        SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
        peanutSoyaMilk.make();

    }
}

运行结果

-----红豆豆浆-----
选主料：新鲜黄豆
添加配料：红豆
浸泡：3小时
打碎
-----花生豆浆-----
选主料：新鲜黄豆
添加配料：花生
浸泡：3小时
打碎

4)钩子方法

在模板方法模式的父类中，定义一个方法，默认不做任何事，子类可以视情况要不要覆盖它，该方法称为钩子
通用钩子方法，子类可以控制父类
豆浆案例升级
- 制作原味纯豆浆，不添加任何的配料

豆浆抽象类升级 SoyaMilk

public abstract class SoyaMilk {
    /**
     * 制作流程模板
     * final：子类不能修改
     */
    final void make(){
        ...
        if(isAddCondiments()){
            // 添加配料
            addCondiments();
        }
        ...
    }

    /**
     * 是否添加配料
     * @return
     */
    boolean isAddCondiments(){
        return true;
    }
}

原生豆浆 PureSoyaMilk

package template.improve;

/**
 * @author ajun
 * Date 2021/7/27
 * @version 1.0
 * 原味豆浆
 */
public class PureSoyaMilk extends SoyaMilk{
    @Override
    void addCondiments() {
        // 空实现：原味豆浆不需要添加配料
    }

    @Override
    boolean isAddCondiments() {
        return false;
    }
}

客户

System.out.println("-----原味豆浆-----");
SoyaMilk pureSoyaMilk = new PureSoyaMilk();
pureSoyaMilk.make();

运行结果

-----原味豆浆-----
选主料：新鲜黄豆
浸泡：3小时
打碎

5)Spring IOC 中应用案例

Spring IOC容器初始化时用到模板方法模式

6)注意事项和细节

基本思想是：算法只存在于一个地方，也就是在父类中，容易修改。需要修改算法时，只要修改父类的模板方法或者已经实现的某些步骤，子类就会继承这些修改
实现了最大化代码复用。父类的模板方法和已实现的某些步骤会被子类继承而直接使用
既统一了算法，也提供了很大的灵活性。父类的模板方法确保了算法的结构保持不变，同时由子类提供部分步骤的实现
不足之处：每一个不同的实现都需要一个子类实现，导致类的个数增加，使得系统更加庞大
一般模板方法都加上 final 关键字，防止子类重写模板方法
模板方法模式使用场景：当要执行一系列步骤，这一系列的步骤基本相同，但个别步骤在实现时可能不同，通常考虑用模板方法模式来处理

2、命令模式

Command Pattern

1)基本介绍

命令模式(Command Pattern)：在软件设计中，我们经常需要向某些对象发送请求，但是并不知道请求的接收者是谁，也不知道被请求的操作是哪个，我们只需在程序运行时指定具体的请求接收者即可，此时，可以使用命令模式来进行设计
命令模式消除了请求发送者与请求接收者之间的耦合，让对象之间的调用关系更加灵活，实现解耦
在命令模式中，会将一个请求封装为一个对象，以便使用不同参数来表示不同的请求(即命名)，同时命令模式

也支持可撤销的操作

通俗易懂的理解：将军发布命令，士兵去执行。其中有几个角色：将军(命令发布者)、士兵(命令的具体执行者)、命令(连接将军和士兵)
- Invoker 是调用者(将军)
- Receiver 是被调用者(士兵)
- MyCommand 是命令，实现了 Command接口，持有接收对象

2)原理类图

Invoker 调用者角色
Command 命令角色，需要执行的所有命令都在这里，可以是接口或抽象类
Receiver 接受者角色，知道如何实施和执行一个请求相关的操作
ConcreteCommand 将一个接受者对象与一个动作绑定，调用接受者相应的操作，实现 execute

3)案例分析

实现一个 app 控制所有智能家电的需要，则每个智能家电厂家都要提供一个统一的接口给 app 调用

命令接口 Command

package command;

/**
 * @author ajun
 * Date 2021/7/28
 * @version 1.0
 * 命令接口
 */
public interface Command {
    /**
     * 执行命令
     */
    void execute();

    /**
     * 撤销命令
     */
    void undo();
}

空命令 NoCommand

package command;

/**
 * @author ajun
 * Date 2021/7/28
 * @version 1.0
 * 空命令
 * 空执行：用于初始化每个按钮,当调用空命令时，对象什么都不做
 * 这样是一种设计模式,可以省掉对空判断
 */
public class NoCommand implements Command {
    @Override
    public void execute() {

    }

    @Override
    public void undo() {

    }
}

命令发送方(遥控器)RemoteController

package command;

/**
 * @author ajun
 * Date 2021/7/28
 * @version 1.0
 * 遥控器
 * 命令发送者
 */
public class RemoteController {
    // 打开命令集合
    private Command[] onCommands;
    // 关闭命令集合
    private Command[] offCommands;
    // 撤销命令
    private Command unDoCommand;

    /**
     * 构造器
     */
    public RemoteController(){
        onCommands = new Command[5];
        offCommands = new Command[5];
        // 遥控器初始化
        for (int i = 0; i < 5; i++) {
            onCommands[i] = new NoCommand();
            offCommands[i] = new NoCommand();
        }
    }

    /**
     * 给遥控器特定按键设置命令
     * @param no
     * @param onCommand
     * @param offCommand
     */
    public void setCommand(int no,Command onCommand,Command offCommand){
        onCommands[no] = onCommand;
        offCommands[no] = offCommand;
    }

    /**
     * 按下特定 打开 按钮
     * @param no
     */
    public void onButtonWasPushed(int no){
        // 执行打开命令
        onCommands[no].execute();
        // 记录打开命令，用于撤销
        unDoCommand = onCommands[no];
    }

    /**
     * 按下特定 关闭 按钮
     * @param no
     */
    public void offButtonWasPushed(int no){
        // 执行关闭命令
        offCommands[no].execute();
        // 记录关闭命令，用于撤销
        unDoCommand = offCommands[no];
    }

    /**
     * 按下 撤销 按钮
     */
    public void unDoButtonWasPushed(){
        unDoCommand.undo();
    }
}

命令接收方(电灯)Light

package command.light;

/**
 * @author ajun
 * Date 2021/7/28
 * @version 1.0
 * 命令接收者：电灯
 */
public class LightReceiver {
    public void on(){
        System.out.println("电灯打开了");
    }
    public void off(){
        System.out.println("电灯关闭了");
    }
}

package command.light;

import command.Command;

/**
 * @author ajun
 * Date 2021/7/28
 * @version 1.0
 * 开灯命令
 */
public class LightOnCommand implements Command {
    // 电灯接收者(聚合)
    private LightReceiver lightReceiver;

    /**
     * 构造器
     * @param lightReceiver
     */
    public LightOnCommand(LightReceiver lightReceiver) {
        this.lightReceiver = lightReceiver;
    }

    /**
     * 执行开灯命令
     */
    @Override
    public void execute() {
        lightReceiver.on();
    }

    /**
     * 撤销开灯命令
     * 执行开灯的相反命令，即关灯
     */
    @Override
    public void undo() {
        lightReceiver.off();
    }
}

package command.light;

import command.Command;

/**
 * @author ajun
 * Date 2021/7/28
 * @version 1.0
 * 关灯命令
 */
public class LightOffCommand implements Command {
    // 电灯接收者(聚合)
    private LightReceiver lightReceiver;

    /**
     * 构造器
     *
     * @param lightReceiver
     */
    public LightOffCommand(LightReceiver lightReceiver) {
        this.lightReceiver = lightReceiver;
    }

    /**
     * 执行关灯命令
     */
    @Override
    public void execute() {
        lightReceiver.off();
    }

    /**
     * 撤销关灯命令
     * 执行关灯的相反命令，即开灯
     */
    @Override
    public void undo() {
        lightReceiver.on();
    }
}

命令接收方(电视)TV

package command.tv;

/**
 * @author ajun
 * Date 2021/7/28
 * @version 1.0
 * 命令接收者：电视
 */
public class TVReceiver {
    public void on(){
        System.out.println("电视打开了");
    }
    public void off(){
        System.out.println("电视关闭了");
    }
}

package command.tv;

import command.Command;

/**
 * @author ajun
 * Date 2021/7/28
 * @version 1.0
 * 开电视命令
 */
public class TVOnCommand implements Command {
    // 电视接收者(聚合)
    private TVReceiver tvReceiver;

    /**
     * 构造器
     * @param tvReceiver
     */
    public TVOnCommand(TVReceiver tvReceiver) {
        this.tvReceiver = tvReceiver;
    }

    /**
     * 执行打开电视命令
     */
    @Override
    public void execute() {
       tvReceiver.on();
    }

    /**
     * 撤销打开电视命令
     * 执行打开电视的相反命令，即关闭
     */
    @Override
    public void undo() {
        tvReceiver.off();
    }
}

package command.tv;

import command.Command;

/**
 * @author ajun
 * Date 2021/7/28
 * @version 1.0
 */
public class TVOffCommand implements Command {
    // 电视接收者(聚合)
    private TVReceiver tvReceiver;

    /**
     * 构造器
     * @param tvReceiver
     */
    public TVOffCommand(TVReceiver tvReceiver) {
        this.tvReceiver = tvReceiver;
    }

    /**
     * 执行关闭电视命令
     */
    @Override
    public void execute() {
        tvReceiver.off();
    }

    /**
     * 撤销关闭电视命令
     * 执行关闭电视的相反命令，即打开
     */
    @Override
    public void undo() {
        tvReceiver.on();
    }
}

客户 Client

package command;

import command.light.*;
import command.tv.*;

/**
 * @author ajun
 * Date 2021/7/28
 * @version 1.0
 * 客户
 */
public class Client {
    public static void main(String[] args) {
        System.out.println("====操作电灯====");
        // 电灯
        LightReceiver lightReceiver = new LightReceiver();
        // 电灯开命令
        LightOnCommand lightOnCommand = new LightOnCommand(lightReceiver);
        // 电灯关命令
        LightOffCommand lightOffCommand = new LightOffCommand(lightReceiver);

        // 遥控器
        RemoteController remoteController = new RemoteController();

        // 给遥控器设置命令
        remoteController.setCommand(0,lightOnCommand,lightOffCommand);
        // 打开
        remoteController.onButtonWasPushed(0);
        // 关闭
        remoteController.offButtonWasPushed(0);
        // 撤销
        remoteController.unDoButtonWasPushed();

        System.out.println("====操作电视====");

        // 电视
        TVReceiver tvReceiver = new TVReceiver();
        // 电视开命令
        TVOnCommand tvOnCommand = new TVOnCommand(tvReceiver);
        // 电视关命令
        TVOffCommand tvOffCommand = new TVOffCommand(tvReceiver);

        // 给遥控器设置命令
        remoteController.setCommand(1,tvOnCommand,tvOffCommand);
        // 打开
        remoteController.onButtonWasPushed(1);
        // 关闭
        remoteController.offButtonWasPushed(1);
        // 撤销
        remoteController.unDoButtonWasPushed();
    }
}

运行结果

====操作电灯====
电灯打开了
电灯关闭了
电灯打开了
====操作电视====
电视打开了
电视关闭了
电视打开了

4)Spring JdbcTemplate 案例

Spring 框架的 JdbcTemplate 就使用到了命令模式

5)注意事项和细节

将发起请求的对象与执行请求的对象解耦。发起请求的对象是调用者，调用者只要调用命令对象的 execute()方法就可以让接收者工作，而不必知道具体的接收者对象是谁、是如何实现的，命令对象会负责让接收者执行请求的动作，也就是说：”请求发起者”和“请求执行者”之间的解耦是通过命令对象实现的，命令对象起到了纽带桥梁的作用
容易设计一个命令队列。只要把命令对象放到列队，就可以多线程的执行命令
容易实现对请求的撤销和重做
不足：可能导致某些系统有过多的具体命令类，增加了系统的复杂度，使用的时候要注意
空命令也是一种设计模式，为我们省去了判空的操作。在上面的实例中，如果没有用空命令，每按下一个按键都要判空，给编码带来一定的麻烦
经典的应用场景：界面的每一个按钮都是一条命令、模拟 CMD(DOS)订单的撤销/恢复、触发- 反馈机制