AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java设计模式-命令模式

2024-01-23 66
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 命令（Command）模式是指将请求封装成为一个对象，使发出请求和执行请求的责任分割开，方便将命令对象进行存储、传递、调用、增加与管理。也就是将发送者、接收者和调用命令封装成独立的对象，来供客户端调用。属于行为模式的一种。

命令（Command）模式是指将请求封装成为一个对象，使发出请求和执行请求的责任分割开，方便将命令对象进行存储、传递、调用、增加与管理。

也就是将发送者、接收者和调用命令封装成独立的对象，来供客户端调用。属于行为模式的一种。

一、命令模式介绍

命令模式将发送者与接受者完全解耦，发送者与接收者之间没有直接的联系，发送者只需要如何发送请求，而不需要关心请求是如何完成的。下面就来看看命令模式的结构和实现：

1.1 命令模式的结构

将调用者和实现者进行分离，其结构如下所示：

image-20220405200443779

  • Command：抽象命令角色，声明执行命令的接口
  • Command1、Command2：具体命令角色，是抽象命令角色的具体实现类
  • ReceiverA、ReceiverB：具体实现，具体命令对象的真正实现者
  • Invoker：调用者，处理命令、实现命令的具体操作者，负责对外提供命令服务
  • Client：客户端

1.2 命令模式的实现

根据上面的结构图，可以实现如下代码：

/**
 * @description: 抽象命令类
 * @author: wjw
 * @date: 2022/4/5
 */
public interface Command {

    public abstract void execute();
}
/**
 * @description: 命令具体实现类1
 * @author: wjw
 * @date: 2022/4/5
 */
public class Command1 implements Command{

    private ReceiverA receiverA = new ReceiverA();

    @Override
    public void execute() {
        receiverA.action();
    }
}
/**
 * @description: 命令具体实现类2
 * @author: wjw
 * @date: 2022/4/5
 */
public class Command1 implements Command{

    private ReceiverA receiverA = new ReceiverA();

    @Override
    public void execute() {
        receiverA.action();
    }
}
/**
 * @description: 接收者类A
 * @author: wjw
 * @date: 2022/4/5
 */
public class ReceiverA {

    public void action() {
        System.out.println("我是ReceiverA");
    }
}
/**
 * @description: 具体实现者
 * @author: wjw
 * @date: 2022/4/5
 */
public class ReceiverB {

    public void action() {
        System.out.println("我是ReceiverB");
    }
}
/**
 * @description: 命令调用者
 * @author: wjw
 * @date: 2022/4/5
 */
public 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();
    }
}
/**
 * @description: 客户端
 * @author: wjw
 * @date: 2022/4/5
 */
public class Client {

    public static void main(String[] args) {
        Command command1 = new Command1();
        Invoker invoker1 = new Invoker(command1);
        invoker1.call();
    }
}

最后的客户端运行结果为：

调用者执行命令command
我是ReceiverA

下面来看看命令模式的应用场景

二、命令模式的应用场景

2.1 Spring 框架中的 JdbcTemplate

本文选取的Spring版本是5.3.1，来看看JdbcTemplate类中的query()方法：

image-20220405165646955

我们看到，上面的query()方法中定义了一个内部类QueryStatementCallback，并实现了StatementCallback接口，点开查看详细内容：

@FunctionalInterface
public interface StatementCallback<T> {
    //唯一的抽象方法
    @Nullable
    T doInStatement(Statement var1) throws SQLException, DataAccessException;
}

回到query()方法中，我们发现最后返回的execute(new QueryStatementCallback())中是将内部类QueryStatementCallback当做参数进行返回。这里QueryStatementCallback就相当于命令模式中的具体命令对象，而StatementCallback则是抽象命令对象。比如还有其他具体命令实现类，比如BatchUpdateStatementCallback、ExecuteStatementCallback等等：

image-20220405174432889

看看execute()方法，为了方便理解，代码做了精简：

