设计模式-观察者模式（Observer）

1. 概念

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

---

2. 原理结构图

• 主题（Subject）：又称为被观察者（Observable），是观察者模式的核心对象。它负责维护一个观察者列表，用于记录所有依赖于它的观察者对象。当主题对象的状态发生改变时，它会通知所有观察者对象。
• 观察者（Observer）：又称为观察者（Observer），是依赖于主题对象的参与者。观察者对象需要实现一个特定的接口（如 update() 方法），以便在主题对象状态发生改变时接收通知并作出相应的处理。
• 具体主题（ConcreteSubject）：是主题类的实现类，负责存储具体的业务逻辑和状态信息。当具体主题对象的状态发生改变时，它会调用某个方法（如 notifyObservers()）来通知所有观察者对象。
• 具体观察者（ConcreteObserver）：是观察者接口的实现类，负责实现具体的响应逻辑。当接收到主题对象的通知时，具体观察者对象会根据自己的需求对通知进行处理。

---

3. 代码示例

3.1 示例1-新闻推送

• 在这个案例中，有一组新闻订阅者（观察者），希望接收特定新闻（被观察对象）的更新。当新闻发布时，所有订阅了该新闻的订阅者都会收到通知。

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

// 定义观察者接口NewsObserver
interface NewsObserver {
    void update(String newsTitle, String newsContent);
}

// 定义被观察对象NewsPublisher，它实现了注册、移除观察者以及发布新闻的方法
class NewsPublisher {
    private List<NewsObserver> observers;

    public NewsPublisher() {
        observers = new ArrayList<>();
    }

    public void registerObserver(NewsObserver observer) {
        observers.add(observer);
    }

    public void removeObserver(NewsObserver observer) {
        observers.remove(observer);
    }

    public void publishNews(String newsTitle, String newsContent) {
        System.out.println("Publishing news: " + newsTitle);
        for (NewsObserver observer : observers) {
            observer.update(newsTitle, newsContent);
        }
    }
}

// 创建几个具体的观察者类，它们实现了NewsObserver接口，并定义了各自的处理逻辑
class EmailSubscriber implements NewsObserver {
    @Override
    public void update(String newsTitle, String newsContent) {
        System.out.println("EmailSubscriber received news: " + newsTitle + "\nContent: " + newsContent);
        // 这里可以添加发送邮件的代码
    }
}

class MobileAppSubscriber implements NewsObserver {
    @Override
    public void update(String newsTitle, String newsContent) {
        System.out.println("MobileAppSubscriber received news: " + newsTitle);
        // 这里可以添加推送通知到移动应用的代码
    }
}

class WebPageSubscriber implements NewsObserver {
    @Override
    public void update(String newsTitle, String newsContent) {
        System.out.println("WebPageSubscriber received news: " + newsTitle + "\nContent: " + newsContent);
        // 这里可以添加更新网页内容的代码
    }
}

