命令模式 rust和java实现

文章目录

- 命令模式
- - 介绍
  - java
  - rust
  - rust仓库

命令模式

命令模式（Command Pattern）是一种数据驱动的设计模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

介绍

意图：将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。
主要解决：在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵御变化的紧耦合的设计就不太合适。
何时使用：当需要先将一个函数登记上，然后再以后调用此函数时，就需要使用命令模式，其实这就是回调函数。
优点：1.类间解耦：调用者角色与接收者角色之间没有任何依赖关系，调用者实现功能时只需调用Command 抽象类的execute方法就可以，不需要了解到底是哪个接收者执行。2.可扩展性：Command的子类可以非常容易地扩展，而调用者Invoker和高层次的模块Client不产生严重的代码耦合。3.命令模式结合其他模式会更优秀：命令模式可以结合责任链模式，实现命令族解析任务；结合模板方法模式，则可以减少 Command子类的膨胀问题。
缺点：命令模式也是有缺点的，请看Command的子类：如果有N个命令，问题就出来了，Command的子类就可不是几个，而是N个，这个类膨胀得非常大，这个就需要读者在项目中慎重考虑使用。

命令模式结构示意图:
在这里插入图片描述

java

我们首先创建作为命令的接口 Order，然后创建作为请求的 Stock 类。实体命令类 BuyStock 和 SellStock，实现了 Order 接口，将执行实际的命令处理。创建作为调用对象的类 Broker，它接受订单并能下订单。

Broker 对象使用命令模式，基于命令的类型确定哪个对象执行哪个命令。CommandPatternDemo 类使用 Broker 类来演示命令模式。

步骤 1
创建一个命令接口。

Order.java

public interface Order {void execute();
}

步骤 2
创建一个请求类。
Stock.java

public class Stock {private String name = "ABC";private int quantity = 10;public void buy(){System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] bought");}public void sell(){System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] sold");}
}

步骤 3
创建实现了 Order 接口的实体类。

BuyStock.java

public class BuyStock implements Order {private Stock abcStock;public BuyStock(Stock abcStock){this.abcStock = abcStock;}public void execute() {abcStock.buy();}
}

SellStock.java

public class SellStock implements Order {private Stock abcStock;public SellStock(Stock abcStock){this.abcStock = abcStock;}public void execute() {abcStock.sell();}
}

步骤 4
创建命令调用类。

Broker.java
import java.util.ArrayList;
import java.util.List;

 public class Broker {private List<Order> orderList = new ArrayList<Order>(); public void takeOrder(Order order){orderList.add(order);      }public void placeOrders(){for (Order order : orderList) {order.execute();}orderList.clear();}
}

步骤 5
使用 Broker 类来接受并执行命令。

CommandPatternDemo.java

public class CommandPatternDemo {public static void main(String[] args) {Stock abcStock = new Stock();BuyStock buyStockOrder = new BuyStock(abcStock);SellStock sellStockOrder = new SellStock(abcStock);Broker broker = new Broker();broker.takeOrder(buyStockOrder);broker.takeOrder(sellStockOrder);broker.placeOrders();}
}

步骤 6
执行程序，输出结果：

Stock [ Name: ABC, Quantity: 10 ] bought
Stock [ Name: ABC, Quantity: 10 ] sold

rust

trait Order {fn execute(&self);
}
#[derive(Clone)]
struct Stock{name:String,quantity:i32,
}
impl Stock {fn buy(&self) {println!("Stock [ Name : {}  Quantity: {}] bought",self.name,self.quantity);}fn sell(&self) {println!("Stock [ Name : {}  Quantity: {}] sold",self.name,self.quantity);}fn new()->Stock{Stock{name:"ABC".to_owned(),quantity:10}}
}
// 创建命令实体
struct  BuyStock {abc_stock:Stock
}
impl Order for BuyStock {fn execute(&self) {self.abc_stock.buy();}
}
struct  SellStock {abc_stock:Stock
}
impl Order for SellStock {fn execute(&self) {self.abc_stock.sell();}
}
// 创建命令调用类。
struct Broker{order_list:Vec<Box<dyn Order>>
}
impl Broker {fn take_order(&mut self,order:impl Order+ 'static){self.order_list.push(Box::new(order));}fn place_orders(&self){self.order_list.iter().for_each(|f|f.execute());}fn  new()->Broker {Broker{order_list:vec![]}}
}
fn main(){let stock=Stock::new();let buy=BuyStock{abc_stock:stock.clone()};let sell=SellStock{abc_stock:stock.clone()};let mut broker=Broker::new();broker.take_order(buy);broker.take_order(sell);broker.place_orders();}