什么是观察者模式
观察者模式（Observer Pattern）是一种设计模式，它定义了对象之间一对多的依赖关系，当一个对象状态发生改变时，其所有依赖者都会收到通知并自动更新。观察者模式中，被观察者对象通常被称为主题（Subject），而观察者对象通常被称为观察者（Observer）。 在观察者模式中，主题维护一个观察者列表，当主题的状态发生变化时，它会依次通知所有的观察者，使它们能够及时更新自己的状态。这种松耦合的设计模式使得主题和观察者之间的关系不会影响彼此的稳定性，使得系统更加灵活和易于扩展。
Tip：观察者模式是一种常见的设计模式，应用场景广泛，如事件驱动系统、用户界面、网络编程等领域都有应用。
如何实现观察者模式
观察者模式的实现步骤如下：
- 定义主题（Subject）接口：包含添加观察者、移除观察者和通知观察者等方法；
- 定义观察者（Observer）接口：包含更新数据的方法；
- 定义具体主题（ConcreteSubject）类：实现主题接口，维护一个观察者列表，提供添加、移除和通知观察者等方法；
- 定义具体观察者（ConcreteObserver）类：实现观察者接口，实现更新数据的方；
- 在客户端代码中创建具体主题和具体观察者对象，将观察者注册到主题中，并触发主题的通知方法，以通知所有已注册的观察者。
Java实现 以下是 Java 实现观察者模式的示例代码：
代码语言：javascript复制import java.util.ArrayList;
import java.util.List;
// 主题接口，被观察者
interface Subject {
void attach(Observer observer);
void detach(Observer observer);
void notifyObservers(String message);
}
// 具体主题类
class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
@Override
public void attach(Observer observer) {
observers.add(observer);
}
@Override
public void detach(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
}
// 观察者接口
interface Observer {
void update(String message);
}
// 具体观察者类
class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name " received message: " message);
}
}
// 客户端调用
public class Client {
public static void main(String[] args) {
Subject subject = new ConcreteSubject();
Observer observer1 = new ConcreteObserver("Observer 1");
Observer observer2 = new ConcreteObserver("Observer 2");
subject.attach(observer1);
subject.attach(observer2);
subject.notifyObservers("Hello World!");
subject.detach(observer2);
subject.notifyObservers("Goodbye!");
}
}以上代码实现了一个观察者模式的例子，其中 Subject 接口定义了被观察者的行为，ConcreteSubject 类是具体的被观察者实现，Observer 接口定义了观察者的行为，ConcreteObserver 类是具体的观察者实现。在客户端调用中，首先创建了一个被观察者对象，然后创建了两个观察者对象并将它们注册到被观察者对象中，最后调用了被观察者对象的 notifyObservers 方法来通知观察者对象。在第二次调用 notifyObservers 方法时，又将其中一个观察者对象从被观察者对象中移除。
C#实现
以下是C#实现观察者模式的示例代码：
using System;
using System.Collections.Generic;
// 主题接口
interface ISubject {
void Attach(IObserver observer);
void Detach(IObserver observer);
void Notify();
}
// 具体主题
class ConcreteSubject : ISubject {
private List<IObserver> observers = new List<IObserver>();
private string subjectState;
public string SubjectState {
get { return subjectState; }
set { subjectState = value; }
}
public void Attach(IObserver observer) {
observers.Add(observer);
}
public void Detach(IObserver observer) {
observers.Remove(observer);
}
public void Notify() {
foreach (IObserver observer in observers) {
observer.Update();
}
}
}
// 观察者接口
interface IObserver {
void Update();
}
// 具体观察者
class ConcreteObserver : IObserver {
private string name;
private string observerState;
private ConcreteSubject subject;
public ConcreteObserver(string name, ConcreteSubject subject) {
this.name = name;
this.subject = subject;
}
public void Update() {
observerState = subject.SubjectState;
Console.WriteLine($"Observer {name}'s new state is {observerState}");
}
public ConcreteSubject Subject {
get { return subject; }
set { subject = value; }
}
}
// 客户端代码
class Client {
static void Main(string[] args) {
ConcreteSubject subject = new ConcreteSubject();
ConcreteObserver observer1 = new ConcreteObserver("Observer1", subject);
ConcreteObserver observer2 = new ConcreteObserver("Observer2", subject);
subject.Attach(observer1);
subject.Attach(observer2);
subject.SubjectState = "State 1";
subject.Notify();
subject.SubjectState = "State 2";
subject.Notify();
subject.Detach(observer2);
subject.SubjectState = "State 3";
subject.Notify();
}
}在这个示例代码中，ConcreteSubject 是具体的主题类，实现了 ISubject 接口，并维护了观察者列表和主题状态。ConcreteObserver 是具体的观察者类，实现了 IObserver 接口，并维护了观察者的状态和主题对象。Client 是客户端代码，创建了具体的主题和观察者对象，并进行了观察者的注册和通知操作。
总结
观察者模式是一种行为设计模式，它允许对象之间建立一种一对多的关系，当一个对象状态发生改变时，所有依赖它的对象都会得到通知并自动更新。该模式的优点在于松耦合，使得主题和观察者之间互不影响，同时增强了系统的可扩展性和灵活性。然而，该模式也有一些缺点，例如可能会导致大量的观察者对象，以及过多的通知可能会影响性能。因此，使用观察者模式时需要根据具体情况进行权衡和优化。
