蘇阿細 - 设计模式
type: channel
link: https://km.wangchouchou.com/category/software-design-patterns/
description: software design patterns
items: 自定义 spring-context Demo
items: 行为型模式-解释器模式
items: 行为型模式-备忘录模式
items: 行为型模式-访问者模式
items: 行为型模式-迭代器模式
items: 行为型模式-中介者模式
items: 行为型模式-观察者模式
items: 行为型模式-状态模式
items: 行为型模式-责任链模式
items: 行为型模式-命令模式

自定义 spring-context Demo
type: item
date: 2022-09-28T13:37:00+00:00
description: applicationContext.xml<?xml version="1.0" encoding="UTF-8"?> <beans> <bean id="userMapper" class="com.spring.mapper.impl.UserMapperImpl"> <property name="name" value="孙笑川"/> <property name="password" value="123456"/> </bean> <bean id="userService" class="com.spring.service.impl.UserServiceImpl"> <property name="userMapper" ref="userMapper"/> </bean> </beans>1. pojo（1）PropertyValue类用于封装bean的属性public class PropertyValue { /** * name */ private String name; /** * ref */ private String ref; /** * value:给基本数据类型及String类型赋的值 */ private String value; public PropertyValue() { } public PropertyValue(String name, String ref, String value) { this.name = name; this.ref = ref; this.value = value; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getRef() { return ref; } public void setRef(String ref) { this.ref = ref; } public String getValue() { return value; } public void setValue(String value) { this.value = value; } }（2）MutablePropertyValues类一个bean标签可以有多个 property 子标签，该类用于存储并管理多个 Propertyvalue 对象public class MutablePropertyValues implements Iterable<PropertyValue> { private final List<PropertyValue> propertyValueList; public MutablePropertyValues() { this.propertyValueList = new ArrayList<>(); } public MutablePropertyValues(List<PropertyValue> propertyValueList) { if (propertyValueList == null) { this.propertyValueList = new ArrayList<>(); } else { this.propertyValueList = propertyValueList; } } /** * 获取PropertyValue数组 * * @return */ public PropertyValue[] getPropertyValues() { return propertyValueList.toArray(new PropertyValue[0]); } /** * 根据名称获取PropertyValue对象 * * @param propertyName * @return */ public PropertyValue getPropertyValueByName(String propertyName) { for (PropertyValue propertyValue : propertyValueList) { if (propertyValue.getName().equals(propertyValue)) { return propertyValue; } } return null; } /** * 判断集合是否为空 * * @return */ public boolean isEmpty() { return propertyValueList.isEmpty(); } /** * 添加 *…

行为型模式-解释器模式
type: item
date: 2022-09-25T02:36:00+00:00
description: （1）概述定义一个语言，定义它的文法表示，并定义一个解释器，根据文法规则来解释语言中的句子文法（语法）规则：用于描述语言的语法结构的形式规则# 例： expression ::= value | plus | minus # ::= 表示定义为 plus ::= expression '+' expression minus ::= expression '-' expression value ::= integer # 表达式可以是一个值，也可以是plus、minus运算， 而plus、minus又由表达式结合运算符构成，值的类型为整数抽象语法树在计算机科学中，抽象语法树（AbstractSyntaxTree，ATS）简称语法树（Syntax Tree），是源代码语法的一种抽象表示，它以树状的形式表现编程语言的语法结构，树上的每个节点都表示源代码中的一种结构。如：1 + 2 + 3 - 4（2）结构抽象表达式：定义解释器的接口，约定解释器的解释操作，主要包含解释方法 interpret()终结符表达式：抽象表达式的子类，实现文法与终结符相关的操作，文法中的每一个终结符都有与之对应的具体终结表达式非终结符表达式：抽象表达式的子类，实现文法与非终结符相关的操作，文法中的每条规则都对应一个非终结符表达式环境角色：包含各个解释器需要的数据或公共功能，用来传递被所有解释器共享的数据，后面的解释器可以从该角色获取相应的数据客户端：将需要分析的句子或表达式转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，同时也可以通过环境角色间接访问解释器的解释方法（3）案例以加减运算为例抽象表达式public abstract class AbstractExpression { /** * 解释（解析） * * @param context 环境变量 * @return */ public abstract int interpret(Context context); }非终结符表达式public class Minus extends AbstractExpression { //减号左边的表达式 private AbstractExpression left; //减号右边的表达式 private AbstractExpression right; public Minus(AbstractExpression left, AbstractExpression right) { this.left = left; this.right = right; } @Override public int interpret(Context context) { return left.interpret(context) - right.interpret(context); } @Override public String toString() { return "(" + left.toString() + " - " + right.toString() + ")"; } } public class Plus extends AbstractExpression { //加号左边的表达式 private AbstractExpression left; //加号右边的表达式 private AbstractExpression right; public Plus(AbstractExpression left, AbstractExpression right) { this.left = left; this.right = right; } @Override public int interpret(Context context) { return left.interpret(context) + right.interpret(context); } @Override public String toString() { return "(" + left.toString() + " + " + right.toString() + ")"; } }终结符表达式public class Variable extends AbstractExpression { //变量名 private String name; public Variable(String name) { this.name = name; } @Override public int interpret(Context context) { //直接返回变量值 return context.getVariable(this); } @O…

行为型模式-备忘录模式
type: item
date: 2022-09-25T02:29:00+00:00
description: （1）概述备忘录模式又叫快照模式，在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便需要时能将该对象恢复到之前保存的状态（2）结构发起人角色：记录当前时刻的内部状态信息，提供创建备忘录和恢复备忘录的功能，它可以访问备忘录里的所有信息备忘录角色：负责存储发起人的内部状态，在需要的时候提供这些内部状态给发起人管理者角色：对备忘录进行管理，提供保存与获取备忘录的功能，但其不能对备忘录没有读写权限备忘录有两个等效接口：窄接口：管理者对象（和其他除发起人对象之外的任何对象），看到的是窄接口，该接口只允许把备忘录对象传递给其他对象宽接口：发起人对象可以看到宽接口，该接口允许读取所有的数据，以便恢复对象之前的内部状态（3）案例以游戏存档为例：“白箱”备忘录备忘录角色对任何对象都提供宽接口（破坏了封装性）发起人角色public class GameRole { /** * 生命值 */ private int vit; /** * 攻击值 */ private int atk; /** * 防御值 */ private int def; public int getVit() { return vit; } public void setVit(int vit) { this.vit = vit; } public int getAtk() { return atk; } public void setAtk(int atk) { this.atk = atk; } public int getDef() { return def; } public void setDef(int def) { this.def = def; } /** * 初始化内部状态 */ public void initState() { this.vit = 100; this.atk = 100; this.def = 100; } /** * 战斗 */ public void fight() { this.vit = 0; this.atk = 0; this.def = 0; } /** * 保存游戏角色状态 * * @return */ public RoleStateMemento saveState() { return new RoleStateMemento(vit, atk, def); } /** * 恢复角色状态 * * @param roleStateMemento */ public void recoverState(RoleStateMemento roleStateMemento) { this.vit = roleStateMemento.getVit(); this.atk = roleStateMemento.getAtk(); this.def = roleStateMemento.getDef(); } /** * 展示角色状态 */ public void displayState() { System.out.println("生命值：" + vit); System.out.println("攻击值：" + vit); System.out.println("防御值：" + vit); } }备忘录角色public class RoleStateMemento { /** * 生命值 */ private int vit; /** * 攻击值 */ private int atk; /** * 防御值 */ private int def; public RoleStateMemento() { } public RoleStateMemento(int vit, int atk, int def) { this.vit = vit; this.atk = atk; this.def = def; } public int getVit() { return vit; } public void setVit(int vit) { this.vit = vit; } public int getAtk() { return atk; } public void setAtk(int atk) { this.atk = atk; } public int getDef() { return def; } public void setDef(int def) { this.def = def; } }备忘录管理者public class RoleStateCaretaker { private RoleStateMemento roleStateMemento; public RoleS…

行为型模式-访问者模式
type: item
date: 2022-09-25T02:24:00+00:00
description: （1）概述封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作（2）结构抽象访问者角色：定义对每一个元素访问的行为，它的参数就是可以访问的元素（它的方法个数理论上来说与元素个数相等）具体访问者角色：给出对每一个元素类访问时所产生的具体行为抽象元素角色：定义接受访问者的方法（即每一个元素都可以被访问者访问）具体元素角色：提供接受访问方法的具体实现，而这个具体的实现，通常情况下是使用访问者提供的访问该元素类的方法对象结构角色：一个具有容器性质或复合对象特性的类，它含有一组元素，且可以迭代这些元素，供访问者访问（3）案例以宠物喂食为例访问者角色：给宠物喂食的人具体访问者角色：宠物主人、其他人等抽象元素角色：动物抽象类具体元素角色：宠物狗、宠物猫结构对象角色：主人家抽象访问者角色public interface Person { /** * 喂猫 * * @param cat 猫 */ void feed(Cat cat); /** * 喂狗 * * @param dog 狗 */ void feed(Dog dog); }具体访问者public class Owner implements Person { @Override public void feed(Cat cat) { System.out.println("主人喂猫"); } @Override public void feed(Dog dog) { System.out.println("主人喂狗"); } } public class Someone implements Person { @Override public void feed(Cat cat) { System.out.println("客人喂猫"); } @Override public void feed(Dog dog) { System.out.println("客人喂狗"); } }抽象元素角色public interface Animal { /** * 接受访问者访问 * * @param person 访问者 */ void accept(Person person); }具体元素角色public class Dog implements Animal { @Override public void accept(Person person) { person.feed(this); System.out.println("喂狗吃狗粮"); } } public class Cat implements Animal { @Override public void accept(Person person) { person.feed(this); System.out.println("喂猫吃猫粮"); } }结构对象角色public class Home { private List<Animal> nodeList = new ArrayList<>(); void add(Animal animal) { nodeList.add(animal); } void action(Person person) { //访问者访问每一个元素 for (Animal animal : nodeList) { animal.accept(person); } } }Clientpublic class Client { public static void main(String[] args) { //创建Home Home home = new Home(); //添加元素 home.add(new Dog()); home.add(new Cat()); //创建主人对象 Owner owner = new Owner(); //主人喂宠物 home.action(owner); } }（4）优缺点扩展性好：在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能复用性好：通过访问者来定义整个对象结构的通用的功能，从而提高代码复用分离无关行为：通过访问者来分离无关的行为，把相关的行为封装在一起，构成一个访问者，使得每一个访问者的功能都比较单一对象结构变化困难：每增加一个新的元素类，都要在每一个具体访问者中增加相应的具体操作，违背了开闭原则违反了依赖倒置原则：访问者依赖具体类，而不依赖抽象类（5）使用场景对象结构稳定，但其操作算法经常变更时对象结构中对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构时（6）扩展访问者模式使用了双分派技术1. 分派变量被声明时的类型叫做变量的静态类型，变量所引用…

行为型模式-迭代器模式
type: item
date: 2022-09-19T15:18:00+00:00
description: （1）概述提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露内部对象的表示（2）结构抽象聚合角色：定义存储、添加、删除聚合元素以及创建迭代器对象的接口具体聚合角色：实现抽象聚合类，返回一个具体迭代器的实例抽象迭代器角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、next() 等方法具体迭代器角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置（3）案例以遍历学生对象集合为例抽象聚合角色public interface StudentAggregate { /** * 添加元素 * * @param student */ void add(Student student); /** * 移除元素 * * @param student */ void remove(Student student); /** * 获取迭代器 * * @return */ StudentIterator getStudentIterator(); }具体聚合角色public class StudentAggregateImpl implements StudentAggregate { private List<Student> list = new ArrayList<>(); @Override public void add(Student student) { list.add(student); } @Override public void remove(Student student) { list.remove(student); } @Override public StudentIterator getStudentIterator() { return new StudentIteratorImpl(list); } }抽象迭代器角色public interface StudentIterator { /** * 判断是否还有元素 * * @return */ boolean hasNext(); /** * 获取下一个元素 * * @return */ Student next(); }具体迭代器角色public class StudentIteratorImpl implements StudentIterator { private List<Student> list; //记录遍历时的位置 private int position = 0; public StudentIteratorImpl(List<Student> list) { this.list = list; } @Override public boolean hasNext() { return position < list.size(); } @Override public Student next() { Student currentStudent = list.get(position); position++; return currentStudent; } }Clientpublic class Client { public static void main(String[] args) { //创建聚合对象 StudentAggregateImpl studentAggregate = new StudentAggregateImpl(); //添加元素 studentAggregate.add(new Student("孙笑川", "001")); studentAggregate.add(new Student("药水哥", "002")); studentAggregate.add(new Student("刘波", "003")); //获取迭代器对象 StudentIterator iterator = studentAggregate.getStudentIterator(); //遍历 while (iterator.hasNext()) { System.out.println(iterator.next()); } } }（4）优缺点支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式，在迭代器模式中只需要用一个不同的迭代器来替换原有的迭代器即可改变遍历算法简化了聚合类，在原有的聚合类中不需要再自行提供遍历等方法由于引入了抽象层，新增新的聚合类和迭代器类都很方便，满足开闭原则（5）使用场景当需要为聚合对象提供多种遍历方式时当需要为遍历不同的聚合结构提供一个统一的接口时当需要访问一个聚合对象的内容而无需暴露其内部细节时

行为型模式-中介者模式
type: item
date: 2022-09-19T15:15:00+00:00
description: （1）概述中介者模式又称调停模式，定义一个中介者角色来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立的改变它们之间的交互（2）结构抽象中介者：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法具体中介者：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事对象之间的交互关系，须依赖于同事对象抽象同事类：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能具体同事类：实现抽象同事类接口，当需要与其他同事对象交互时，由中介者对象负责后续的交互（3）案例以租房为例抽象中介者public abstract class Mediator { /** * 交流 * * @param message 信息 * @param person 抽象同事类 */ public abstract void contact(String message, Person person); }具体中介者public class MediatorStructure extends Mediator { //聚合房东、租房者 private HouseOwner houseOwner; private Tenant tenant; public HouseOwner getHouseOwner() { return houseOwner; } public void setHouseOwner(HouseOwner houseOwner) { this.houseOwner = houseOwner; } public Tenant getTenant() { return tenant; } public void setTenant(Tenant tenant) { this.tenant = tenant; } @Override public void contact(String message, Person person) { if (person == houseOwner) { tenant.getMessage(message); } else { houseOwner.getMessage(message); } } }抽象同事类public abstract class Person { protected String name; protected Mediator mediator; public Person(String name, Mediator mediator) { this.name = name; this.mediator = mediator; } }具体同事类public class HouseOwner extends Person { public HouseOwner(String name, Mediator mediator) { super(name, mediator); } /** * 与中介沟通 * * @param message 信息 */ public void contact(String message) { mediator.contact(message, this); } /** * 获取信息 * * @param message 信息 */ public void getMessage(String message) { System.out.println("房东获取到的信息：" + message); } } public class Tenant extends Person { public Tenant(String name, Mediator mediator) { super(name, mediator); } /** * 与中介沟通 * * @param message 信息 */ public void contact(String message) { mediator.contact(message, this); } /** * 获取信息 * * @param message 信息 */ public void getMessage(String message) { System.out.println("租房者获取到的信息：" + message); } }Clientpublic class Client { public static void main(String[] args) { //创建中介者 MediatorStructure mediatorStructure = new MediatorStructure(); //租房者 Tenant …

行为型模式-观察者模式
type: item
date: 2022-09-19T15:11:00+00:00
description: （1）概述观察者模式又称发布 - 订阅模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态变化时，会通知所有的观察者对象，使它们能够自动更新自己（2）结构抽象主题（抽象被观察者）：抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加/删除观察者对象具体主题（具体被观察者）：该角色将有关状态存入具体观察者对象，在具体主题的内部发生改变时，给所有注册过的观察者发送通知抽象观察者：它定义了一个更新接口，使得在得到主题更改时通知更新自己具体观察者：实现抽象观察者定义的更新接口，以便在得到主题更改时通知更新自身的状态（3）案例以订阅公众号为例抽象主题角色public interface Subject { /** * 添加观察者对象（订阅者） * @param observer 观察者对象 */ void attach(Observer observer); /** * 删除观察者对象（订阅者） * @param observer 观察者对象 */ void detach(Observer observer); /** * 通志观察者（订阅者）更新消息 * @param message 消息 */ void notify(String message); }具体主题角色public class SubscriptionSubject implements Subject { private List<Observer> userList = new ArrayList<>(); @Override public void attach(Observer observer) { userList.add(observer); } @Override public void detach(Observer observer) { userList.remove(observer); } @Override public void notify(String message) { //通知所有订阅者 for (Observer observer : userList) { observer.update(message); } } }抽象观察者角色public interface Observer { /** * 更新 * @param message 消息 */ void update(String message); }具体观察者角色public class User implements Observer { private String name; public User(String name) { this.name = name; } @Override public void update(String message) { System.out.println(name + "接收到消息：" + message); } }Clientpublic class Client { public static void main(String[] args) { //创建公众号 SubscriptionSubject subject = new SubscriptionSubject(); //订阅公众号 subject.attach(new User("孙笑川")); subject.attach(new User("药水哥")); subject.attach(new User("刘波")); //公众号发布新的消息 subject.notify("带带大师兄"); } }（4）优缺点降低了被观察者与观察者之间的耦合被观察者发送消息，所有观察者都可以收到，可以实现广播机制观察者过多时，对系统性能会产生一定的影响如果被观察者有循环依赖，在发送消息时可能导致观察者循环调用（5）使用场景当对象存在一对多关系，一个对象的状态发生改变会影响其他的对象当一个抽象模型存在两个方面，其中一方面依赖于另一方面时

行为型模式-状态模式
type: item
date: 2022-09-16T15:14:00+00:00
description: （1）概述对有状态的对象，把复杂的“判断逻辑“提取到不同的状态对象中，允许其状态对象在其内部状态发生改变时改变其行为（2）结构环境角色：也称为上下文，它定义了客户程序需要的接口，维护一个当前状态并将与状态相关的操作委托给当前状态对象来处理抽象状态角色：定义接口用以封装环境对象中的特定状态所对应的行为具体状态角色：实现抽象状态所定义的行为（3）案例以乘坐电梯为例环境角色public class Context { /** * 对应状态对象的常量 */ public final static OpeningState OPENING_STATE = new OpeningState(); public final static ClosingState CLOSING_STATE = new ClosingState(); public final static RunningState RUNNING_STATE = new RunningState(); public final static StoppingState STOPPING_STATE = new StoppingState(); /** * 当前电梯状态变量 */ private LiftState liftState; public LiftState getLiftState() { return liftState; } public void setLiftState(LiftState liftState) { this.liftState = liftState; //设置当前状态对象中的Context对象 liftState.setContext(this); } public void open() { this.liftState.open(); } public void close() { this.liftState.close(); } public void run() { this.liftState.run(); } public void stop() { this.liftState.stop(); } }抽象状态角色public abstract class LiftState { //环境角色类变量 protected Context context; public void setContext(Context context) { this.context = context; } /** * 开门 */ public abstract void open(); /** * 关门 */ public abstract void close(); /** * 运行 */ public abstract void run(); /** * 停止 */ public abstract void stop(); }具体状态角色public class OpeningState extends LiftState { @Override public void open() { System.out.println("电梯门开了"); } @Override public void close() { //修改状态 super.context.setLiftState(Context.CLOSING_STATE); //调用当前状态中的Context中的close方法 super.context.close(); } @Override public void run() { } @Override public void stop() { } } public class RunningState extends LiftState { @Override public void open() { } @Override public void close() { } @Override public void run() { System.out.println("电梯正在运行"); } @Override public void stop() { super.context.setLiftState(Context.STOPPING_STATE); super.context.stop(); } } public class ClosingState extends LiftState { @Override public void open() { super.context.setLiftState(Context.OPENING_STATE); super.context.open(); } @Override p…

行为型模式-责任链模式
type: item
date: 2022-09-16T15:09:00+00:00
description: （1）概述为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连城一条链；当有请求发生时，可将请求沿着这条链传递，只到有对象处理它为止（2）结构抽象处理者角色：定义处理请求的接口，包含抽象处理方法和一个后继链接具体处理者角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理则处理，否则将该请求转发给后继者客户类角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节及请求传递的过程（3）案例以请假为例抽象处理者角色public abstract class Handler { protected final static int ONE = 1; protected final static int THREE = 3; protected final static int SEVEN = 7; //不同角色可以处理的请假天数区间 private int startNum; private int endNum; //声明后继者（该案例中的上级领导） private Handler nextHandler; public Handler(int startNum) { this.startNum = startNum; } public Handler(int startNum, int endNum) { this.startNum = startNum; this.endNum = endNum; } /** * 设置上级领导对象 * * @param nextHandler */ public void setNextHandler(Handler nextHandler) { this.nextHandler = nextHandler; } /** * 各级领导处理请假条的方法 * * @param leave */ protected abstract void handlerLeave(LeaveRequest leave); /** * 提交请假申请 * * @param leave */ public final void submit(LeaveRequest leave) { //当前领导审批 this.handlerLeave(leave); //上级领导审批 if (this.nextHandler != null && leave.getNum() > this.endNum) { this.nextHandler.handlerLeave(leave); } else { System.out.println("流程结束"); } } }具体处理者角色public class GroupLeader extends Handler { public GroupLeader() { super(0, Handler.ONE); } @Override protected void handlerLeave(LeaveRequest leave) { System.out.println(leave.getName() + "由于" + leave.getContent() + "，请假：" + leave.getNum() + "天"); System.out.println("组长审批意见：同意"); } } public class Manager extends Handler { public Manager() { super(Handler.ONE, Handler.THREE); } @Override protected void handlerLeave(LeaveRequest leave) { System.out.println(leave.getName() + "由于" + leave.getContent() + "，请假：" + leave.getNum() + "天"); System.out.println("部门经理意见：同意"); } } public class GeneralManager extends Handler { public GeneralManager() { super(Handler.THREE, Handler.SEVEN); } @Override protected void handlerLeave(LeaveRequest leave) { System.out.println(leave.getName() + "由于" + leave.getContent() + "，请假：" + leave.getNum() + "天"); System.out.p…

行为型模式-命令模式
type: item
date: 2022-09-16T15:00:00+00:00
description: （1）概述将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开，使两者之间通过命令对象来进行沟通，便于命令对象的存储、传递、调用、增加及管理（2）结构抽象命令角色：定义命令的接口，声明执行的方法具体命令角色：具体的命令，实现命令接口，持有接收者，并调用接收者的功能来完成命令要执行的操作实现者/接收者角色：执行命令的对象（任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能）调用者/请求者角色：要求命令对象执行请求，持有命令对象（一个或多个），客户端真正触发命令并要求命令执行相应操作的地方（即使用命令对象的入口）（3）案例以点餐为例抽象命令角色public interface Command { /** * 执行命令 */ void execute(); }public class Order { private int diningTable; private Map<String, Integer> foodDic = new HashMap<>(); public int getDiningTable() { return diningTable; } public void setDiningTable(int diningTable) { this.diningTable = diningTable; } public Map<String, Integer> getFoodDic() { return foodDic; } public void setFood(String foodName, int num) { foodDic.put(foodName, num); } }具体命令角色public class OrderCommand implements Command { //持有接收者对象 private SeniorChef receiver; //持有订单对象 private Order order; public OrderCommand(SeniorChef receiver, Order order) { this.receiver = receiver; this.order = order; } @Override public void execute() { System.out.println(order.getDiningTable() + "号桌的订单："); Map<String, Integer> foodDic = order.getFoodDic(); for (String foodName : foodDic.keySet()) { receiver.makeFood(foodName, foodDic.get(foodName)); } System.out.println(order.getDiningTable() + "号桌的菜品已准备完毕！"); } }实现者/接收者角色public class SeniorChef { public void makeFood(String foodName, int num) { System.out.println("制作了" + num + "份 " + foodName); } }调用者/请求者角色public class Waiter { //持有多个命令对象 private List<Command> commands = new ArrayList<>(); public void command(Command command) { commands.add(command); } public void orderUp() { System.out.println("新订单来了"); for (Command command : commands) { if (command != null) { command.execute(); } } } }Clientpublic class Client { public static void main(String[] args) { //创建订单 Order order1 = new Order(); order1.setDiningTable(1); order1.setFood("小混沌", 1); order1.setFood("煎饼", 1); Order order2 = new Order(); order2.setDiningTable(2); order2.setFood("小炒肉盖饭", 1); order2.setFood("酸梅汤", 1); //创建厨师 SeniorChef receiver = new S…