Publish-Subscribe 模式采用的设计模式是什么？给个代码

### 回答1：

发布-订阅（Publish-Subscribe）模式通常使用观察者模式（Observer Pattern）来实现。在观察者模式中，当一个对象的状态发生变化时，它的所有依赖对象都会收到通知并自动更新。

以下是一个简单的使用观察者模式实现发布-订阅模式的示例代码：

class Publisher:
    def __init__(self):
        self.subscribers = []

    def add_subscriber(self, subscriber):
        self.subscribers.append(subscriber)

    def remove_subscriber(self, subscriber):
        self.subscribers.remove(subscriber)

    def notify_subscribers(self, message):
        for subscriber in self.subscribers:
            subscriber.update(message)


class Subscriber:
    def __init__(self, name):
        self.name = name

    def update(self, message):
        print(f"{self.name} received message: {message}")


# Usage
publisher = Publisher()

subscriber1 = Subscriber("Subscriber 1")
subscriber2 = Subscriber("Subscriber 2")

publisher.add_subscriber(subscriber1)
publisher.add_subscriber(subscriber2)

publisher.notify_subscribers("Hello, world!")

publisher.remove_subscriber(subscriber2)

publisher.notify_subscribers("Goodbye, world!")

在上面的代码中，`Publisher` 是发布者，`Subscriber` 是订阅者。`Publisher` 维护了一个订阅者列表，可以动态地添加和移除订阅者。`Subscriber` 实现了 `update` 方法，当接收到发布者的消息时会自动打印出来。

这里我们可以看到，当发布者的状态发生变化时，它会自动通知它的所有订阅者，并且订阅者会自动更新它们的状态。这就是观察者模式的工作原理。

### 回答2：
Publish-Subscribe(发布-订阅)模式采用的设计模式是观察者模式。

观察者模式是一种行为型设计模式，它定义了一个一对多的依赖关系，让多个观察者对象同时监听并且被自动通知被观察者对象的状态变化。在发布-订阅模式中，发布者充当被观察者，而订阅者则充当观察者。

下面是一个使用观察者模式实现的简单的发布-订阅系统的示例代码：

import java.util.ArrayList;
import java.util.List;

// 观察者接口
interface Observer {
    void update(String message);
}

// 被观察者（发布者）类
class Publisher {
    private List<Observer> observers = new ArrayList<>();

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void detach(Observer observer) {
        observers.remove(observer);
    }

    public void publishMessage(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

// 订阅者类
class Subscriber implements Observer {
    private String name;

    public Subscriber(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}

// 示例代码
public class PubSubExample {
    public static void main(String[] args) {
        Publisher publisher = new Publisher();
        
        // 创建订阅者
        Subscriber subscriber1 = new Subscriber("Subscriber 1");
        Subscriber subscriber2 = new Subscriber("Subscriber 2");
        
        // 订阅者订阅发布者
        publisher.attach(subscriber1);
        publisher.attach(subscriber2);
        
        // 发布者发布消息
        publisher.publishMessage("Hello, World!");
        
        // 订阅者取消订阅
        publisher.detach(subscriber1);
        
        // 发布者再次发布消息
        publisher.publishMessage("Goodbye!");
    }
}

运行以上代码，输出结果为：

Subscriber 1 received message: Hello, World!
Subscriber 2 received message: Hello, World!
Subscriber 2 received message: Goodbye!

其中，`Publisher`充当被观察者角色，`Observer`是观察者接口，`Subscriber`是具体的观察者类。通过`attach`方法订阅发布者，通过`detach`方法取消订阅，通过`publishMessage`方法发布消息，观察者通过`update`方法接收发布者的消息。

### 回答3：
Publish-Subscribe 模式采用的设计模式是观察者模式（Observer Pattern）。

观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，使得当一个对象的状态发生改变时，依赖于它的所有对象都会得到通知并自动更新。

下面是一个简单的观察者模式的代码示例：

首先定义一个抽象的观察者接口 Observer：

public interface Observer {
    void update(String message);
}

然后定义一个具体的观察者类 Subscriber，实现 Observer 接口：

public class Subscriber implements Observer {
    private String name;
    
    public Subscriber(String name) {
        this.name = name;
    }
    
    @Override
    public void update(String message) {
        System.out.println(name + " 收到消息: " + message);
    }
}

定义一个被观察者类 Publisher，它维护一个观察者列表，并在状态变化时通知观察者：

import java.util.ArrayList;
import java.util.List;

public class Publisher {
    private List<Observer> observers;
    
    public Publisher() {
        this.observers = new ArrayList<>();
    }
    
    public void attach(Observer observer) {
        observers.add(observer);
    }
    
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    
    public void publish(String message) {
        System.out.println("发布消息: " + message);
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

最后，使用上述类进行测试：

public class Main {
    public static void main(String[] args) {
        Publisher publisher = new Publisher();
        
        Observer subscriber1 = new Subscriber("Subscriber1");
        Observer subscriber2 = new Subscriber("Subscriber2");
        
        publisher.attach(subscriber1);
        publisher.attach(subscriber2);
        
        publisher.publish("Hello World!");
        
        publisher.detach(subscriber2);
        
        publisher.publish("Goodbye!");
    }
}

输出结果：

发布消息: Hello World!
Subscriber1 收到消息: Hello World!
Subscriber2 收到消息: Hello World!
发布消息: Goodbye!
Subscriber1 收到消息: Goodbye!