目录
https://blog.csdn.net/dongganen/article/details/79688794
定义命令模式
将请求封装成对象,这可以让你使用不同的请求、队列,或者日志请求来参数化其它对象。命令模式也可以支持撤销模式。
案例分析
有一家很好吃的饭店,饭店聘用了很多的厨师,每当6点之后会有很多的顾客来吃饭。
逻辑很简单就是:
顾客点餐,厨师做菜。
代码实现
public class Part1 {
public static void main(String[] args) {
Customer customerA = new Customer("小明");
CookA cookA = new CookA("厨师师傅A");
customerA.order("红烧鱼", cookA);
Customer customerb = new Customer("小红");
CookB cookB = new CookB("厨师师傅B");
customerb.order("白斩鸡", cookB);
}
}
class Customer{
String name;
public Customer(String name){
this.name = name;
}
public void order(String orderName, Cook cook){
System.out.println(name + "点了" + orderName + "," + cook.name + "来接单");
cook.cooking(orderName);
}
}
class Cook{
String name;
public void cooking(String orderName){
System.out.println(name + "正在做:" + orderName);
}
}
class CookA extends Cook{
public CookA(String name){
super.name = name;
}
}
class CookB extends Cook{
public CookB(String name){
super.name = name;
}
}
分析
我们聘用了很多的厨师
我们也有不同的客户
在上面例子中,客户和厨师紧耦合了
哪里紧耦合了?
顾客把想吃的菜告诉厨师,厨师按照顾客的需求完成
是不是这样做更合适?
顾客点好菜不需要知道哪个厨师给他做(私人定制除外)
厨师安心做菜,不需要知道谁点的菜(不需要接单)
怎么解耦和?
我们把客户点的菜抽取出来封装成一个对象(订单)
我们再招一个服务员处理这些订单
厨师根据服务员给的订单做菜
UML
代码实现
public class Part2 {
public static void main(String[] args) {
//顾客小明
Customer customer = new Customer("小明");
//小明想吃红烧鱼
CookA cookA = new CookA();
HongShaoYuOrder hongShaoYuOrder = new HongShaoYuOrder(cookA);
//告诉服务员
Waiter waiter = new Waiter();
waiter.setOrder(hongShaoYuOrder);
//服务员提交订单
waiter.commit();
//顾客小红
Customer customerB = new Customer("小红");
//小明想吃红烧鱼
waiter.setOrder(hongShaoYuOrder);
//服务员提交订单
waiter.commit();
}
}
//客户
class Customer{
String name;
public Customer(String name){
this.name = name;
}
}
//订单
interface Order{
//提交订单
void orderUp();
}
//红烧鱼订单
class HongShaoYuOrder implements Order{
CookA cookA;
HongShaoYuOrder(CookA cookA){
this.cookA = cookA;
}
@Override
public void orderUp() {
cookA.cooking("红烧鱼");
}
}
//白斩鸡订单
class BaiZhanJi implements Order{
CookB cookB;
BaiZhanJi(CookB cookB){
this.cookB = cookB;
}
@Override
public void orderUp() {
cookB.cooking("白斩鸡");
}
}
//服务员
class Waiter{
Order order;
public Waiter(){
}
public void setOrder(Order order){
this.order = order;
}
public void commit(){
order.orderUp();
}
}
//厨师
class Cook{
String name;
public void cooking(String orderName){
System.out.println(name + "正在做:" + orderName);
}
}
class CookA extends Cook{
public CookA(){
super.name = "CookA";
}
}
class CookB extends Cook{
public CookB(){
super.name = "CookB";
}
}
分析
客户(顾客)创建命令
将命令交给执行者(服务员)
执行者(服务员)处理命令
接收者(厨师)处理
分析
我们增加撤销功能
服务员不是每次订单都提交
当订单满3个时才提交
点了未提交的可以撤销
有时候我们饭吃饱了,菜还没上,我们就退了
简单逻辑实现
在我们使命令的发出者和命令执行者解耦
我们可以做很多的操作,如记录日志啊等
代码
public class Part3 {
public static void main(String[] args) {
Customer customerA = new Customer("小明");
Customer customerB = new Customer("小红");
Waiter waiter = new Waiter();
CookA cookA = new CookA();
CookB cookB = new CookB();
//先点一个红烧肉
HongShaoYuOrder hongShaoYuOrder = new HongShaoYuOrder(cookA);
waiter.setOrder(hongShaoYuOrder);
waiter.commit();
//再点一个白斩鸡
BaiZhanJi baiZhanJi = new BaiZhanJi(cookB);
waiter.setOrder(baiZhanJi);
waiter.commit();
//再点一个鱼香肉丝
YuXiangRouSi yuXiangRouSi = new YuXiangRouSi(cookB);
waiter.setOrder(yuXiangRouSi);
waiter.commit();
//满三个提交
//再点一个蛋花汤
DanHuaTang danHuaTang = new DanHuaTang(cookB);
waiter.setOrder(danHuaTang);
waiter.commit();
//撤销红烧肉
boolean undo = waiter.undo(hongShaoYuOrder);
System.out.println(undo);
//撤销蛋花汤
boolean undo1 = waiter.undo(danHuaTang);
System.out.println(undo1);
}
}
//客户
class Customer{
String name;
public Customer(String name){
this.name = name;
}
}
//订单
interface Order{
//提交订单
void orderUp();
}
//红烧鱼订单
class HongShaoYuOrder implements Order{
CookA cookA;
HongShaoYuOrder(CookA cookA){
this.cookA = cookA;
}
@Override
public void orderUp() {
cookA.cooking("红烧鱼");
}
}
//白斩鸡订单
class BaiZhanJi implements Order{
CookB cookB;
BaiZhanJi(CookB cookB){
this.cookB = cookB;
}
@Override
public void orderUp() {
cookB.cooking("白斩鸡");
}
}
//鱼香肉丝订单
class YuXiangRouSi implements Order{
CookB cookB;
YuXiangRouSi(CookB cookB){
this.cookB = cookB;
}
@Override
public void orderUp() {
cookB.cooking("鱼香肉丝");
}
}
//蛋花汤订单
class DanHuaTang implements Order{
CookB cookB;
DanHuaTang(CookB cookB){
this.cookB = cookB;
}
@Override
public void orderUp() {
cookB.cooking("蛋花汤");
}
}
//服务员
class Waiter{
List<Order> orders;
public Waiter(){
orders = new ArrayList<>();
}
public void setOrder(Order order){
orders.add(order);
}
public void commit(){
if(orders.size() >= 3){
orders.stream().forEach(e -> e.orderUp());
orders.clear();
}
}
public boolean undo(Order order){
boolean b = false;
int index = orders.indexOf(order);
if(index >= 0){
orders.remove(index);
b = true;
}
return b;
}
}
//厨师
class Cook{
String name;
public void cooking(String orderName){
System.out.println(name + "正在做:" + orderName);
}
}
class CookA extends Cook{
public CookA(){
super.name = "CookA";
}
}
class CookB extends Cook{
public CookB(){
super.name = "CookB";
}
}