Conteúdo deste artigo
1. Introdução ao Modo de Comando
Padrão de comando (Padrão de comando) é um padrão de design baseado em dados, que é um padrão comportamental. A solicitação é agrupada no objeto na forma de um comando e passada para o objeto de chamada. O objeto de chamada procura um objeto adequado que possa manipular o comando e passa o comando para o objeto correspondente, que executa o comando.
1. Introdução ao Modo de Comando
Intenção: Encapsular uma solicitação em um objeto para que você possa parametrizar clientes com diferentes solicitações.
Solução principal: No sistema de software, o solicitante de comportamento e o implementador de comportamento estão geralmente em um relacionamento fortemente acoplado, mas em alguns casos, como quando o comportamento precisa ser registrado, cancelado ou refeito e as transações são processadas, isso não pode ser resistido Projeto fortemente acoplado variável não é adequado.
Quando usar: em algumas situações, como "gravar, desfazer / refazer, transação" e outro processamento de comportamento, esse tipo de acoplamento estreito que não pode resistir a mudanças é inadequado. Nesse caso, como separar o "solicitante de comportamento" do "implementador de comportamento"? Abstrair um conjunto de comportamentos como objetos pode alcançar um acoplamento fraco entre os dois.
Como resolver: chamar o receptor para executar o comando através do chamador, a ordem é: chamador → comando → receptor.
Código-chave: Defina três funções: 1. Recebeu o objeto de execução de comando real 2. Comando 3. Invoker usa a entrada do objeto de comando
Exemplo de aplicação: Há apenas um controlador de núcleo de ação ActionServlet no struts 1, que é equivalente a Invoker, e as classes da camada de modelo terão classes de modelo diferentes com aplicativos diferentes, que são equivalentes a comandos específicos.
Vantagens: 1. Reduz o grau de acoplamento do sistema. 2. Novos comandos podem ser facilmente adicionados ao sistema.
Desvantagens: Usar o modo de comando pode causar muitas classes de comando específicas em alguns sistemas.
Cenário de uso: o modo de comando pode ser usado sempre que for considerado um comando, como: 1. Cada botão na GUI é um comando. 2. Simule o CMD.
Nota: O sistema precisa suportar a operação de desfazer (Desfazer) e a operação de refazer do comando. Você também pode considerar o uso do modo de comando. Consulte a extensão do modo de comando.
Dois, implementação de código
Os exemplos de implementação de código de todos os padrões de design podem ser visualizados no Code Cloud. Se estiver interessado, você pode conferir. Endereço do Code Cloud: https://gitee.com/no8g/java-design-patterns
2.1 Diagrama Geral de Classes
Neste diagrama de classes, vemos três funções:
Função do receptor: Esta é a função do trabalho.O comando deve ser executado quando é passado para ele.Especificamente, em nosso exemplo acima, existem três classes de implementação de Grupo;
Função de comando: É um comando, todos os comandos que precisam ser executados por mim são declarados aqui;
Função de invocador: o chamador, recebe o comando e executa o comando.No exemplo, meu gerente de projeto é esta função;
O modo de comando é relativamente simples, mas é muito utilizado em projetos, e o encapsulamento é muito bom, pois separa o solicitante (Invoker) do executor (Receiver), e a escalabilidade também é bem garantida. Porém, o modo de comando também tem suas deficiências.Você pode ver se não existem subclasses de Comando.Se eu quiser escrever não algumas, mas dezenas, esse tipo de expansão é muito grande, e isso requer todos no projeto. Considere usá-lo.
2.2 Implementação do código
package com.iot.practice.designpattern.command.commandpattern;
/**
* <p>CommandClient 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 15:45</p>
* <p>@remark：</p>
*/
public class CommandClient {
public static void main(String[] args) {
// 定义我们的接头人
Invoker zhangSan = new Invoker();
// 客户要求增加一项需求
System.out.println("\n-------------客户要求增加一项需求-----------------");
// 客户给我们下命令来
Command command = new AddRequirementCommand();
// 接头人接收到命令
zhangSan.setCommand(command);
// 接头人执行命令
zhangSan.action();
// 客户要求增加一项需求
System.out.println("\n-------------客户要求删除一个页面-----------------");
// 客户给我们下命令来
Command command1 = new DeletePageCommand();
//接头人接收到命令
zhangSan.setCommand(command1);
//接头人执行命令
zhangSan.action();
}
}
package com.iot.practice.designpattern.command.commandpattern;
import com.iot.practice.designpattern.command.CodeGroup;
import com.iot.practice.designpattern.command.PageGroup;
import com.iot.practice.designpattern.command.RequirementGroup;
/**
* <p>Command 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 15:34</p>
* <p>@remark：命令的抽象类，我们把客户发出的命令定义成一个一个的对象</p>
*/
public abstract class Command {
/**
* 把三个组都定义好，子类可以直接使用
*
* 需求组
*/
protected RequirementGroup requirementGroup = new RequirementGroup();
/**
* 美工组
*/
protected PageGroup pageGroup = new PageGroup();
/**
* 代码组
*/
protected CodeGroup codeGroup = new CodeGroup();
/**
* 只要一个方法，你要我做什么事情
*/
public abstract void execute();
}
package com.iot.practice.designpattern.command.commandpattern;
/**
* <p>Invoker 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 15:42</p>
* <p>@remark：接头人的职责就是接收命令，并执行</p>
*/
public class Invoker {
/**
* 什么命令
*/
private Command command;
/**
* 客户发出命令
*/
public void setCommand(Command command) {
this.command = command;
}
/**
* 执行客户的命令
*/
public void action() {
this.command.execute();
}
}
package com.iot.practice.designpattern.command.commandpattern;
/**
* <p>AddRequirementCommand 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 15:38</p>
* <p>@remark：增加一项需求</p>
*/
public class AddRequirementCommand extends Command {
/**
* 执行增加一项需求的命令
*/
@Override
public void execute() {
// 找到需求组
super.requirementGroup.find();
// 增加一份需求
super.requirementGroup.add();
// 给出计划
super.requirementGroup.plan();
}
}
package com.iot.practice.designpattern.command.commandpattern;
/**
* <p>DeleltePageCommand 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 15:41</p>
* <p>@remark：<删除一个页面的命令/p>
*/
public class DeletePageCommand extends Command {
/**
* 执行删除一个页面的命令
*/
@Override
public void execute() {
// 找到页面组
super.pageGroup.find();
// 删除一个页面
super.pageGroup.delete();
// 给出计划
super.pageGroup.plan();
}
}
package com.iot.practice.designpattern.command;
/**
* <p>Group 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 15:11</p>
* <p>@remark：项目组分成了三个组，每个组还是要接受增删改的命令</p>
*/
public abstract class Group {
/**
* 甲乙双方分开办公，你要和那个组讨论，你首先要找到这个组
*/
public abstract void find();
/**
* 被要求增加功能
*/
public abstract void add();
/**
* 被要求删除功能
*/
public abstract void delete();
/**
* 被要求修改功能
*/
public abstract void change();
/**
* 被要求给出所有的变更计划
*/
public abstract void plan();
}
package com.iot.practice.designpattern.command;
/**
* <p>RequirementGroup 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 15:14</p>
* <p>@remark：</p>
*/
public class RequirementGroup extends Group {
@Override
public void find() {
System.out.println("找到需求组...");
}
@Override
public void add() {
System.out.println("客户要求增加一项需求...");
}
@Override
public void delete() {
System.out.println("客户要求删除一项需求...");
}
@Override
public void change() {
System.out.println("客户要求修改一项需求...");
}
@Override
public void plan() {
System.out.println("客户要求需求变更计划...");
}
}
package com.iot.practice.designpattern.command;
/**
* <p>PageGroup 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 15:23</p>
* <p>@remark：美工组的职责是设计出一套漂亮、简单、便捷的界面</p>
*/
public class PageGroup extends Group {
@Override
public void find() {
System.out.println("找到美工组...");
}
@Override
public void add() {
System.out.println("客户要求增加一个页面...");
}
@Override
public void delete() {
System.out.println("客户要求删除一个页面...");
}
@Override
public void change() {
System.out.println("客户要求修改一个页面...");
}
@Override
public void plan() {
System.out.println("客户要求页面变更计划...");
}
}
package com.iot.practice.designpattern.command;
/**
* <p>CodeGroup 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 15:27</p>
* <p>@remark：代码组的职责是实现业务逻辑，当然包括数据库设计了</p>
*/
public class CodeGroup extends Group {
@Override
public void find() {
System.out.println("找到代码组...");
}
@Override
public void add() {
System.out.println("客户要求增加一项功能...");
}
@Override
public void delete() {
System.out.println("客户要求删除一项功能...");
}
@Override
public void change() {
System.out.println("客户要求修改一项功能...");
}
@Override
public void plan() {
System.out.println("客户要求代码变更计划...");
}
}
fim!