Java設計模式之java命令模式詳解
命令模式的介紹
命令模式是對命令的封裝。命令模式把發出命令的責任和執行命令的責任分割開，委派給不同的對象
每一個命令都是一個操作：請求的一方發出請求要求執行一個操作；接收的一方收到請求，並執行操作。命令模式允許請求的一方和接收的一方獨立開來，使得請求的一方不必知道接收請求的一方的接口，更不必知道請求是怎麼被接收，以及操作是否被執行、何時被執行，以及是怎麼被執行的。
角色
- 客戶端(Client)角色：創建一個具體命令(ConcreteCommand)對象並確定其接收者。
- 命令(Command)角色：聲明瞭一個給所有具體命令類的抽象接口。
- 具體命令(ConcreteCommand)角色：定義一個接收者和行為之間的弱耦合；實現execute()方法，負責調用接收者的相應操作。execute()方法通常叫做執行方法。
- 請求者(Invoker)角色：負責調用命令對象執行請求，相關的方法叫做行動方法。
- 接收者(Receiver)角色：負責具體實施和執行一個請求。任何一個類都可以成為接收者，實施和執行請求的方法叫做行動方法。
訂單案例
代碼演示
將客人點餐的請求封裝為一個請求對象，即訂單類
//將客人點餐的請求封裝為一個請求類
//即訂單類
public class Order
{
//幾號桌點餐
private Integer diningTable;
//當前桌客人點的菜品
private Map<String,Integer> FoodDic=new HashMap<>();
public Integer getDiningTable() {
return diningTable;
}
public void setDiningTable(Integer diningTable) {
this.diningTable = diningTable;
}
public Map<String, Integer> getFoodDic() {
return FoodDic;
}
public void setFoodDic(String foodName,Integer num)
{
FoodDic.put(foodName,num);
}
}
抽象命令類
//抽象命令類
public abstract class Command
{
//執行命令的抽象方法
public abstract void execute();
}
具體命令類—訂單命令
//具體訂單命令
public class OrderCommand extends Command {
//持有接受者對象和訂單對象
private SeniorChef chef;
private Order order;
//通過構造函數為屬性賦值
OrderCommand(SeniorChef seniorChef,Order order)
{
this.chef=seniorChef;
this.order=order;
}
//通過調用接受者對象的方法，來執行命令的具體邏輯行為
@Override
public void execute()
{
System.out.println(order.getDiningTable()+"號桌的訂單");
//遍歷集合: key-->foodName value--->食物點瞭幾份
order.getFoodDic().forEach((key,value)->{
chef.makeFood(key,value);
});
}
}
接收者
//廚師類
public class SeniorChef
{
//制作食物
public void makeFood(String name,Integer num)
{
System.out.println("制作"+name+" "+num+"份");
}
}
請求者
//服務員類----發送請求(命令)者
public class Waitor
{
//命令可能有多個
List<Command> commadns= Lists.newArrayList();
//將命令放入到集合中
public void setCmd(Command cmd)
{
commadns.add(cmd);
}
//發起命令功能
public void OrderUp()
{
System.out.println("訂單來瞭.....");
//遍歷List集合
commadns.forEach(cmd->{
if(cmd!=null)
//命令有效就執行
cmd.execute();
});
}
}
客戶端
//創建訂單對象---請求被包裝成一個類
Order order=new Order();
order.setDiningTable(1);
order.setFoodDic("大雞腿",2);
//創建廚師對象---接收者
SeniorChef chef=new SeniorChef();
//創建命令類--組合接受者和具體請求
Command command=new OrderCommand(chef,order);
//創建服務員---調用者
Waitor waitor=new Waitor();
//將命令組合進去
waitor.setCmd(command);
//執行命令
waitor.OrderUp();
命令模式的優點
命令允許請求的一方和接收請求的一方能夠獨立演化，從而具有以下的優點：
（1）命令模式使新的命令很容易地被加入到系統裡。
（2）允許接收請求的一方決定是否要否決請求。
（3）能較容易地設計一個命令隊列。
（4）可以容易地實現對請求的撤銷和恢復====>可以結合備忘錄模式實現
（5）在需要的情況下，可以較容易地將命令記入日志。
下面以一個示意性的系統，說明命令模式的結構。
命令模式的初衷：對命令請求者（Invoker）和命令實現者（Receiver）的解耦，方便對命令進行各種控制。
適用場景
- 命令的發送者和命令執行者有不同的生命周期。命令發送瞭並不是立即執行。
- 命令需要進行各種管理邏輯。
- 需要支持撤消\重做操作（這種狀況的代碼大傢可以上網搜索下，有很多，這裡不進行詳細解讀）。
示例代碼
接收者角色類
public class Receiver {
/**
* 真正執行命令相應的操作
*/
public void action(){
System.out.println("執行操作");
}
}
抽象命令角色類
public interface Command {
/**
* 執行方法
*/
void execute();
}
具體命令角色類
public class ConcreteCommand implements Command {
//持有相應的接收者對象
private Receiver receiver = null;
/**
* 構造方法
*/
public ConcreteCommand(Receiver receiver){
this.receiver = receiver;
}
@Override
public void execute() {
//通常會轉調接收者對象的相應方法，讓接收者來真正執行功能
receiver.action();
}
}
請求者角色類
public class Invoker {
/**
* 持有命令對象
*/
private Command command = null;
/**
* 構造方法
*/
public Invoker(Command command){
this.command = command;
}
/**
* 行動方法
*/
public void action(){
command.execute();
}
}
客戶端角色類
public class Client {
public static void main(String[] args) {
//創建接收者
Receiver receiver = new Receiver();
//創建命令對象，設定它的接收者
Command command = new ConcreteCommand(receiver);
//創建請求者，把命令對象設置進去
Invoker invoker = new Invoker(command);
//執行方法
invoker.action();
}
}
通過一個command命令類，實現接收者與執行者的解耦操作
應用
宏命令—-執行一組命令
所謂宏命令簡單點說就是包含多個命令的命令，是一個命令的組合。
示例代碼
系統需要一個代表宏命令的接口，以定義出具體宏命令所需要的接口。
public interface MacroCommand extends Command {
/**
* 宏命令聚集的管理方法
* 可以添加一個成員命令
*/
public void add(Command cmd);
/**
* 宏命令聚集的管理方法
* 可以刪除一個成員命令
*/
public void remove(Command cmd);
}
具體的宏命令MacroAudioCommand類負責把個別的命令合成宏命令。
public class MacroAudioCommand implements MacroCommand {
private List<Command> commandList = new ArrayList<Command>();
/**
* 宏命令聚集管理方法
*/
@Override
public void add(Command cmd) {
commandList.add(cmd);
}
/**
* 宏命令聚集管理方法
*/
@Override
public void remove(Command cmd) {
commandList.remove(cmd);
}
/**
* 執行方法
*/
@Override
public void execute() {
for(Command cmd : commandList){
cmd.execute();
}
}
}
客戶端類
public class Julia {
public static void main(String[]args){
//創建接收者對象
AudioPlayer audioPlayer = new AudioPlayer();
//創建命令對象
Command playCommand = new PlayCommand(audioPlayer);
Command rewindCommand = new RewindCommand(audioPlayer);
Command stopCommand = new StopCommand(audioPlayer);
MacroCommand marco = new MacroAudioCommand();
marco.add(playCommand);
marco.add(rewindCommand);
marco.add(stopCommand);
marco.execute();
}
}
總結
更松散的耦合
命令模式使得發起命令的對象——客戶端，和具體實現命令的對象——接收者對象完全解耦，也就是說發起命令的對象完全不知道具體實現對象是誰，也不知道如何實現。
更動態的控制
命令模式把請求封裝起來，可以動態地對它進行參數化、隊列化和日志化等操作，從而使得系統更靈活。
很自然的復合命令
命令模式中的命令對象能夠很容易地組合成復合命令，也就是宏命令，從而使系統操作更簡單，功能更強大。
更好的擴展性
由於發起命令的對象和具體的實現完全解耦，因此擴展新的命令就很容易，隻需要實現新的命令對象，然後在裝配的時候，把具體的實現對象設置到命令對象中，然後就可以使用這個命令對象，已有的實現完全不用變化。
JDK源碼解析 Runable是一個典型命令模式，Runnable擔當命令的角色，Thread充當的是調用者，start方法就是其執行方法
//命令接口(抽象命令角色)
public interface Runnable {
public abstract void run();
}
//調用者
public class Thread implements Runnable {
private Runnable target;
public synchronized void start() {
if (threadStatus != 0)
throw new IllegalThreadStateException();
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
private native void start0();
}
會調用一個native方法start0(),調用系統方法，開啟一個線程。
而接收者是對程序員開放的，可以自己定義接收者。
/**
* jdk Runnable 命令模式
* TurnOffThread ： 屬於具體
*/
public class TurnOffThread implements Runnable{
private Receiver receiver;
public TurnOffThread(Receiver receiver) {
this.receiver = receiver;
}
public void run() {
receiver.turnOFF();
}
**
* 測試類
*/
public class Demo {
public static void main(String[] args) {
Receiver receiver = new Receiver();
TurnOffThread turnOffThread = new TurnOffThread(receiver);
Thread thread = new Thread(turnOffThread);
thread.start();
}
}
總結
本篇文章就到這裡瞭，希望能夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容！