设计模式-12-命令模式

简介:以对象来代表实际行动,命令对象可以把行动(action) 及其参数封装起来,这些行动可以被

  • 重复多次
  • 取消(如果该对象有实现的话)
  • 取消后又再重做

目的:

总结:

组成:对象,行动
1,对象

package com.design.l.command;
/**
 * 程序设计员
 */
public class Programmer {

    private String userName;
    public Programmer(String userName) {
        super();
        this.userName = userName;
    }

    public void handleDemand(){
        System.out.println("程序员 : " + userName + " ,正在处理新需求 ... ...");
    }
    public void handleBug(){
        System.out.println("程序员 : " + userName + " ,正在处理Bug ... ...");
    }
    public void handleProblem(){
        System.out.println("程序员 : " + userName + " ,正在处理线上问题 ... ...");
    }

    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
}
package com.design.l.command;

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

/**
 * 产品经理
 */
public class ProductManager {

    //任务集合
    private List<TaskService> taskList;
    //程序员
    private List<Programmer> programmerList;
    private static final int TASK_MAX_NUM = 4;//任务最大数量
    private int idx = 0;

    public ProductManager(Programmer ... programmers) {
        super();
        this.taskList = new ArrayList<>();
        this.programmerList = Arrays.asList(programmers);
    }

    //新增任务
    public void addTaskToProduct(TaskService taskService){
        taskList.add(taskService);
    }

    //分配任务
    public void assignments(){
        TaskService[] copy = new TaskService[taskList.size() > TASK_MAX_NUM ? taskList.size() - TASK_MAX_NUM : 0];
        for ( int i = 0; i < TASK_MAX_NUM && i < taskList.size(); i ++){
            taskList.get(i).handle();
        }

        System.arraycopy(taskList.toArray(), TASK_MAX_NUM > taskList.size() ? taskList.size() : TASK_MAX_NUM, copy, 0, copy.length);
        taskList = Arrays.asList(copy);
    }

    //获取程序员
    public Programmer chooseProgrammer(){
        return programmerList.get(idx == programmerList.size() ? 0 : idx ++);
    }

    //打印出未处理的任务
    public void printTask(){
        if(taskList == null || taskList.size() == 0){
            System.out.println("----无任务----");
            return ;
        }

        System.out.println("----剩余任务----");
        for(TaskService task : taskList){
            System.out.println(task);
        }
    }

}
package com.design.l.command;
/**
 * 销售人员
 */
public class Sales {

    private String userName;
    private ProductManager productManager;//产品经理

    public Sales(String userName) {
        super();
        this.userName = userName;
    }
    public Sales(String userName, ProductManager productManager) {
        super();
        this.userName = userName;
        this.productManager = productManager;
    }

    public void putDemand(){
        System.out.println("业务员 : " + userName + ", 提出新需求  ... ... ");
        productManager.addTaskToProduct(new DemandTaskServiceImpl(productManager.chooseProgrammer()));
    }
    public void putBug(){
        System.out.println("业务员 : " + userName + ", 提出新Bug  ... ... ");
        productManager.addTaskToProduct(new BugTaskServiceImpl(productManager.chooseProgrammer()));
    }
    public void putProblem(){
        System.out.println("业务员 : " + userName + ", 提出线上问题     ... ... ");
        productManager.addTaskToProduct(new ProblemTaskServiceImpl(productManager.chooseProgrammer()));
    }

    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public ProductManager getProductManager() {
        return productManager;
    }
    public void setProductManager(ProductManager productManager) {
        this.productManager = productManager;
    }

}

2,行为

package com.design.l.command;
/**
 * 任务接口
 */
public interface TaskService {

    /**
     * 任务处理方法
     */
    void handle();
}
package com.design.l.command;
/**
 * 新需求任务
 */
public class DemandTaskServiceImpl implements TaskService {

    private Programmer programmer;
    public DemandTaskServiceImpl(Programmer programmer) {
        super();
        this.programmer = programmer;
    }

    @Override
    public void handle() {
        programmer.handleDemand();
    }

}
package com.design.l.command;
/**
 * Bug任务
 */
