设计模式(行为型设计模式——命令模式)

设计模式(行为型设计模式------命令模式)

命令模式

基本定义

将一个请求封装为一个对象,使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通,这样方便将命令对象进行储存、传递、调用、增加与管理。

模式结构

  • Command:抽象命令类
  • ConcreteCommand:具体命令类
  • Invoker:调用者,命令的传递者
  • Receiver:接收者,执行命令功能的相关操作,是具体命令对象业务的真正实现者。
  • Client:客户类

代码实现

Command
java 复制代码
public abstract class Command {
 //需要加载接收者类,将receiver加载
    final static Receiver receiver = new Receiver();
    int memoryValue;

    public abstract int execute(int value);

    //撤销操作
    public abstract int reset();

}
ConcreteCommand 具体命令类
java 复制代码
public class AddCommand extends Command {

    @Override
    public int execute(int value) {
        super.memoryValue = value;
        return super.receiver.add(value);
    }

    @Override
    public int reset() {
        return super.receiver.subtract(memoryValue);
    }
}
java 复制代码
public class MultiCommand extends Command{

    @Override
    public int execute(int value) {
        super.memoryValue = value;
        return this.receiver.multi(value);
    }

    @Override
    public int reset() {
        return receiver.division(super.memoryValue);
    }
}
Invoker 调用者
java 复制代码
@Slf4j
public class Invoker {
    //调用者发送命令, 所以需要将命令类关联进来
    Command command;

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

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

    public void calc(int value){
        int result = command.execute(value);
        log.info("计算操作:执行结果:{} ", result);
    }

    public void cancel(){
        int result = command.reset();
        log.info("撤销操作,执行结果:{}", result);
    }
}
Receiver 接收者
java 复制代码
@Slf4j
public class Receiver {

    private int number;

    public int add(int value){
        log.info("加法 {} + {} ", number, value);
        return number += value;
    }

    public int subtract(int value){
        log.info("减法 {} - {} ", number, value);
        return number -= value;
    }

    public int multi(int value){
        log.info("乘法 {} * {} ", number, value);
        return number *= value;
    }

    public int division(int value){
        log.info("除法 {} / {} ", number, value);
        return number /= value;
    }
}
测试类
java 复制代码
public class Test {

    public static void main(String[] args){
        Command add = new AddCommand();
        Invoker invoker = new Invoker(add);
        invoker.calc(10);
        invoker.calc(20);
        invoker.cancel();

        Command multi = new MultiCommand();
        invoker.setCommand(multi);
        invoker.calc(3);
        invoker.calc(2);
        invoker.cancel();
    }
}
输出结果

CalcReceiver - 加法 0 + 10

CalcInvoker - 计算操作:执行结果:10

CalcReceiver - 加法 10 + 20

CalcInvoker - 计算操作:执行结果:30

CalcReceiver - 减法 30 - 20

CalcInvoker - 撤销操作,执行结果:10

CalcReceiver - 乘法 10 * 3

CalcInvoker - 计算操作:执行结果:30

CalcReceiver - 乘法 30 * 2

CalcInvoker - 计算操作:执行结果:60

CalcReceiver - 除法 60 / 2

CalcInvoker - 撤销操作,执行结果:30

枚举实现

java 复制代码
//抽象命令类
public enum CalcEnum {
    //ConcreteCommand具体命令类
    ADD("加法"){
        @Override
        public int execute(int value) {
            super.memoryValue = value;
            return super.receiver.add(value);
        }

        @Override
        public int reset() {
            //减去记忆数值
            return super.receiver.subtract(super.memoryValue);
        }
    },
    //ConcreteCommand具体命令类
    MULTI("乘法"){
        @Override
        public int execute(int value) {
            super.memoryValue = value;
            return super.receiver.multi(value);
        }

        @Override
        public int reset() {
            return super.receiver.division(super.memoryValue);
        }
    };

    CalcEnum(String name) {
        this.name = name;
    }

    private String name;