public class NewsSystem {
    public static void main(String[] args) {
        // 创建新闻发布者
        NewsPublisher newsPublisher = new NewsPublisher();

        // 创建订阅者并注册到新闻发布者
        NewsObserver emailSubscriber = new EmailSubscriber();
        NewsObserver mobileAppSubscriber = new MobileAppSubscriber();
        NewsObserver webPageSubscriber = new WebPageSubscriber();

        newsPublisher.registerObserver(emailSubscriber);
        newsPublisher.registerObserver(mobileAppSubscriber);
        newsPublisher.registerObserver(webPageSubscriber);

        // 发布新闻
        newsPublisher.publishNews("Breaking News", "An earthquake hit the city!");

        // 移除某个订阅者（如果需要）
        // newsPublisher.removeObserver(emailSubscriber);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

• 将看到如下输出：

Publishing news: Breaking News
EmailSubscriber received news: Breaking News
Content: An earthquake hit the city!
MobileAppSubscriber received news: Breaking News
WebPageSubscriber received news: Breaking News
Content: An earthquake hit the city!
1
2
3
4
5
6

• 以上是新闻推送的案例，如果需要，你可以添加更多的订阅者类型，或者实现更复杂的逻辑，比如基于新闻类别的订阅、延迟推送等。
• 这个示例展示了观察者模式在新闻推送场景中的基本应用。在实际应用中，你可能还需要考虑线程安全、错误处理、性能优化等方面的问题。

---

3.2 示例2-游戏开发

• 在游戏开发中，玩家受到攻击时触发观察者模式通常涉及更复杂的逻辑，包括攻击者、受害者、伤害计算、效果展示等多个方面。下面是一个演示了玩家受到攻击时使用观察者模式的案例。

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

// 首先，我们定义Observer接口和Subject接口
interface Observer {
    void update(String message);
}

interface Subject {
    void registerObserver(Observer o);

    void removeObserver(Observer o);

    void notifyObservers(String message);
}

// 实现Player类作为Subject
class Player implements Subject {
    private List<Observer> observers;
    private int healthPoints;

    public Player(int initialHealth) {
        this.observers = new ArrayList<>();
        this.healthPoints = initialHealth;
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        observers.remove(o);
    }

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

    public void takeDamage(int damage) {
        healthPoints -= damage;
        if (healthPoints < 0) {
            healthPoints = 0;
        }
        notifyObservers("Player took " + damage + " damage. Remaining health: " + healthPoints);
    }

    public int getHealthPoints() {
        return healthPoints;
    }

    public boolean isAlive() {
        return healthPoints > 0;
    }
}

// 创建HUDDisplay和GameLog作为Observer
class HUDDisplay implements Observer {
    @Override
    public void update(String message) {
        System.out.println("HUD: " + message);
    }
}

class GameLog implements Observer {
    @Override
    public void update(String message) {
        System.out.println("Log: " + message);
    }
}

// 创建一个Enemy类，它负责攻击玩家
class Enemy {
    private String name;
    private int attackPower;

    public Enemy(String name, int attackPower) {
        this.name = name;
        this.attackPower = attackPower;
    }

    public void attack(Player target) {
        int damage = this.attackPower;
        target.takeDamage(damage);
        System.out.println(this.name + " attacked the player!");
    }
}

public class GameTest {
    public static void main(String[] args) {
        // 创建玩家对象
        Player player = new Player(100);

        // 创建HUD显示和游戏日志对象，并注册为观察者
        HUDDisplay hudDisplay = new HUDDisplay();
        GameLog gameLog = new GameLog();
        player.registerObserver(hudDisplay);
        player.registerObserver(gameLog);

        // 创建敌人对象
        Enemy enemy = new Enemy("Goblin", 20);

        // 敌人攻击玩家
        enemy.attack(player);

        // 检查玩家是否存活，并显示相关信息
        if (player.isAlive()) {
            System.out.println("Player is still alive with " + player.getHealthPoints() + " health points.");
        } else {
            System.out.println("Player has been defeated!");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

• 将看到如下输出：

HUD: Player took 20 damage. Remaining health: 80
Log: Player took 20 damage. Remaining health: 80
Goblin attacked the player!
Player is still alive with 80 health points.
1
2
3
4

• 在这个例子中，Player 类在受到攻击时调用takeDamage 方法，并通知所有注册的观察者。HUDDisplay 和 GameLog 作为观察者，分别负责在HUD界面和游戏日志中显示玩家受到攻击的信息。Enemy类负责执行攻击行为。
• 运行这段代码时，你将看到HUD界面和游戏日志中显示了玩家受到攻击的信息，同时还会检查玩家是否存活并显示相应的信息。
• 这个案例展示了在游戏开发中，如何使用观察者模式来处理玩家受到攻击的事件，并允许不同的组件（如HUD显示、游戏日志等）订阅并响应这些事件。通过解耦，我们可以更容易地扩展游戏的功能，比如添加新的观察者来响应攻击事件，比如播放音效、显示特效等。

---

4. 优缺点

• 主要作用
  • 实现对象间的异步通信，允许一个对象在状态改变时通知多个依赖对象，而无需知道具体的观察者是谁，从而解耦系统并提高可扩展性。
• 优点
  • 降低耦合性：它通过定义对象之间的一对多依赖关系，使得一个对象的状态变化能够通知多个对象，而无需这些对象之间直接交互，从而降低了系统各部分之间的耦合度。
  • 增强可扩展性：新的观察者可以很容易地添加到系统中，只要它们遵循主题接口，就可以随时订阅或取消订阅主题的状态更新，这使得系统更加灵活和可扩展。
  • 支持广播通信：在需要广播通信的场景中，观察者模式提供了一种有效的机制，允许主题对象向所有注册的观察者发送通知，而不必知道具体的观察者是谁。
  • 动态交互：观察者和被观察者之间的交互是动态的，可以在运行时添加或移除观察者，这种灵活性对于实现动态数据绑定和实时事件处理非常有用。
  • 实现简单：观察者模式的结构相对简单，易于理解和实现，因此在许多实际应用中得到了广泛的使用。
  • 适用于多种场景：观察者模式适用于多种应用场景，如GUI事件处理、实时数据传输等，它提供了一种标准化的方法来处理状态变化和通知的问题。
• 缺点
  • 增加系统复杂性：虽然观察者模式降低了对象之间的耦合，但同时也增加了系统的复杂性。每个主题对象都需要维护一个观察者列表，并在状态变化时通知所有观察者，这需要额外的代码和资源开销。
  • 循环依赖：如果在观察者和被观察对象之间存在循环依赖，即一个观察者同时也是另一个观察者的被观察对象，那么当状态变化发生时，它们之间可能会触发循环调用，这不仅会导致通知的无限循环，还可能导致系统崩溃。
  • 通知成本：当被观察对象的状态发生变化时，它需要通知所有注册的观察者。如果被观察者的数量很多，或者通知过程较为复杂，那么通知的发布可能会消耗大量的时间和资源，导致程序的效率降低。
  • 内存开销：每个观察者都需要在被观察者中注册，因此如果被观察者有大量的观察者，那么就需要消耗大量的内存来存储这些观察者。
  • 通知顺序无法保证：在有多个观察者的情况下，无法保证通知的顺序。如果观察者的执行顺序很重要，可能需要额外的逻辑来控制。

---

5. 应用场景

1. 消息通知系统：如邮件系统、聊天室、新闻推送等，当有新消息或事件产生时，需要实时通知所有关注该消息或事件的观察者。观察者模式可以确保消息的及时传递和处理。
2. 分布式系统：在分布式系统中，不同节点之间的状态变化需要实时同步。观察者模式可以帮助实现节点之间的状态监测和通知机制，确保系统的一致性和可靠性。
3. 状态监控：在监控系统中，例如服务器负载监控，当某个指标超过预设阈值时，需要通知管理员或其他系统进行响应。观察者模式可以用来实现这种监控和通知机制。
4. 跨模块通信：在一个复杂的系统中，不同的模块或组件可能需要在某些事件发生时互相通信。通过观察者模式，一个模块可以作为观察者订阅另一个模块的事件，而不需要知道具体的实现细节。
5. 用户界面与交互：在图形用户界面（GUI）应用程序中，当某个元素（如按钮、文本框等）的状态发生变化时，可能需要通知其他相关元素进行更新。观察者模式可以确保这些元素之间的动态同步，提高用户体验。
6. 游戏开发：在游戏中，观察者模式可以用于处理各种事件，如玩家输入、碰撞检测、角色状态变化等。它可以帮助实现游戏逻辑的解耦和灵活扩展。

---

6. JDK中的使用

• java.util.Observable 和 java.util.Observer类
  • java.util.Observable
    • 这是一个抽象类，用于表示被观察的对象，也就是主题（Subject）。当Observable对象的状态发生变化时，它需要通知所有注册的观察者。为了实现这一点，Observable类提供了addObserver方法来注册观察者，deleteObserver方法来移除观察者，以及notifyObservers方法来通知所有观察者对象状态的变化。
  • java.util.Observe
    • 这是一个接口，用于定义观察者的行为。实现这个接口的类需要定义update方法，该方法将在被观察者状态变化时被调用。这样，观察者就可以接收到通知并执行相应的操作。

---

7. 注意事项

• 保持低耦合：确保主题对象（Subject）和观察者对象（Observer）之间的耦合度尽可能低。主题应该只知道观察者实现了某个接口，而不需要知道观察者的具体类或其实现细节。
• 避免直接调用：具体目标对象和具体观察者对象之间不应该直接调用对方的方法，这会导致两者之间的紧密耦合，违反面向对象的设计原则。
• 单一职责原则：每个对象应该专注于问题域中的一个离散抽象，即一个对象只做一件事情。这有助于提高代码的重用性和维护性。
• 扩展性：观察者模式支持对系统进行扩展，可以在不修改现有代码的情况下添加新的观察者类型。新观察者只需实现相应的接口即可注册到主题对象中。
• 注册与注销机制：主题应该提供注册和注销观察者的接口，以便在运行时动态地添加或移除观察者。
• 线程安全：如果在多线程环境中使用观察者模式，需要考虑同步问题，以防止并发修改导致的数据不一致。
• 通知顺序：如果有多个观察者，需要确定通知观察者的顺序，这可能会影响程序的行为。
• 性能考虑：在有大量观察者的情况下，通知所有观察者可能会耗费较多时间，需要考虑优化通知机制的性能。
• 避免循环依赖：应避免出现观察者和主题之间的循环依赖，这会导致系统难以维护和理解。

---