构建设计模式字典

关联知识库：构建设计模式字典

设计模式字典 - 中文版

https://draveness.me/holy-grail-design-pattern/

https://www.cnblogs.com/wxdlut/p/17346906.html

https://developer.aliyun.com/article/342530

https://www.infoq.cn/article/design-patterns-proposed-by-gof-20-years-ago

关于设计模式的争议

近年来，关于设计模式的争论非常激烈。

理解和学习它是第一步（如果你想谈论它，无论你站在哪一边）。

站在巨人的肩膀上无疑是一个明智的选择。作为经验的汇集，无疑见证了前辈们是如何运用面向对象编程（OOP）思想的。这23篇经验汇集展现了一段辉煌的历史。

如何应用它是第二步，而分歧也由此而来。
有些人将设计模式奉为天堂，认为它们是最佳实践，并被广泛使用。
另一些人则将设计模式贬低为地狱，认为它们不过是过去的糟粕，并不适用于当下。
当然，大多数人持中立态度。

尽信书不如无书。追求低耦合，但不可能完全没有耦合。

首先，在实际应用中考虑使用设计模式并没有错。这只是利用现有的解决方案来解决现有的问题。

然而，在分析和处理问题时，并不应该局限于设计模式。设计模式是面向对象编程（OOP）思维的最佳实践，也就是说，OOP 的落地经验产生了设计模式。

面对实际问题时，OOP 思维应该是第一反应。在 OOP 思维下，问题才有一个对应的上下文。这些上下文就是设计模式的源泉。同时，可以考虑当前问题是否与设计模式中已经解决的问题相匹配。

OOP和设计模式的比喻：乘法规则 / 25*25 = 625

接下来，也是最重要的一步 —— 平衡 与取舍 。
这是把握设计与过度设计的关键一步，关键在于利大于弊。

设计模式并不能解决所有问题，反而会带来新的问题。但如果解决问题的价值大于新问题的弊端，那就使用它。

这条规则似乎不仅限于设计模式，所有方法论都适用。动态地分析问题处理方式的优劣，是为了达到一个准确合理的终点。

️ 创建对象的模式

单例模式

全局唯一；通过添加类似 @Component 的注解，Spring bean 的作用域为单例。

原型模式

通过复制旧对象创建对象；为 Spring bean 设置 @Scope("prototype")。

️ 建造者模式

使用建造者模式创建复杂对象，无需在构造函数中传递大量参数；为对象添加 Lombok 的 @Builder 注解。

工厂模式

封装一组或多组对象的创建过程，并提供统一的参数化对象创建入口。[结合策略模式实现]

• 工厂方法
• 抽象工厂 —— 工厂的工厂

对象行为模式

策略模式

背景：对于对象的单一行为，在不同场景下会有不同的实现。

思路：添加策略层（策略接口），解耦程序调用与实现，实现程序的可扩展性。

Implemention: https://github.com/qiao-925/Strategy-pattern-demo

模板模式

背景：对于一组操作，大多数步骤相同，只有少数步骤不同，这将产生大量重复代码。

思路：定义程序的框架，并将部分步骤推迟到子类中，以实现模板代码复用。

️ 观察者模式

对象级别的 MQ。

专注于对象级别的事件发布和消息通知

职责链模式

根据单一职责原则，将复杂的业务处理流程拆分成链表结构，以实现可读性和可扩展性。

⚡ 命令模式

解耦请求发送者和接收者。