    public abstract int execute(int value);
    public abstract int reset();
    int memoryValue;
    final static Receiver receiver = new Receiver();
}
调用者
java 复制代码
@Slf4j
public class CalcInvoker {
    private CalcEnum calcEnum;

    public CalcInvoker(CalcEnum calcEnum) {
        this.calcEnum = calcEnum;
    }

    public void setCalcEnum(CalcEnum calcEnum) {
        this.calcEnum = calcEnum;
    }
    public void calc(int value){
        int result = calcEnum.execute(value);
        log.info("计算操作:执行结果:{} ", result);
    }

    public void cancel(){
        int result = calcEnum.reset();
        log.info("撤销操作,执行结果:{}", result);
    }
}
测试类
java 复制代码
public class CalcTest {

    public static void main(String[] args) {

        CalcInvoker invoker = new CalcInvoker(CalcEnum.ADD);
        invoker.calc(10);
        invoker.calc(20);
        invoker.cancel();

        invoker.setCalcEnum(CalcEnum.MULTI);
        invoker.calc(3);
        invoker.calc(2);
        invoker.cancel();

    }
}
输出结果

加法 0 + 10

计算操作:执行结果:10

加法 10 + 20

计算操作:执行结果:30

减法 30 - 20

撤销操作,执行结果:10

乘法 10 * 3

计算操作:执行结果:30

乘法 30 * 2

计算操作:执行结果:60

除法 60 / 2

撤销操作,执行结果:30

优点

  • 降低系统的耦合度。命令模式能将调用操作的对象与实现该操作的对象解耦。

  • 增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类,它满足"开闭原则",对扩展比较灵活。

  • 可以实现宏命令。命令模式可以与组合模式结合,将多个命令装配成一个组合命令,即宏命令。

  • 方便实现 Undo 和 Redo 操作。命令模式可以备忘录模式结合,实现命令的撤销与恢复。

缺点

可能产生大量具体命令类。因为针对每一个具体操作都需要设计一个具体命令类,这将增加系统的复杂性。

应用场景

  • 当系统需要将请求调用者与请求接收者解耦时,命令模式使得调用者和接收者不直接交互。

  • 当系统需要随机请求命令或经常增加或删除命令时,命令模式比较方便实现这些功能。

  • 当系统需要执行一组操作时,命令模式可以定义宏命令来实现该功能。

  • 当系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作时,可以将命令对象存储起来,采用备忘录模式来实现。

相关推荐
nlog3n2 小时前
Java策略模式详解
java·bash·策略模式
Mryan20055 小时前
解决GraalVM Native Maven Plugin错误:JAVA_HOME未指向GraalVM Distribution
java·开发语言·spring boot·maven
VX_CXsjNo15 小时前
免费送源码:Java+SSM+Android Studio 基于Android Studio游戏搜索app的设计与实现 计算机毕业设计原创定制
java·spring boot·spring·游戏·eclipse·android studio·android-studio
ylfhpy5 小时前
Java面试黄金宝典33
java·开发语言·数据结构·面试·职场和发展·排序算法
乘风!6 小时前
Java导出excel,表格插入pdf附件,以及实现过程中遇见的坑
java·pdf·excel
小小鸭程序员6 小时前
Vue组件化开发深度解析:Element UI与Ant Design Vue对比实践
java·vue.js·spring·ui·elementui
shuaixio6 小时前
【C++代码整洁之道】第九章 设计模式和习惯用法
c++·设计模式·设计原则·常见设计模式·习惯用法
南宫生6 小时前
Java迭代器【设计模式之迭代器模式】
java·学习·设计模式·kotlin·迭代器模式
seabirdssss7 小时前
通过动态获取项目的上下文路径来确保请求的 URL 兼容两种启动方式(IDEA 启动和 Tomcat 部署)下都能正确解析
java·okhttp·tomcat·intellij-idea
程序员小赵同学7 小时前
AI Agent设计模式二:Parallelization
开发语言·python·设计模式