docs(golang): 更新设计模式笔记。

更新观察者模式笔记。
更新状态模式笔记。

Author: magicgopher

docs/public/images/docs/Golang/Golang设计模式/assets/state.png

@@ -35,152 +35,142 @@ title: 观察者模式
 classDiagram
     direction LR
 
-    %% 主题接口（Subject）：Subject
+	%% 定义接口
     class Subject {
         <<interface>>
-        +RegisterObserver(o Observer)
-        +RemoveObserver(o Observer)
-        +NotifyObservers()
+        +Attach(observer Observer)
+        +Detach(observer Observer)
+        +Notify(message string)
     }
-    note for Subject "定义主题的接口，管理观察者"
 
-    %% 具体主题（Concrete Subject）：NewsAgency
-    class NewsAgency {
-        -observers []Observer
-        -news string
-        +RegisterObserver(o Observer)
-        +RemoveObserver(o Observer)
-        +NotifyObservers()
-        +SetNews(news string)
-    }
-
-    %% 观察者接口（Observer）：Observer
     class Observer {
         <<interface>>
-        +Update(news string)
+        +Update(message string)
     }
-    note for Observer "定义观察者的接口，处理通知"
 
-    %% 具体观察者（Concrete Observer）：NewsChannel
-    class NewsChannel {
-        -name string
-        -news string
-        +Update(news string)
-        +GetNews() string
+    %% 定义具体类
+    class ConcreteSubject {
+        -observers []Observer
+        -state string
+        +Attach(observer Observer)
+        +Detach(observer Observer)
+        +Notify(message string)
+        +GetState() string
     }
 
-    %% 定义关系
-    Subject <|.. NewsAgency : 实现
-    Observer <|.. NewsChannel : 实现
-    NewsAgency o--> "many" Observer : 管理
-```
-
-### 新闻发布示例
+    class ConcreteObserver {
+        -name string
+        +Update(message string)
+    }
 
-`subject.go` 代码如下：
+	class Client {
 
-```go
-package observer
-
-// 观察者模式
+	}
 
-// 主题接口
+    %% 关系描述
+    Subject <|.. ConcreteSubject : 实现
+    Observer <|.. ConcreteObserver : 实现
+    Subject o--> Observer : 聚合 (持有列表)
+    ConcreteSubject ..> Observer : 依赖 (调用 Update)
 
-// Subject 定义主题接口，管理观察者
-type Subject interface {
-	RegisterObserver(o Observer)
-	RemoveObserver(o Observer)
-	NotifyObservers()
-}
+	Client ..> ConcreteSubject : 1. 创建 & 触发变更
+    Client ..> ConcreteObserver : 2. 创建实例
+    Client ..> Subject : 3. 调用 Attach/Detach
 ```
 
-`news_agency.go` 代码如下：
+### 新闻发布示例
+
+`observer.go` 代码如下：
 
 ```go
 package observer
 
-// 观察者模式
-
-// 具体主题
+import "fmt"
 
-// NewsAgency 是具体主题，管理新闻和观察者
-type NewsAgency struct {
-	observers []Observer
-	news      string
-}
+// 观察者模式（观察者接口与具体实现）
 