@Nullable
private <T> T execute(StatementCallback<T> action, boolean closeResources) throws DataAccessException {
    Assert.notNull(action, "Callback object must not be null");
    Connection con = DataSourceUtils.getConnection(this.obtainDataSource());
    Statement stmt = null;

    Object var12;
    try {
        stmt = con.createStatement();
        this.applyStatementSettings(stmt);
        //执行doInStatement方法
        T result = action.doInStatement(stmt);
        this.handleWarnings(stmt);
        //赋值为var12
        var12 = result;
    } catch (SQLException var10) {
       //...
    } finally {
      //...
    }
    //最后返回statementCallback对象
    return var12;
}

根据上面的代码，可以梳理整个执行流程：

image-20220405195756378

实际上JdbcTemplate这个类是调用者（Invoker）、实现者（Receiver）和具体命令实现（Concrete Command）的集合， statementCallback则是命令的抽象接口。

三、命令模式实战

模拟在餐厅中点餐交给初始烹饪的场景，在该场景中点餐人员只需要把需要点的各种菜系交给服务员，服务员再把各项菜品交给厨师进行烹饪。如下图所示：

image-20220405205119777

我们先分析一下，命令是菜品具体实现是菜系，命令实现是厨师，调用者是服务员。所以该场景下的命令模式结构应该为：

image-20220405205915202

代码目录结构为：

├─src
│  ├─main
│  │  ├─java
│  │  │  └─cn
│  │  │      └─ethan
│  │  │          └─design
│  │  │              └─command
│  │  │                  │  Waiter.java
│  │  │                  │
│  │  │                  ├─cook
│  │  │                  │  │  ICook.java
│  │  │                  │  │
│  │  │                  │  └─impl
│  │  │                  │          GuangDongCook.java
│  │  │                  │          JiangSuCook.java
│  │  │                  │          ShanDongCook.java
│  │  │                  │          SiChuangCook.java
│  │  │                  │
│  │  │                  └─cuisine
│  │  │                      │  ICuisine.java
│  │  │                      │
│  │  │                      └─impl
│  │  │                              GuangDongCuisine.java
│  │  │                              JiangSuCuisine.java
│  │  │                              ShanDongCuisine.java
│  │  │                              SiChuangCuisine.java
│  │  │
│  │  └─resources
│  └─test
│      └─java
│          └─cn
│              └─ethan
│                  └─disign
│                          ApiTest.java

具体代码如下：

  1. 抽象命令者及其具体实现
/**
 * @description: 抽象命令接口（八大菜系）
 * @author: wjw
 * @date: 2022/4/5
 */
public interface ICuisine {

    /**烹调公共接口*/
    void cook();
}
/**
 * @description: 具体命令实现（广东菜）
 * @author: wjw
 * @date: 2022/4/5
 */
public class GuangDongCuisine implements ICuisine {

    private ICook cook;

    public GuangDongCuisine(ICook cook) {
        this.cook = cook;
    }

    @Override
    public void cook() {
        cook.doCooking();
    }
}
/**
 * @description: 命令具体实现（江苏菜）
 * @author: wjw
 * @date: 2022/4/5
 */
public class JiangSuCuisine implements ICuisine {

    private ICook cook;

    public JiangSuCuisine(ICook cook) {
        this.cook = cook;
    }

    @Override
    public void cook() {
        cook.doCooking();
    }
}
/**
 * @description: 具体命令实现（山东菜）
 * @author: wjw
 * @date: 2022/4/5
 */
public class ShanDongCuisine implements ICuisine {

    private ICook cook;

    public ShanDongCuisine(ICook cook) {
        this.cook = cook;
    }

    @Override
    public void cook() {
        cook.doCooking();
    }
}
/**
 * @description: 具体命令实现（四川菜）
 * @author: wjw
 * @date: 2022/4/5
 */
public class SiChuangCuisine implements ICuisine {

    private ICook cook;

    public SiChuangCuisine(ICook cook) {
        this.cook = cook;
    }

    @Override
    public void cook() {
        cook.doCooking();
    }
}
  1. 抽象实现者及其具体实现