public class BugTaskServiceImpl implements TaskService {

    private Programmer programmer;
    public BugTaskServiceImpl(Programmer programmer) {
        super();
        this.programmer = programmer;
    }

    @Override
    public void handle() {
        programmer.handleBug();
    }

}
package com.design.l.command;
/**
 * 线上问题任务
 */
public class ProblemTaskServiceImpl implements TaskService {

    private Programmer programmer;
    public ProblemTaskServiceImpl(Programmer programmer) {
        super();
        this.programmer = programmer;
    }

    @Override
    public void handle() {
        programmer.handleProblem();
    }

}

3,Main

package com.design.l.command;
/**
 * 12-命令模式
 */
public class MainTest {

    public static void main(String[] args) {

        Programmer programmerA = new Programmer("程序员A");
        ProductManager productManager = new ProductManager(programmerA);
        Sales salesA = new Sales("业务员A", productManager);
        Sales salesB = new Sales("业务员B", productManager);
        Sales salesC = new Sales("业务员C", productManager);
        Sales salesD = new Sales("业务员D", productManager);

        salesA.putDemand();
        salesA.putBug();
        salesB.putProblem();
        salesC.putBug();
        salesD.putProblem();

        productManager.assignments();
        productManager.printTask();

        productManager.assignments();
        productManager.printTask();
    }

}

4,Result

业务员 : 业务员A, 提出新需求  ... ...
业务员 : 业务员A, 提出新Bug  ... ...
业务员 : 业务员B, 提出线上问题     ... ...
业务员 : 业务员C, 提出新Bug  ... ...
业务员 : 业务员D, 提出线上问题     ... ...
程序员 : 程序员A ,正在处理新需求 ... ...
程序员 : 程序员A ,正在处理Bug ... ...
程序员 : 程序员A ,正在处理线上问题 ... ...
程序员 : 程序员A ,正在处理Bug ... ...
----剩余任务----
[email protected]
程序员 : 程序员A ,正在处理线上问题 ... ...
----无任务----
时间: 2024-08-09 06:34:31

设计模式-12-命令模式的相关文章

设计模式之命令模式

命令模式的核心是把方法调用封装起来,调用的对象不需要关心是如何执行的. 定义:命令模式将"请求"封装成对象,以便使用不同的请求.队列或者日志来参数化其他对象.命令模式也可以支持撤销操作. 先看一个例子,设计一个家电遥控器的API,可以通过遥控器发出命令来控制不同生产商生产的家电,比如关灯.开灯. 以下是一个简单的代码示例. 1 package cn.sp.test05; 2 /** 3 * 电灯类 4 * @author 2YSP 5 * 6 */ 7 public class Lig

设计模式之命令模式20170719