-// RegisterObserver 添加观察者
-func (n *NewsAgency) RegisterObserver(o Observer) {
-	n.observers = append(n.observers, o)
+// Observer 定义观察者接口
+// 所有具体的观察者都必须实现这个方法，当主题状态改变时会被调用
+type Observer interface {
+	// Update 当主题状态发生变化时，主题会调用此方法通知观察者
+	// 参数 message 是主题传递过来的最新状态信息
+	Update(message string)
 }
 
-// RemoveObserver 移除观察者
-func (n *NewsAgency) RemoveObserver(o Observer) {
-	for i, observer := range n.observers {
-		if observer == o {
-			n.observers = append(n.observers[:i], n.observers[i+1:]...)
-			break
-		}
-	}
+// ConcreteObserver 具体观察者实现
+type ConcreteObserver struct {
+	name string // 观察者名称，用于区分不同的观察者
 }
 
-// NotifyObservers 通知所有观察者
-func (n *NewsAgency) NotifyObservers() {
-	for _, observer := range n.observers {
-		observer.Update(n.news)
-	}
+// NewConcreteObserver 创建一个具体的观察者实例
+func NewConcreteObserver(name string) *ConcreteObserver {
+	return &ConcreteObserver{name: name}
 }
 
-// SetNews 设置新闻并通知观察者
-func (n *NewsAgency) SetNews(news string) {
-	n.news = news
-	n.NotifyObservers()
+// Update 实现 Observer 接口，接收主题的通知并打印
+func (o *ConcreteObserver) Update(message string) {
+	fmt.Printf("[观察者: %s] 收到状态更新通知 → %s\n", o.name, message)
 }
 ```
 
-`observer.go` 代码如下：
+`subject.go` 代码如下：	
 
 ```go
 package observer
 
-// 观察者模式
-
-// 观察者接口
+// 观察者模式（主题接口与具体实现）
 
-// Observer 定义观察者接口，处理通知
-type Observer interface {
-	Update(news string)
-}
-```
+// Subject 定义主题（被观察者）接口
+type Subject interface {
+	// Attach 注册/添加一个观察者
+	Attach(observer Observer)
 
-`news_channel.go` 代码如下：
+	// Detach 注销/移除一个观察者
+	Detach(observer Observer)
 
-```go
-package observer
+	// Notify 通知所有已注册的观察者状态已变更
+	Notify(message string)
+}
 
-// 观察者模式
+// ConcreteSubject 具体的主题实现（被观察的对象）
+type ConcreteSubject struct {
+	observers []Observer // 保存所有注册的观察者
+	state     string     // 主题当前的状态（可选，用于业务扩展）
+}
 
-// 具体观察者
+// NewConcreteSubject 创建一个具体的主题实例
+func NewConcreteSubject() *ConcreteSubject {
+	return &ConcreteSubject{
+		observers: make([]Observer, 0),
+	}
+}
 
-// NewsChannel 是具体观察者，接收和存储新闻
-type NewsChannel struct {
-	name string
-	news string
+// Attach 添加观察者到列表中
+func (s *ConcreteSubject) Attach(observer Observer) {
+	s.observers = append(s.observers, observer)
 }
 
-// NewNewsChannel 创建具体观察者实例
-func NewNewsChannel(name string) *NewsChannel {
-	return &NewsChannel{name: name}
+// Detach 从列表中移除指定的观察者
+func (s *ConcreteSubject) Detach(observer Observer) {
+	for i, obs := range s.observers {
+		if obs == observer { // 引用相同即认为相等
+			s.observers = append(s.observers[:i], s.observers[i+1:]...)
+			return
+		}
+	}
 }
 
-// Update 更新观察者的新闻内容
-func (n *NewsChannel) Update(news string) {
-	n.news = news
+// Notify 遍历所有观察者，调用它们的 Update 方法进行通知
+func (s *ConcreteSubject) Notify(message string) {
+	s.state = message // 更新主题状态（实际项目中可能有更多字段）
+	for _, observer := range s.observers {
+		observer.Update(message)
+	}
 }
 
-// GetNews 获取观察者的新闻内容
-func (n *NewsChannel) GetNews() string {
-	return n.news
+// GetState （可选）获取当前状态，用于观察者主动拉取（拉模型扩展）
+func (s *ConcreteSubject) GetState() string {
+	return s.state
 }
 ```
 
@@ -191,71 +181,64 @@ func (n *NewsChannel) GetNews() string {
 ```go
 package observer
 
-import (
-	"testing"
-)
+import "testing"
 
 // 单元测试
 // 模拟客户端调用
 
-// TestObserver 测试观察者模式的场景
-func TestObserver(t *testing.T) {
-	agency := &NewsAgency{}
-	channel1 := NewNewsChannel("频道1")
-	channel2 := NewNewsChannel("频道2")
-
-	tests := []struct {
-		name         string
-		news         string
-		expectedNews string
-	}{
-		{
-			name:         "发布第一条新闻",
-			news:         "突发新闻：事件A",
-			expectedNews: "突发新闻：事件A",
-		},
-		{
-			name:         "发布第二条新闻",
-			news:         "最新报道：事件B",
-			expectedNews: "最新报道：事件B",
-		},
-	}
+// TestObserverPattern 模拟真实客户端使用观察者模式的完整流程
+func TestObserverPattern(t *testing.T) {
+	// 1. 创建被观察者（主题）
+	newsAgency := NewConcreteSubject()
 
-	// 注册观察者
-	agency.RegisterObserver(channel1)
-	agency.RegisterObserver(channel2)
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// 发布新闻
-			agency.SetNews(tt.news)
-
-			// 验证观察者接收的新闻
-			if result := channel1.GetNews(); result != tt.expectedNews {
-				t.Errorf("频道1 期望新闻 %q，实际得到 %q", tt.expectedNews, result)
-			}
-			if result := channel2.GetNews(); result != tt.expectedNews {
-				t.Errorf("频道2 期望新闻 %q，实际得到 %q", tt.expectedNews, result)
-			}
-			t.Logf("新闻发布: %s", tt.expectedNews)
-		})
-	}
+	// 2. 创建多个具体观察者（比如不同的新闻订阅者）
+	tvStation := NewConcreteObserver("电视台")
+	wechatUser := NewConcreteObserver("微信用户")
+	appUser := NewConcreteObserver("手机APP用户")
 
-	// 测试移除观察者
-	agency.RemoveObserver(channel2)
-	agency.SetNews("新事件：事件C")
-	if channel2.GetNews() != "最新报道：事件B" {
-		t.Errorf("频道2 不应接收新新闻，期望 %q，实际得到 %q", "最新报道：事件B", channel2.GetNews())
-	}
-	if channel1.GetNews() != "新事件：事件C" {
-		t.Errorf("频道1 期望新闻 %q，实际得到 %q", "新事件：事件C", channel1.GetNews())
-	}
+	// 3. 订阅（注册观察者）
+	newsAgency.Attach(tvStation)
+	newsAgency.Attach(wechatUser)
+	newsAgency.Attach(appUser)
+
+	t.Log("第一次发布新闻，所有人都能收到...")
+	// 4. 主题状态改变 → 自动通知所有观察者（推模型）
+	newsAgency.Notify("紧急：最新天气预报发布！")
+
+	t.Log("\n微信用户取关了...")
+	// 5. 某个观察者取消订阅
+	newsAgency.Detach(wechatUser)
+
+	t.Log("第二次发布新闻，只有剩余订阅者收到...")
+	newsAgency.Notify("股市大涨，指数突破14000点！")
 }
 ```
 
 ### 实现说明
 
-观察者模式通过 `Subject` 接口定义了主题的行为，`NewsAgency`（具体主题）维护观察者列表并在新闻更新时通知所有观察者。`Observer` 接口定义了观察者的更新方法，`NewsChannel`（具体观察者）接收并存储新闻内容。客户端通过注册和移除观察者、设置新闻内容来触发通知。测试代码验证了观察者模式的动态注册、通知和移除功能，展示了主题与观察者的解耦以及状态更新的正确性。
+**接口解耦：**
+
+- 通过 `Subject` 和 `Observer` 接口定义交互契约，实现了发布者与订阅者的松耦合。`Subject` 只知道观察者实现了 `Update` 方法，而不关心具体的业务逻辑。
+- `Observer` 接口仅包含 `Update(message string)` 方法，这是一种推模型（`Push Model`）的实现，主题在通知时直接将数据（`message`）推送给观察者。
+
+**主题（Subject）管理机制：**
+
+- `ConcreteSubject` 使用切片 `[]Observer` 来存储所有活跃的观察者列表。
+- 注册（Attach）：使用 Go 的内建函数 `append` 将新的观察者加入切片。
+- 注销（Detach）：遍历切片，通过对比接口对象的引用地址找到目标观察者，并利用切片操作 `append(s.observers[:i], s.observers[i+1:]...)` 将其移除。这是 Go 语言中删除切片元素的标准做法。
+- 通知（Notify）：遍历 `observers` 切片，逐一调用观察者的 `Update` 方法。这里是同步调用，意味着如果某个观察者处理耗时较长，会阻塞后续观察者的通知。
+
+**观察者（Observer）响应：**
+
+- `ConcreteObserver` 内部维护了 `name` 字段用于区分身份。
+- 收到 `Update` 调用时，直接打印消息，模拟业务响应。
+
+**客户端流程：**
+
+- 客户端首先创建 `ConcreteSubject`，然后实例化多个 `ConcreteObserver`。
+- 通过 `Attach` 方法建立订阅关系。
+- 当调用 `Notify` 触发事件时，所有在列表中的观察者都会收到通知。
+- 演示了 `Detach` 后，被移除的观察者不再收到后续通知的逻辑。
 
 ## 优点与缺点