/**
 * @description: 抽象实现者接口
 * @author: wjw
 * @date: 2022/4/5
 */
public interface ICook {

    /**厨师烹调*/
    void doCooking();
}
/**
 * @description: 具体实现者（广东厨师）
 * @author: wjw
 * @date: 2022/4/5
 */
public class GuangDongCook implements ICook {

    private Logger logger = LoggerFactory.getLogger(GuangDongCook.class);

    @Override
    public void doCooking() {
        logger.info("广东厨师，会做广东菜");
    }
}
/**
 * @description: 具体实现类（江苏厨师）
 * @author: wjw
 * @date: 2022/4/5
 */
public class JiangSuCook implements ICook {

    private Logger logger = LoggerFactory.getLogger(JiangSuCook.class);

    @Override
    public void doCooking() {
        logger.info("江苏厨师，会烧江苏菜");
    }
}
/**
 * @description: 具体实现类（山东厨师）
 * @author: wjw
 * @date: 2022/4/5
 */
public class ShanDongCook implements ICook {

    private Logger logger = LoggerFactory.getLogger(ShanDongCook.class);

    @Override
    public void doCooking() {
        logger.info("山东厨师会烧山东菜");
    }
}
/**
 * @description: 具体实现类（四川厨师）
 * @author: wjw
 * @date: 2022/4/5
 */
public class SiChuangCook implements ICook {

    private Logger logger = LoggerFactory.getLogger(SiChuangCook.class);

    @Override
    public void doCooking() {
        logger.info("四川厨师会烧四川菜");
    }
}
  1. 调用者及客户端
/**
 * @description: 调用者(服务员)
 * @author: wjw
 * @date: 2022/4/5
 */
public class Waiter {

    private Logger logger = LoggerFactory.getLogger(Waiter.class);

    private List<ICuisine> cuisineList = new ArrayList<>();

    public void order(ICuisine cuisine) {
        cuisineList.add(cuisine);
    }

    public synchronized void placeOrder() {
        for (ICuisine cuisine : cuisineList) {
            cuisine.cook();
        }
        cuisineList.clear();
    }
}
/**
 * @description: 客户端
 * @author: wjw
 * @date: 2022/4/5
 */
public class ApiTest {

    @Test
    public void test_command() {
        //菜和厨师命令实现
        ICuisine guangDongCuisine = new GuangDongCuisine(new GuangDongCook());
        ICuisine shanDongCuisine = new ShanDongCuisine(new ShanDongCook());
        ICuisine siChuangCuisine = new SiChuangCuisine(new SiChuangCook());
        ICuisine jiangSuCuisine = new JiangSuCuisine(new JiangSuCook());

        //调用者进行点单
        Waiter waiter = new Waiter();
        waiter.order(guangDongCuisine);
        waiter.order(shanDongCuisine);
        waiter.order(siChuangCuisine);
        waiter.order(jiangSuCuisine);

        //下单操作
        waiter.placeOrder();

    }
}

最终测试结果如下：

23:16:40.512 [main] INFO  c.e.d.c.cook.impl.GuangDongCook - 广东厨师，会做广东菜
23:16:40.518 [main] INFO  c.e.d.command.cook.impl.ShanDongCook - 山东厨师会烧山东菜
23:16:40.518 [main] INFO  c.e.d.command.cook.impl.SiChuangCook - 四川厨师会烧四川菜
23:16:40.518 [main] INFO  c.e.d.command.cook.impl.JiangSuCook - 江苏厨师，会烧江苏菜

参考资料

《重学Java设计模式》