• code example

  // 命令接口
  public interface Command {void execute();
  }// 接收者
  public class Light {public void turnOn() {System.out.println("The light is on.");}public void turnOff() {System.out.println("The light is off.");}
  }// 具体命令：打开灯
  public class TurnOnLightCommand implements Command {private Light light;public TurnOnLightCommand(Light light) {this.light = light;}@Overridepublic void execute() {light.turnOn();}
  }// 具体命令：关闭灯
  public class TurnOffLightCommand implements Command {private Light light;public TurnOffLightCommand(Light light) {this.light = light;}@Overridepublic void execute() {light.turnOff();}
  }// 调用者
  public class RemoteControl {private Command command;public void setCommand(Command command) {this.command = command;}public void pressButton() {command.execute(); // 执行命令}
  }public class Client {public static void main(String[] args) {Light light = new Light(); // 创建接收者Command turnOn = new TurnOnLightCommand(light); // 创建打开灯的命令Command turnOff = new TurnOffLightCommand(light); // 创建关闭灯的命令RemoteControl remote = new RemoteControl(); // 创建调用者// 打开灯remote.setCommand(turnOn);remote.pressButton();// 关闭灯remote.setCommand(turnOff);remote.pressButton();}
  }
  

备忘录模式

目标：用于对象的历史记录和备份。

示例：用于编辑器，记录和恢复历史状态。

• code example

  public class Originator {private String state;public Originator(String state) {this.state = state;}public String getState() {return state;}public void setState(String state) {this.state = state;}
  /**
  * right here
  **/**public Memento createMemento() {return new Memento(state);}public void restoreMemento(Memento memento) {this.state = memento.getState();}**// Inner class for Mementopublic static class Memento {private final String state;public Memento(String state) {this.state = state;}public String getState() {return state;}}
  }
  

---

关于此模式，讨论的是：

如何在不破坏封装性的情况下公开私有成员变量数据？

当然，从私有变为公共很容易，但这会破坏封装性。

解决方案：对象本身保留创建备份的功能。

顺便说一句，这与充血模型的思维相关。

备忘录模式和充血模型比较 —— from manus

https://refactoringguru.cn/design-patterns/memento

状态模式

为每个状态及其行为创建类，以减少超过 3 个“if/else”语句的复杂性。

更易读、更易于维护，但类太多。

• comparation

  normal implemention:

  public class ContentWithoutState {private String status = "草稿"; // 初始状态为草稿public void publish() {if (status.equals("草稿")) {status = "待发布";System.out.println("内容已提交待发布");} else if (status.equals("待发布")) {// 模拟发布过程，可能成功或失败boolean success = Math.random() < 0.8; // 80%概率成功if (success) {status = "已发布";System.out.println("内容发布成功");} else {status = "发布失败";System.out.println("内容发布失败");}} else {System.out.println("内容状态不允许发布");}}public String getStatus() {return status;}public static void main(String[] args) {ContentWithoutState content = new ContentWithoutState();content.publish();System.out.println("当前状态: " + content.getStatus());content.publish();System.out.println("当前状态: " + content.getStatus());content.publish();System.out.println("当前状态: " + content.getStatus());}
  }
  

  implementiom by state pattern

  interface ContentStatus {void publish(Content content);
  }class DraftStatus implements ContentStatus {@Overridepublic void publish(Content content) {System.out.println("内容已提交待发布");content.setStatus(content.getPendingStatus());}
  }class PendingStatus implements ContentStatus {@Overridepublic void publish(Content content) {boolean success = Math.random() < 0.8; // 80%概率成功if (success) {System.out.println("内容发布成功");content.setStatus(content.getPublishedStatus());} else {System.out.println("内容发布失败");content.setStatus(content.getFailedStatus());}}
  }class PublishedStatus implements ContentStatus {@Overridepublic void publish(Content content) {System.out.println("内容已发布，无法再次发布");}
  }class FailedStatus implements ContentStatus {@Overridepublic void publish(Content content) {System.out.println("内容发布失败，请检查错误并重新提交");}
  }public class ContentWithState {private ContentStatus status;private DraftStatus draftStatus = new DraftStatus();private PendingStatus pendingStatus = new PendingStatus();private PublishedStatus publishedStatus = new PublishedStatus();private FailedStatus failedStatus = new FailedStatus();public ContentWithState() {this.status = draftStatus;}public void publish() {status.publish(this);}public void setStatus(ContentStatus status) {this.status = status;}public ContentStatus getDraftStatus() { return draftStatus; }public ContentStatus getPendingStatus() { return pendingStatus; }public ContentStatus getPublishedStatus() { return publishedStatus; }public ContentStatus getFailedStatus() { return failedStatus; }public static void main(String[] args) {ContentWithState content = new ContentWithState();content.publish();content.publish();content.publish();}
  }
  

访问者模式

将数据结构与作用于它们的算法分离。

• Example by json operations:

  import org.json.JSONObject;interface JsonVisitor {void visit(JSONObject jsonObject);
  }class PrintJsonVisitor implements JsonVisitor {@Overridepublic void visit(JSONObject jsonObject) {System.out.println("Name: " + jsonObject.getString("name"));System.out.println("Age: " + jsonObject.getInt("age"));System.out.println("City: " + jsonObject.getString("city"));}
  }class AgeSquareJsonVisitor implements JsonVisitor {@Overridepublic void visit(JSONObject jsonObject) {int age = jsonObject.getInt("age");System.out.println("Age squared: " + age * age);}
  }class AgePlusTenJsonVisitor implements JsonVisitor {@Overridepublic void visit(JSONObject jsonObject) {int age = jsonObject.getInt("age");System.out.println("Age plus 10: " + (age + 10));}
  }public class JsonWithVisitor {public static void main(String[] args) {String jsonString = "{\"name\":\"Alice\",\"age\":30,\"city\":\"New York\"}";JSONObject jsonObject = new JSONObject(jsonString);JsonVisitor printVisitor = new PrintJsonVisitor();printVisitor.visit(jsonObject);JsonVisitor ageSquareVisitor = new AgeSquareJsonVisitor();ageSquareVisitor.visit(jsonObject);JsonVisitor agePlusTenVisitor = new AgePlusTenJsonVisitor();agePlusTenVisitor.visit(jsonObject);}
  }
  

中介者模式

背景：多个对象之间存在大量的相互依赖关系。

其理念与 IOC 非常相似：将对象之间的对话转换为中介者与对象之间的对话。

对象结构模式

适配器模式

添加适配层来解决接口不兼容问题。

专注于接口层面。

桥接模式

延迟实例化和绑定。

使用组合模式代替继承模式，以避免类的排列组合导致的数量激增。

```jsx
// Implementor interface
interface MessageSender {void sendMessage(String message);
}// Concrete Implementors
class EmailSender implements MessageSender {@Overridepublic void sendMessage(String message) {System.out.println("Sending email: " + message);}
}class SmsSender implements MessageSender {@Overridepublic void sendMessage(String message) {System.out.println("Sending SMS: " + message);}
}// Abstraction
abstract class Message {protected MessageSender sender;Message(MessageSender sender) {this.sender = sender;}abstract void send(String message);
}// Refined Abstractions
class UrgentMessage extends Message {UrgentMessage(MessageSender sender) {super(sender);}@Overridevoid send(String message) {sender.sendMessage("URGENT: " + message);}
}class NormalMessage extends Message {NormalMessage(MessageSender sender) {super(sender);}@Overridevoid send(String message) {sender.sendMessage(message);}
}// Client code
public class BridgePatternDemo {public static void main(String[] args) {MessageSender emailSender = new EmailSender();MessageSender smsSender = new SmsSender();Message urgentEmail = new UrgentMessage(emailSender);urgentEmail.send("Meeting at 2 PM");Message normalSms = new NormalMessage(smsSender);normalSms.send("Reminder: Grocery shopping");}
}
```

组合模式

为客户端屏蔽对象和组合对象的具体实现提供统一的处理接口。

```jsx
// 抽象组件
public abstract class TreeNode {protected Long id;protected Long parentId;protected String name;protected Integer level;protected Integer sort;// 子节点操作public abstract void add(TreeNode node);public abstract void remove(TreeNode node);public abstract List<TreeNode> getChildren();// 树形结构操作public abstract List<TreeNode> getPath();public abstract boolean isLeaf();public abstract int getDepth();
}// 叶子节点
public class TreeLeaf extends TreeNode {@Overridepublic void add(TreeNode node) {throw new UnsupportedOperationException("Leaf node cannot add child");}@Overridepublic void remove(TreeNode node) {throw new UnsupportedOperationException("Leaf node cannot remove child");}@Overridepublic List<TreeNode> getChildren() {return Collections.emptyList();}@Overridepublic List<TreeNode> getPath() {return Collections.singletonList(this);}@Overridepublic boolean isLeaf() {return true;}@Overridepublic int getDepth() {return 0;}
}// 分支节点
public class TreeBranch extends TreeNode {private List<TreeNode> children = new ArrayList<>();@Overridepublic void add(TreeNode node) {children.add(node);}@Overridepublic void remove(TreeNode node) {children.remove(node);}@Overridepublic List<TreeNode> getChildren() {return Collections.unmodifiableList(children);}@Overridepublic List<TreeNode> getPath() {List<TreeNode> path = new ArrayList<>();path.add(this);if (!children.isEmpty()) {path.addAll(children.get(0).getPath());}return path;}@Overridepublic boolean isLeaf() {return children.isEmpty();}@Overridepublic int getDepth() {if (children.isEmpty()) {return 0;}return 1 + children.stream().mapToInt(TreeNode::getDepth).max().orElse(0);}
}
```

装饰器模式

动态地为对象添加一些额外的职责。

```jsx
// 组件接口
public interface Coffee {double cost();String getDescription();
}// 具体组件
public class SimpleCoffee implements Coffee {@Overridepublic double cost() {return 2.0; // 基础咖啡价格}@Overridepublic String getDescription() {return "Simple Coffee"; // 描述}
}----------------------------------------------------------------// 装饰器
public abstract class CoffeeDecorator implements Coffee {protected Coffee coffee; // 持有一个Coffee对象public CoffeeDecorator(Coffee coffee) {this.coffee = coffee;}
}// 具体装饰器：牛奶
public class MilkDecorator extends CoffeeDecorator {public MilkDecorator(Coffee coffee) {super(coffee);}@Overridepublic double cost() {return coffee.cost() + 0.5; // 加牛奶的额外费用}@Overridepublic String getDescription() {return coffee.getDescription() + ", Milk"; // 添加描述}
}// 具体装饰器：糖
public class SugarDecorator extends CoffeeDecorator {public SugarDecorator(Coffee coffee) {super(coffee);}@Overridepublic double cost() {return coffee.cost() + 0.2; // 加糖的额外费用}@Overridepublic String getDescription() {return coffee.getDescription() + ", Sugar"; // 添加描述}
}---------------------------------------------------------------------------------------public class CoffeeShop {public static void main(String[] args) {Coffee coffee = new SimpleCoffee(); // 创建基础咖啡System.out.println(coffee.getDescription() + " $" + coffee.cost());// 添加牛奶装饰coffee = new MilkDecorator(coffee);System.out.println(coffee.getDescription() + " $" + coffee.cost());// 添加糖装饰coffee = new SugarDecorator(coffee);System.out.println(coffee.getDescription() + " $" + coffee.cost());}
}
```

外观模式

封装子系统功能并提供简单的接口调用。

• 计算机启动示例

  // 子系统类1
  public class CPU {public void freeze() {System.out.println("CPU is freezing.");}public void jump(long position) {System.out.println("CPU is jumping to: " + position);}public void execute() {System.out.println("CPU is executing.");}
  }// 子系统类2
  public class Memory {public void load(long position, byte[] data) {System.out.println("Memory is loading data at position: " + position);}
  }// 子系统类3
  public class HardDrive {public byte[] read(long lba, int size) {System.out.println("HardDrive is reading data from LBA: " + lba + ", size: " + size);return new byte[size]; // 返回模拟数据}
  }// 外观类
  public class ComputerFacade {private CPU cpu;private Memory memory;private HardDrive hardDrive;public ComputerFacade() {this.cpu = new CPU();this.memory = new Memory();this.hardDrive = new HardDrive();}public void startComputer() {cpu.freeze();memory.load(0, hardDrive.read(0, 1024));cpu.jump(0);cpu.execute();}
  }public class Client {public static void main(String[] args) {ComputerFacade computer = new ComputerFacade();computer.startComputer(); // 启动计算机}
  }
  

享元模式

也称为： 缓存

通过构建映射实现对象重用。

```jsx
// 享元接口
public interface Shape {void draw(String color);
}// 具体享元类
public class Circle implements Shape {private String type; // 内部状态public Circle() {this.type = "Circle"; // 共享的状态}@Overridepublic void draw(String color) {System.out.println("Drawing a " + color + " " + type);}
}// 享元工厂
import java.util.HashMap;
import java.util.Map;public class ShapeFactory {private Map<String, Shape> shapes = new HashMap<>();public Shape getCircle(String color) {Shape circle = shapes.get(color);if (circle == null) {circle = new Circle();shapes.put(color, circle);System.out.println("Creating a new circle of color: " + color);}return circle;}
}// 客户端代码
public class Client {public static void main(String[] args) {ShapeFactory shapeFactory = new ShapeFactory();// 创建并使用享元对象Shape redCircle = shapeFactory.getCircle("Red");redCircle.draw("Red");Shape greenCircle = shapeFactory.getCircle("Green");greenCircle.draw("Green");// 共享相同的对象Shape anotherRedCircle = shapeFactory.getCircle("Red");anotherRedCircle.draw("Red");// 输出结果System.out.println("Red circle and another red circle are the same object: " + (redCircle == anotherRedCircle));}
}
```

代理模式

创建一个代理对象来控制对真实对象的调用，以实现额外的功能。

```jsx
// 主题接口
public interface Subject {void request();
}// 真实对象
public class RealSubject implements Subject {@Overridepublic void request() {System.out.println("RealSubject: Handling request.");}
}// 代理对象
public class Proxy implements Subject {private RealSubject realSubject;@Overridepublic void request() {if (realSubject == null) {realSubject = new RealSubject(); // 延迟加载}// 代理的额外功能System.out.println("Proxy: Pre-processing request.");realSubject.request(); // 调用真实对象的方法System.out.println("Proxy: Post-processing request.");}
}// 客户端代码
public class Client {public static void main(String[] args) {Subject subject = new Proxy(); // 使用代理对象subject.request(); // 通过代理对象调用请求}
}
```

代理模式与装饰器模式的区别：实现方式类似，但目标不同：
代理：专注于调用对象的控制。
装饰器：专注于功能扩展。

action test 001