行为型设计模式之命令模式: 一.含义 将请求(命令)封装成一个对象(内部有接收者对象,以及按照具体命令执行接收者操作的方法),传递给调用者,由调用者执行具体命令. 也就是把一个动作的执行分为执行对象(接收者角色).执行行为(命令角色),让两者相互独立而不相互影响,实现对动作解耦 二.代码说明 1.主要有三个角色 1)接收者角色 该角色就是干活的角色,被命令角色调用,其操作按具体命令的要求执行 2)命令角色 需要执行的所有命令都在这里声明,同时接收者所有的对象都在这里(接收者封装在这里,防止高层模

设计模式 7 —— 命令模式

设计模式目录: 设计模式 1 ——观察者模式 设计模式 2 —— 装饰者模式 设计模式 3 —— 迭代器和组合模式(迭代器) 设计模式 4 —— 迭代器和组合模式(组合) 设计模式 5 —— 工厂模式 设计模式 6 —— 单件模式 设计模式 7 —— 命令模式 概述 第1部分 问题引入 第2部分 定义和实现 第3部分 使用宏命令 第1部分 问题引入 首先看下,下面的要求: 实现命令接口 首先,让说有的命令对象实现相同的包含一个方法的接口. 1 /** 2 * 命令接口 3 * @ClassNam

C#设计模式(15)——命令模式(Command Pattern)

原文:C#设计模式(15)--命令模式(Command Pattern) 一.前言 之前一直在忙于工作上的事情,关于设计模式系列一直没更新,最近项目中发现,对于设计模式的了解是必不可少的,当然对于设计模式的应用那更是重要,可以说是否懂得应用设计模式在项目中是衡量一个程序员的技术水平,因为对于一个功能的实现,高级工程师和初级工程师一样都会实现,但是区别在于它们实现功能的可扩展和可维护性,也就是代码的是否“优美”.可读.但是,要更好地应用,首先就必须了解各种设计模式和其应用场景,所以我还是希望继续完

跟我学设计模式视频教程——命令模式vs策略模式,唠嗑

课程视频 命令模式vs策略模式 唠嗑 课程笔记 课程笔记 课程代码 课程代码 新课程火热报名中 课程介绍 跟我学设计模式视频教程--命令模式vs策略模式,唠嗑,布布扣,bubuko.com

用Java 8 Lambda表达式实现设计模式:命令模式

链接:http://www.importnew.com/16789.html 在这篇博客里,我将说明如何在使用Java 8 Lambda表达式的函数式编程方式时实现命令设计模式.命令模式的目标是将请求封装成一个对象,从对客户端的不同类型请求,例如队列或日志请求参数化,并提供相应的操作.命令模式是一种通用编程方式,该方式基于运行时决策顺序来执行方法.模式的参与者如下: 命令 :声明用于执行操作的接口. 实体命令 :定义接收者对象和动作的绑定. 客户端 :创建实体命令实例并设置它的接收者. 调用者:

设计模式 ( 十三 ) 命令模式Command(对象行为型)

设计模式 ( 十三 ) 命令模式Command(对象行为型) 1.概述 在软件设计中,我们经常需要向某些对象发送请求,但是并不知道请求的接收者是谁,也不知道被请求的操作是哪个,我们只需在程序运行时指定具体的请求接收者即可,此时,可以使用命令模式来进行设计,使得请求发送者与请求接收者消除彼此之间的耦合,让对象之间的调用关系更加灵活. 例子1:电视机遥控器 : 遥控器是请求的发送者,电视机是请求的接收者,遥控器上有一些按钮如开,关,换频道等按钮就是具体命令,不同的按钮对应电视机的不同操作. 2.问题

设计模式(6)--命令模式

关键词 :空对象 有人称为设计模式 三层调用 1. 封装调用  , 把封装带到一个全新的境界: 把方法调用(method invocation) 封装起来. 2. 命令模式可将"动作的请求者" 从"动作的执行者" 对象中解耦. 3. 当需要将发出的请求和执行请求的对象解耦的时候,使用命令模式. OO原则: (1)封装变化 (2) 多用组合,少用继承 (3)针对接口编程,不针对实现编程 (4)为交互对象之间松耦合设计而努力 (5) 类应该对扩展开放,对修改关闭 (6)

每天一个设计模式之命令模式

作者按:<每天一个设计模式>旨在初步领会设计模式的精髓,目前采用javascript和python两种语言实现.诚然,每种设计模式都有多种实现方式,但此小册只记录最直截了当的实现方式 :) 原文地址是:<每天一个设计模式之命令模式> 欢迎关注个人技术博客:godbmw.com.每周 1 篇原创技术分享!开源教程(webpack.设计模式).面试刷题(偏前端).知识整理(每周零碎),欢迎长期关注! 如果您也想进行知识整理 + 搭建功能完善/设计简约/快速启动的个人博客,请直接戳the

理解设计模式之----命令模式

零零碎碎的了解过部分设计模式,但没有系统的学习过,最近晚上有点时间,就买了本程杰的<大话设计模式>,最近想系统的学习下.当看到命令模式的时候,感觉并不是太好理解,于是上网搜索了些资料.发现对设计模式的看法多少很多文章都有些不一样,于是想写下自己对命令模式的一些看法,以加深理解.要是文章有不对的地方,希望大家能提出改进建议. 目的: 任何模式的出现,都是为了解决一些特定的场景的耦合问题,以达到对修改封闭,对扩展开放的效果.命令模式也不例外: 命令模式是为了解决命令的请求者和命令的实现者之间的耦合