1. 引言
在软件开发中，设计模式是一种被广泛使用的解决方案。它们为开发人员提供了一种常用的、经过验证的方法来解决特定问题，使得软件更具可维护性、可扩展性以及可复用性。本文将讨论两种常见的软件设计模式：观察者模式和中介者模式，并通过实际示例演示它们的应用。
2. 观察者模式
观察者模式是一种行为型模式，用于当一个对象的状态发生变化时，自动通知其他依赖于该对象的对象。它建立了一个一对多的依赖关系，使得多个对象能够同时监听并根据被观察对象的状态变化自动执行相应操作。
示例场景
想象一下，我们正在开发一个电子商务网站，当顾客下订单后，我们希望发送提醒邮件给物流部门、财务部门和顾客本人。这里，订单是被观察者，物流部门、财务部门和顾客本人是观察者。
UML类图
classDiagram
class Order {
+items: List<OrderItem>
+status: String
+addItem(item: OrderItem): void
+setStatus(status: String): void
+notifyObservers(): void
}
class Observer {
+update(): void
}
class LogisticsObserver {
+update(): void
}
class FinanceObserver {
+update(): void
}
class CustomerObserver {
+update(): void
}
class OrderItem {
+name: String
}
Order <|-- Observer
Order <|-- LogisticsObserver
Order <|-- FinanceObserver
Order <|-- CustomerObserver
代码示例
import java.util.ArrayList;
import java.util.List;
class Order {
private List<OrderItem> items;
private String status;
private List<Observer> observers;
public Order() {
items = new ArrayList<>();
status = "New";
observers = new ArrayList<>();
}
public void addItem(OrderItem item) {
items.add(item);
}
public void setStatus(String status) {
this.status = status;
notifyObservers();
}
public void attach(Observer observer) {
observers.add(observer);
}
public void detach(Observer observer) {
observers.remove(observer);
}
private void notifyObservers() {
for (Observer observer : observers) {
observer.update();
}
}
}
class OrderItem {
private String name;
public OrderItem(String name) {
this.name = name;
}
}
interface Observer {
void update();
}
class LogisticsObserver implements Observer {
@Override
public void update() {
System.out.println("Logistics department has been notified of the order status change.");
}
}
class FinanceObserver implements Observer {
@Override
public void update() {
System.out.println("Finance department has been notified of the order status change.");
}
}
class CustomerObserver implements Observer {
@Override
public void update() {
System.out.println("Customer has been notified of the order status change.");
}
}
public class Main {
public static void main(String[] args) {
Order order = new Order();
Observer logistics = new LogisticsObserver();
Observer finance = new FinanceObserver();
Observer customer = new CustomerObserver();
order.attach(logistics);
order.attach(finance);
order.attach(customer);
order.addItem(new OrderItem("Product 1"));
order.setStatus("Processing");
// Output:
// Logistics department has been notified of the order status change.
// Finance department has been notified of the order status change.
// Customer has been notified of the order status change.
}
}
3. 中介者模式
中介者模式是一种行为型模式，通过使用一个中介对象来封装对象之间的交互，使得对象之间不需要显式地相互引用，从而降低它们之间的耦合度。中介者模式可以减少对象之间的直接通信，将复杂的网络结构转为星型结构，使得对象之间的通信更加简洁高效。
示例场景
想象一下，我们正在开发一个多人聊天应用程序。为简化示例，我们仅考虑3个聊天用户：Alice、Bob和Charlie。当任何一个用户发送消息时，我们希望消息自动发送到其他用户。
UML类图
classDiagram
class Mediator {
+sendMessage(user: User, message: String): void
}
class User {
+name: String
-mediator: Mediator
+User(mediator: Mediator, name: String): void
+sendMessage(message: String): void
+receiveMessage(message: String): void
}
Mediator <|-- ChatMediator
User <|-- Alice
User <|-- Bob
User <|-- Charlie
代码示例
class Mediator {
public void sendMessage(User user, String message) {
// 根据用户和消息，决定向哪些用户发送消息
// 这里简化为发送给其他用户，可根据实际需求扩展
for (User u : users) {
if (u != user) {
u.receiveMessage(String.format("[%s]: %s", user.getName(), message));
}
}
}
}
class User {
private String name;
private Mediator mediator;
public User(Mediator mediator, String name) {
this.mediator = mediator;
this.name = name;
}
public void sendMessage(String message) {
mediator.sendMessage(this, message);
}
public void receiveMessage(String message) {
System.out.println(message);
}
public String getName() {
return name;
}
}
class Alice extends User {
public Alice(Mediator mediator) {
super(mediator, "Alice");
}
}
class Bob extends User {
public Bob(Mediator mediator) {
super(mediator, "Bob");
}
}
class Charlie extends User {
public Charlie(Mediator mediator) {
super(mediator, "Charlie");
}
}
public class Main {
public static void main(String[] args) {
Mediator mediator = new ChatMediator();
User alice = new Alice(mediator);
User bob = new Bob(mediator);
User charlie = new Charlie(mediator);
((ChatMediator) mediator).addUser(alice);
((ChatMediator) mediator).addUser(bob);
((ChatMediator) mediator).addUser(charlie);
alice.sendMessage("Hello, everyone!");
// Output:
// [Alice]: Hello, everyone!
bob.sendMessage("Hi, Alice!");
// Output:
// [Bob]: Hi, Alice!
}
}
4. 总结
观察者模式和中介者模式是软件开发中常用且有价值的设计模式。观察者模式可以帮助我们构建松耦合的对象之间的通信机制，实现事件驱动的模型；中介者模式可以帮助我们管理对象之间的复杂交互，减少对象之间的直接依赖，使得代码更易于维护和扩展。通过理解观察者模式和中介者模式的概念以及实际应用，我们可以更好地设计和开发高质量的软件系统。
本文来自极简博客，作者：码农日志，转载请注明原文链接：软件设计模式中的观察者模式与中介者模式实战
