Golang – 結構與介面

單元：嵌入結構（Embedded Structs）

---

簡介

在 Go 語言中，**結構（struct）是組合資料的核心工具，而嵌入結構（embedded structs）**則提供了一種簡潔且強大的方式，讓我們可以在不使用繼承的前提下，實現「類似繼承」的行為。透過嵌入，我們可以把共用的欄位與方法抽離成基礎結構，然後在多個具體結構中直接「內嵌」它，讓程式碼更具可讀性、可維護性，同時也能自然地支援介面的隱式實作。

對於剛接觸 Go 的新手來說，嵌入結構可能會感到陌生；但只要掌握其概念與使用方式，就能在日常開發中減少重複程式碼、提升抽象層次，尤其在建構大型服務或套件時，效益更為顯著。

---

核心概念

1. 什麼是嵌入結構？

在 Go 中，嵌入結構指的是把一個結構體作為另一個結構體的匿名欄位（anonymous field）放入。這樣的欄位不需要指定名稱，編譯器會自動把內嵌結構的欄位與方法「提升」到外層結構，使得外層結構可以直接存取它們。

type Person struct {
    Name string
    Age  int
}

type Employee struct {
    Person   // <-- 匿名欄位，等同於嵌入 Person
    ID       string
    Position string
}

在上例中，Employee 內部並沒有顯式宣告 Name、Age，但我們仍可直接使用 e.Name、e.Age，因為它們被 提升（promoted）了。

2. 為什麼要使用嵌入？

• 避免重複程式碼：共用欄位與方法只需要寫一次。
• 自然支援介面：內嵌結構的實作會自動被外層結構視為介面的實作。
• 組合優於繼承：Go 推崇「組合」而非「類別繼承」，嵌入正是組合的最佳範例。

3. 方法提升（Method Promotion）

當一個結構嵌入另一個結構時，內嵌結構的 方法 也會被提升。這意味著外層結構可以直接呼叫這些方法，甚至可以在外層結構上重新定義（override）同名方法。

type Logger struct {
    Prefix string
}

func (l Logger) Log(msg string) {
    fmt.Printf("%s: %s\n", l.Prefix, msg)
}

type Service struct {
    Logger          // 嵌入 Logger
    Name string
}

// 重新定義 Log 方法，覆寫提升的版本
func (s Service) Log(msg string) {
    fmt.Printf("[Service %s] %s\n", s.Name, msg)
}

4. 多層嵌入與衝突解決

嵌入可以是多層的，且不同層級可能出現同名欄位或方法。此時，最外層的同名成員會遮蔽（shadow）內層的成員，若想存取被遮蔽的成員，需要透過具名的內嵌結構來明確指定。

type A struct{ X int }
type B struct{ A; X int } // B 同時有自己的 X 與 A.X

b := B{A: A{X: 1}, X: 2}
fmt.Println(b.X)   // 2  (B 自己的 X)
fmt.Println(b.A.X) // 1  (透過具名方式存取 A 的 X)

---

程式碼範例

以下提供 5 個實用範例，說明嵌入結構在不同情境下的應用方式。每個範例都附有說明註解，方便讀者快速掌握重點。

範例 1：基礎欄位提升

package main

import "fmt"

type Address struct {
    City    string
    Zipcode string
}

type User struct {
    Name string
    Age  int
    Address // 嵌入 Address
}

func main() {
    u := User{
        Name: "Alice",
        Age:  30,
        Address: Address{
            City:    "Taipei",
            Zipcode: "100",
        },
    }

    // 直接存取內嵌結構的欄位
    fmt.Printf("%s lives in %s (zip %s)\n", u.Name, u.City, u.Zipcode)
}

重點：u.City、u.Zipcode 其實是 u.Address.City、u.Address.Zipcode 的提升版本，程式碼更簡潔。

範例 2：方法提升與介面實作

package main

import "fmt"

type Shape interface {
    Area() float64
}

// 基礎結構，提供通用的 Area 方法
type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// 具體形狀，嵌入 Rectangle
type Box struct {
    Rectangle // 直接提升 Area 方法
    Color string
}

func main() {
    b := Box{
        Rectangle: Rectangle{Width: 3, Height: 4},
        Color:     "red",
    }

    // Box 自動實作 Shape 介面
    var s Shape = b
    fmt.Printf("Box area: %.2f, color: %s\n", s.Area(), b.Color)
}

說明：Box 只需要嵌入 Rectangle，就已經符合 Shape 介面的要求，不需要額外實作 Area。

範例 3：方法覆寫（Override）

package main

import "fmt"

type Counter struct {
    value int
}

func (c *Counter) Inc() {
    c.value++
}

func (c Counter) Value() int {
    return c.value
}

// 嵌入 Counter，並自行實作 Inc 以加入日誌
type LoggedCounter struct {
    Counter
}

func (lc *LoggedCounter) Inc() {
    fmt.Println("incrementing counter")
    lc.Counter.Inc() // 呼叫被嵌入的原始方法
}

func main() {
    lc := LoggedCounter{}
    lc.Inc()          // 會先印出日誌，再遞增
    fmt.Println(lc.Value()) // 1
}

關鍵：在 LoggedCounter 中重新定義 Inc，同時透過 lc.Counter.Inc() 呼叫被遮蔽的原始實作，達成 method overriding 的效果。

範例 4：多層嵌入與衝突解決

package main

import "fmt"

type Base struct {
    ID   int
    Name string
}

type Derived struct {
    Base          // 第一次嵌入
    ID   string   // 與 Base.ID 同名，會遮蔽
    Base2 Base    // 具名嵌入，避免衝突
}