文章标签：
Java
设计模式
Spring
存储
关键词：
Java设计模式
Java设计模式命令模式
设计模式命令模式
Java命令模式
归思君
目录
相关文章
进步`于辰
|
23天前
|
设计模式 Java 程序员
[Java]23种设计模式
本文介绍了设计模式的概念及其七大原则，强调了设计模式在提高代码重用性、可读性、可扩展性和可靠性方面的作用。文章还简要概述了23种设计模式，并提供了进一步学习的资源链接。
进步`于辰
36 0
[Java]23种设计模式
大数据文摘
|
7天前
|
设计模式 JavaScript Java
Java设计模式：建造者模式详解
建造者模式是一种创建型设计模式，通过将复杂对象的构建过程与表示分离，使得相同的构建过程可以创建不同的表示。本文详细介绍了建造者模式的原理、背景、应用场景及实际Demo，帮助读者更好地理解和应用这一模式。
大数据文摘
20 0
全干程序员demo
|
1月前
|
设计模式 监控 算法
Java设计模式梳理：行为型模式（策略，观察者等）
本文详细介绍了Java设计模式中的行为型模式，包括策略模式、观察者模式、责任链模式、模板方法模式和状态模式。通过具体示例代码，深入浅出地讲解了每种模式的应用场景与实现方式。例如，策略模式通过定义一系列算法让客户端在运行时选择所需算法；观察者模式则让多个观察者对象同时监听某一个主题对象，实现松耦合的消息传递机制。此外，还探讨了这些模式与实际开发中的联系，帮助读者更好地理解和应用设计模式，提升代码质量。
全干程序员demo
63 0
Java设计模式梳理：行为型模式（策略，观察者等）
艾利克斯冰
|
2月前
|
存储 设计模式 安全
Java设计模式-备忘录模式（23）
Java设计模式-备忘录模式（23）
艾利克斯冰
40 3
艾利克斯冰
|
2月前
|
设计模式 存储 算法
Java设计模式-命令模式（16）
Java设计模式-命令模式（16）
艾利克斯冰
30 2
艾利克斯冰
|
2月前
|
设计模式 存储 缓存
Java设计模式 - 解释器模式（24）
Java设计模式 - 解释器模式（24）
艾利克斯冰
34 1
艾利克斯冰
|
2月前
|
设计模式 安全 Java
Java设计模式-迭代器模式（21）
Java设计模式-迭代器模式（21）
艾利克斯冰
27 1
艾利克斯冰
|
2月前
|
设计模式 缓存 监控
Java设计模式-责任链模式（17）
Java设计模式-责任链模式（17）
艾利克斯冰
52 1
艾利克斯冰
|
2月前
|
设计模式 运维 算法
Java设计模式-策略模式（15）
Java设计模式-策略模式（15）
艾利克斯冰
56 1
艾利克斯冰
|
2月前
|
设计模式 算法 Java
Java设计模式-模板方法模式（14）
Java设计模式-模板方法模式（14）
艾利克斯冰
25 1

热门文章

最新文章

  • 1
    3、Python与设计模式--建造者模式
  • 2
    Android Ap 开发 设计模式第五篇：单件模式
  • 3
    设计模式（九）：Composite组合模式 -- 结构型模式
  • 4
    设计模式--组合模式
  • 5
    极速理解设计模式系列：4.原型模式(Prototype Pattern)
  • 6
    深入浅出单实例Singleton设计模式
  • 7
    设计模式之美：Command（命令）
  • 8
    设计模式[11]-Visitor
  • 9
    云计算设计模式（十九）——运行重构模式
  • 10
    学习设计模式之单例模式
  • 1
    java接口防爬虫
    129
  • 2
    day14：Java零基础-条件运算符
    40
  • 3
    Java并发编程中的锁机制与性能优化
    50
  • 4
    深入理解Java虚拟机：垃圾收集机制的演变与最佳实践
    49
  • 5
    《手把手教你》系列基础篇（九十五）-java+ selenium自动化测试-框架之设计篇-java实现自定义日志输出（详解教程）
    294
  • 6
    Java并发编程之线程池深度解析
    62
  • 7
    Java中的并发编程：从基础到高级
    64
  • 8
    Java并发编程中的线程安全性与性能优化
    55
  • 9
    《手把手教你》系列基础篇（九十四）-java+ selenium自动化测试-框架设计基础-POM设计模式实现-下篇（详解教程）
    46
  • 10
    Spring Boot框架在java领域的优势
    77

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    阿里云OSS设置跨域访问