func main() {
    d := Derived{
        Base:  Base{ID: 1, Name: "BaseOne"},
        ID:    "D-100",
        Base2: Base{ID: 2, Name: "BaseTwo"},
    }

    fmt.Println("Derived.ID :", d.ID)           // "D-100"
    fmt.Println("Derived.Base.ID :", d.Base.ID) // 1
    fmt.Println("Derived.Base2.ID :", d.Base2.ID) // 2
}

技巧：當欄位名稱衝突時，具名嵌入（Base2 Base）可以讓我們仍然存取被遮蔽的欄位。

範例 5：在介面中使用嵌入結構的多型

package main

import "fmt"

type Notifier interface {
    Notify(msg string)
}

// 共用的 Email 結構
type Email struct {
    Addr string
}

func (e Email) Notify(msg string) {
    fmt.Printf("Send email to %s: %s\n", e.Addr, msg)
}

// SMS 結構
type SMS struct {
    Number string
}

func (s SMS) Notify(msg string) {
    fmt.Printf("Send SMS to %s: %s\n", s.Number, msg)
}

// 服務結構，同時支援 Email 與 SMS
type AlertService struct {
    Email // 嵌入 Email，提供 Email.Notify
    SMS   // 嵌入 SMS，提供 SMS.Notify
}

// 讓 AlertService 同時實作 Notifier，根據需求選擇方法
func (a AlertService) Notify(msg string) {
    a.Email.Notify(msg) // 先用 Email
    a.SMS.Notify(msg)   // 再用 SMS
}

func main() {
    as := AlertService{
        Email: Email{Addr: "user@example.com"},
        SMS:   SMS{Number: "+886912345678"},
    }
    as.Notify("系統已啟動")
}

實務觀點：透過嵌入，我們可以把多個「通知方式」的實作聚合在同一個服務裡，且仍然符合單一介面的契約，方便在程式中以 多型 方式使用。

---

常見陷阱與最佳實踐

陷阱	說明	解決方式
欄位名稱衝突	不同層級的結構有相同欄位時，外層會遮蔽內層，導致無法直接存取	使用具名嵌入或透過 outer.inner.Field 明確指定
指標與值的混用	嵌入結構時若使用值類型，方法接收者若是指標，外層呼叫時會自動取得指標，但若外層是值，可能無法呼叫指標接收者的方法	建議在外層使用指標（*Embedded）或在需要時手動取址 &e.Embedded
JSON / XML 編碼	嵌入結構的欄位在編碼時會被「展開」成同層欄位，若想保留巢狀結構需使用具名欄位或自訂 MarshalJSON	依需求選擇匿名或具名嵌入，或使用 omitempty、json:"-" 控制
介面隱式實作的誤解	以為只要嵌入結構就一定實作介面，實際上只有提升的方法符合介面簽名才算	確認提升的方法簽名與介面一致，必要時自行實作或覆寫
過度嵌入	把太多功能全部放在一個結構裡，導致結構變得龐大且難以維護	依職責分離（SRP）原則，適度拆分，必要時使用組合（多個嵌入）而非單一巨型結構

最佳實踐

1. 以「共用」為嵌入的依據：只有在多個結構真的需要相同欄位或方法時才考慮嵌入。
2. 盡量使用指標嵌入：避免不必要的值拷貝，尤其當內嵌結構較大或包含可變狀態時。
3. 保持層級清晰：多層嵌入時，盡量限制在兩層以內，過深的層級會降低可讀性。
4. 明確文件化：在程式碼註解或文件中說明哪個結構是「基礎」或「共用」的，讓其他開發者快速了解設計意圖。
5. 測試覆寫行為：如果在外層重新定義（override）了內嵌結構的方法，務必寫測試確保兩者的行為符合預期。

---

實際應用場景

場景	為何適合使用嵌入結構
Web 框架的請求上下文（Context）	多個中介層（middleware）需要共享 RequestID、UserInfo 等欄位，可將這些共用欄位抽成 BaseContext，再嵌入到各個具體的 APIContext、AdminContext 中。
資料庫模型	多張資料表都有 ID、CreatedAt、UpdatedAt，可以建立 Model 基礎結構，其他模型直接嵌入，省去重複欄位與時間戳記的程式碼。
錯誤處理與日誌	透過嵌入 Logger 結構，讓服務或套件自動具備 Log、Error 方法，且仍可自行覆寫以加入額外資訊（如 trace ID）。
多種通知渠道	如前範例的 AlertService，把 Email、SMS、Slack 等通知方式嵌入同一服務，統一介面 (Notify) 供上層呼叫。
插件系統	核心插件結構提供基本欄位與方法，具體插件透過嵌入擴充功能，同時保持與核心介面的相容性。

---

總結

嵌入結構是 Go 語言中 組合（composition） 的核心機制，它讓我們能在不引入傳統繼承的情況下，達成欄位與方法的 提升（promotion）、介面的 隱式實作，以及 多層次的抽象。透過適當的設計與最佳實踐，我們可以：

• 大幅減少重複程式碼
• 讓結構間的關係更清晰、維護更容易
• 在介面導向的程式設計中自然支援多型

在實務開發中，從 資料模型、請求上下文 到 通知服務，嵌入結構皆能提供簡潔且彈性的解決方案。只要留意欄位衝突、指標使用與介面契約，就能安全、有效地運用這項功能，寫出更乾淨、可擴充的 Go 程式碼。祝你在 Golang 的旅程中，玩得開心、寫得優雅！ 🚀