1
2
3
4
5

// 定义一个统一的支付接口，就像不同国家的插座都遵循的统一标准
type PaymentGateway interface {
    Pay(amount float64) error
    Refund(transactionID string) error
}

 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

// 定义标准支付接口
type PaymentGateway interface {
    Pay(amount float64) error
    Refund(transactionID string) error
}

// Alipay（支付宝）—— 我们的"老朋友"，天生就实现了标准接口
type Alipay struct{}

func (a *Alipay) Pay(amount float64) error {
    fmt.Printf("支付宝收款: %.2f 元\n", amount)
    return nil
}

func (a *Alipay) Refund(transactionID string) error {
    fmt.Printf("支付宝退款，交易号: %s\n", transactionID)
    return nil
}

// WechatPay（微信支付）—— "新朋友"，接口和老系统不兼容
// 注意：微信支付的接口是 PayWechat(amount int64, channel string)
// 和我们的标准接口完全不搭嘎！
type WechatPay struct{}

func (w *WechatPay) PayWechat(amount int64, channel string) error {
    // 微信支付的金额单位是"分"，而不是"元"
    fmt.Printf("微信支付收款: %d 分，支付渠道: %s\n", amount, channel)
    return nil
}

func (w *WechatPay) RefundWechat(transactionID string, amount int64) error {
    fmt.Printf("微信退款，交易号: %s，金额: %d 分\n", transactionID, amount)
    return nil
}

 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

// WechatPayAdapter 就是那个万能转换插头！
// 它实现了 PaymentGateway 接口，但内部调用的是 WechatPay 的方法
type WechatPayAdapter struct {
    wechat *WechatPay
}

// 构造函数，负责"组装"这个转换插头
func NewWechatPayAdapter() *WechatPayAdapter {
    return &WechatPayAdapter{
        wechat: &WechatPay{},
    }
}

// 关键方法：Pay 的实现
// 这里把"元"转换成"分"，把标准接口的调用转换成微信支付能理解的格式
func (adapter *WechatPayAdapter) Pay(amount float64) error {
    // 金额单位转换：元 -> 分
    amountInCent := int64(amount * 100)
    channel := "WX_NATIVE" // 默认使用Native支付
    return adapter.wechat.PayWechat(amountInCent, channel)
}

func (adapter *WechatPayAdapter) Refund(transactionID string) error {
    // 假设退款金额从外部获取，这里简化处理
    return adapter.wechat.RefundWechat(transactionID, 0)
}

 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

// UnionPay（银联支付）—— 又一个"方言"选手
type UnionPay struct{}

func (u *UnionPay) PayWithCard(amount float64, cardNo string, cvv string) error {
    // 银联需要卡号和CVV，是不是很烦？
    fmt.Printf("银联收款: %.2f 元，卡号: %s***\n", amount, cardNo[:4])
    return nil
}

func (u *UnionPay) RefundToCard(transactionID string) error {
    fmt.Printf("银联退款，交易号: %s\n", transactionID)
    return nil
}

// UnionPayAdapter —— 银联支付适配器
type UnionPayAdapter struct {
    union *UnionPay
}

func NewUnionPayAdapter() *UnionPayAdapter {
    return &UnionPayAdapter{union: &UnionPay{}}
}

func (adapter *UnionPayAdapter) Pay(amount float64) error {
    // 银联需要虚拟卡号，这里简化处理
    return adapter.union.PayWithCard(amount, "6222021234567890", "123")
}

func (adapter *UnionPayAdapter) Refund(transactionID string) error {
    return adapter.union.RefundToCard(transactionID)
}

 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

// ProcessPayment 是一个通用的支付处理函数
// 它只认识 PaymentGateway，不管你是支付宝还是微信还是银联
func ProcessPayment(gateway PaymentGateway, amount float64) {
    fmt.Println("=== 开始支付流程 ===")
    if err := gateway.Pay(amount); err != nil {
        fmt.Printf("支付失败: %v\n", err)
        return
    }
    fmt.Println("支付成功！")
    fmt.Println("=== 支付流程结束 ===\n")
}

func main() {
    // 场景一：使用支付宝（它天然就符合标准接口）
    alipay := &Alipay{}
    ProcessPayment(alipay, 199.50)

    // 场景二：使用微信支付（通过适配器接入）
    wechatAdapter := NewWechatPayAdapter()
    ProcessPayment(wechatAdapter, 199.50)

    // 场景三：使用银联支付（也是通过适配器接入）
    unionAdapter := NewUnionPayAdapter()
    ProcessPayment(unionAdapter, 199.50)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 定义一个"旧系统"的遗留接口，参数列表很奇葩
type LegacyAPI func(userID int, data string, timeout int) (string, error)

// 新的标准接口只需要一个参数
type NewAPI func(req string) (string, error)

// LegacyToNewAdapter 就是函数适配器
// 它把旧接口的参数"组装"成新接口需要的格式
func LegacyToNewAdapter(legacy LegacyAPI) NewAPI {
    return func(req string) (string, error) {
        // 旧接口需要 userID, data, timeout，我们这里硬编码一些默认值
        // 真实场景中，这些值可能来自 req 的解析
        userID := 10086
        timeout := 30
        return legacy(userID, req, timeout)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func main() {
    // 模拟旧系统的遗留接口
    legacyFunc := func(userID int, data string, timeout int) (string, error) {
        result := fmt.Sprintf("旧系统处理: userID=%d, data=%s, timeout=%d", userID, data, timeout)
        return result, nil
    }

    // 通过适配器，把旧接口转换成新接口
    newFunc := LegacyToNewAdapter(legacyFunc)

    // 现在可以像使用新接口一样使用它
    result, _ := newFunc("Hello, 适配器！")
    fmt.Println(result)
}

1
2
3
4
5
6
7
8
9

type Coffee struct {
    Name        string
    Price       float64
    WithMilk    bool
    WithSugar   bool
    WithMocha   bool
    WithWhipped bool
    // ... 一长串配料flag
}

1
2
3
4
5

// 首先定义一个统一接口——所有咖啡（不管加了多少配料）都实现这个接口
type Coffee interface {
    GetPrice() float64        // 获取当前这杯咖啡的价格
    GetDescription() string  // 获取当前这杯咖啡的描述
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 基础咖啡，实现 Coffee 接口
type SimpleCoffee struct{}

func (c *SimpleCoffee) GetPrice() float64 {
    return 30.0 // 一杯纯咖啡，30元
}

func (c *SimpleCoffee) GetDescription() string {
    return "原味咖啡"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// CoffeeDecorator 就是"装饰器基类"，它也实现了 Coffee 接口
// 不同的是，它内部持有一个"已经被装饰过的咖啡"的引用
// 注意：这里是具名字段嵌套，而不是匿名嵌套（匿名嵌套才类似"继承"）
type CoffeeDecorator struct {
    coffee Coffee // 引用，可以是一杯基础咖啡，也可以是另一个装饰器
}

func (d *CoffeeDecorator) GetPrice() float64 {
    // 装饰器默认不额外收费，价格由具体的装饰器子类决定
    return d.coffee.GetPrice()
}

func (d *CoffeeDecorator) GetDescription() string {
    return d.coffee.GetDescription()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// MilkDecorator —— 牛奶装饰器
type MilkDecorator struct {
    *CoffeeDecorator // 匿名嵌套，相当于"继承"了 GetPrice 和 GetDescription 方法
}

func NewMilkDecorator(coffee Coffee) *MilkDecorator {
    return &MilkDecorator{
        CoffeeDecorator: &CoffeeDecorator{coffee: coffee},
    }
}

// 关键：牛奶的额外价格
func (d *MilkDecorator) GetPrice() float64 {
    basePrice := d.coffee.GetPrice()
    milkPrice := 5.0
    fmt.Printf("[牛奶装饰器] 基础价格: %.2f, 牛奶价格: %.2f\n", basePrice, milkPrice)
    return basePrice + milkPrice
}

// 关键：牛奶的额外描述
func (d *MilkDecorator) GetDescription() string {
    return d.coffee.GetDescription() + " + 牛奶"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// SugarDecorator —— 糖装饰器
type SugarDecorator struct {
    *CoffeeDecorator
}

func NewSugarDecorator(coffee Coffee) *SugarDecorator {
    return &SugarDecorator{
        CoffeeDecorator: &CoffeeDecorator{coffee: coffee},
    }
}

func (d *SugarDecorator) GetPrice() float64 {
    basePrice := d.coffee.GetPrice()
    sugarPrice := 2.0
    fmt.Printf("[糖装饰器] 基础价格: %.2f, 糖价格: %.2f\n", basePrice, sugarPrice)
    return basePrice + sugarPrice
}

func (d *SugarDecorator) GetDescription() string {
    return d.coffee.GetDescription() + " + 糖"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// MochaDecorator —— 摩卡装饰器
type MochaDecorator struct {
    *CoffeeDecorator
}

func NewMochaDecorator(coffee Coffee) *MochaDecorator {
    return &MochaDecorator{
        CoffeeDecorator: &CoffeeDecorator{coffee: coffee},
    }
}

func (d *MochaDecorator) GetPrice() float64 {
    basePrice := d.coffee.GetPrice()
    mochaPrice := 8.0
    fmt.Printf("[摩卡装饰器] 基础价格: %.2f, 摩卡价格: %.2f\n", basePrice, mochaPrice)
    return basePrice + mochaPrice
}

func (d *MochaDecorator) GetDescription() string {
    return d.coffee.GetDescription() + " + 摩卡"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// WhippedCreamDecorator —— 鲜奶油装饰器
type WhippedCreamDecorator struct {
    *CoffeeDecorator
}

func NewWhippedCreamDecorator(coffee Coffee) *WhippedCreamDecorator {
    return &WhippedCreamDecorator{
        CoffeeDecorator: &CoffeeDecorator{coffee: coffee},
    }
}

func (d *WhippedCreamDecorator) GetPrice() float64 {
    basePrice := d.coffee.GetPrice()
    whippedPrice := 6.0
    fmt.Printf("[鲜奶油装饰器] 基础价格: %.2f, 鲜奶油价格: %.2f\n", basePrice, whippedPrice)
    return basePrice + whippedPrice
}

func (d *WhippedCreamDecorator) GetDescription() string {
    return d.coffee.GetDescription() + " + 鲜奶油"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

func main() {
    fmt.Println("=== 点一杯基础咖啡 ===")
    coffee := &SimpleCoffee{}
    fmt.Printf("描述: %s, 价格: %.2f 元\n", coffee.GetDescription(), coffee.GetPrice())

    fmt.Println("\n=== 点一杯咖啡 + 牛奶 ===")
    coffeeWithMilk := NewMilkDecorator(coffee)
    fmt.Printf("描述: %s, 价格: %.2f 元\n", coffeeWithMilk.GetDescription(), coffeeWithMilk.GetPrice())

    fmt.Println("\n=== 点一杯咖啡 + 牛奶 + 糖 ===")
    coffeeWithMilkAndSugar := NewSugarDecorator(coffeeWithMilk)
    fmt.Printf("描述: %s, 价格: %.2f 元\n", coffeeWithMilkAndSugar.GetDescription(), coffeeWithMilkAndSugar.GetPrice())

    fmt.Println("\n=== 点一杯咖啡 + 牛奶 + 糖 + 摩卡 ===")
    coffeeDeluxe := NewMochaDecorator(coffeeWithMilkAndSugar)
    fmt.Printf("描述: %s, 价格: %.2f 元\n", coffeeDeluxe.GetDescription(), coffeeDeluxe.GetPrice())

    fmt.Println("\n=== 超级豪华套餐：咖啡 + 牛奶 + 糖 + 摩卡 + 鲜奶油 ===")
    coffeeUltimate := NewWhippedCreamDecorator(coffeeDeluxe)
    fmt.Printf("描述: %s, 价格: %.2f 元\n", coffeeUltimate.GetDescription(), coffeeUltimate.GetPrice())
}

 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

// 定义一个"处理器函数"类型
type HandlerFunc func(w string, r string) string

// 第一个装饰器：日志中间件
// 它的输入是一个 HandlerFunc，输出也是一个 HandlerFunc
func LoggingDecorator(next HandlerFunc) HandlerFunc {
    return func(w string, r string) string {
        fmt.Printf("[日志] 收到请求: %s, 参数: %s\n", w, r)
        result := next(w, r) // 先调用真正的处理函数
        fmt.Printf("[日志] 响应结果: %s\n", result)
        return result
    }
}

// 第二个装饰器：认证中间件
func AuthDecorator(next HandlerFunc) HandlerFunc {
    return func(w string, r string) string {
        fmt.Println("[认证] 检查用户身份...")
        if r == "" {
            fmt.Println("[认证] 未携带参数，拒绝访问！")
            return "Unauthorized"
        }
        result := next(w, r)
        fmt.Println("[认证] 认证通过！")
        return result
    }
}

// 第三个装饰器：超时控制中间件
func TimeoutDecorator(next HandlerFunc) HandlerFunc {
    return func(w string, r string) string {
        fmt.Println("[超时控制] 开始计时...")
        // 这里简化处理，实际场景应该用 goroutine + channel 实现真正的超时
        result := next(w, r)
        fmt.Println("[超时控制] 任务完成，计时结束！")
        return result
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 真实的处理器函数
func RealHandler(w string, r string) string {
    fmt.Printf("[真实处理器] 处理业务逻辑: w=%s, r=%s\n", w, r)
    return fmt.Sprintf("处理结果: Hello %s!", r)
}

func main() {
    // 一层一层地包装，就像套娃一样
    // 最外层是 TimeoutDecorator
    // 它包装了 AuthDecorator
    // AuthDecorator 又包装了 LoggingDecorator
    // LoggingDecorator 最终包装了 RealHandler

    handler := TimeoutDecorator(
        AuthDecorator(
            LoggingDecorator(RealHandler),
        ),
    )

    fmt.Println("=== 执行装饰后的处理器 ===")
    response := handler("GET", "World")
    fmt.Printf("最终响应: %s\n", response)
}

1
2
3
4
5
6
7
8
9

// 定义一个"明星"接口，所有明星都要实现这个接口
type Star interface {
    // ReceiveGift 接收粉丝礼物
    ReceiveGift(gift string) string
    // AttendDinner 参加晚宴
    AttendDinner(venue string) string
    // SignName 为粉丝签名
    SignName(fanName string) string
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// RealStar 是真正的明星——我们的大明星"小美"
type RealStar struct {
    name string
}

func NewRealStar(name string) *RealStar {
    return &RealStar{name: name}
}

func (s *RealStar) ReceiveGift(gift string) string {
    // 明星亲自接收礼物
    return fmt.Sprintf("明星[%s]收到礼物: %s，非常感谢！", s.name, gift)
}

func (s *RealStar) AttendDinner(venue string) string {
    // 明星亲自确认晚宴
    return fmt.Sprintf("明星[%s]确认出席晚宴，地点: %s", s.name, venue)
}

func (s *RealStar) SignName(fanName string) string {
    // 明星亲自签名
    return fmt.Sprintf("明星[%s]为粉丝[%s]签名: 祝学业进步，天天开心！", s.name, fanName)
}

 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

// StarProxy 是经纪人/代理——负责替明星过滤和处理请求
type StarProxy struct {
    realStar *RealStar // 持有一个真实明星的引用
    // 代理还有一些自己的"资源"，比如：可以设置拦截条件
    vipFans map[string]bool // VIP粉丝名单
}

func NewStarProxy(star *RealStar) *StarProxy {
    return &StarProxy{
        realStar: star,
        vipFans: map[string]bool{
            "王思聪": true,   // 顶级VIP
            "马云":   true,   // 顶级VIP
            "普通粉丝": false, // 普通粉丝
        },
    }
}

func (p *StarProxy) ReceiveGift(gift string) string {
    // 代理先"过滤"一下
    fmt.Printf("[经纪人] 检查礼物: %s\n", gift)

    // 过滤逻辑：太贵重的礼物不接受（保护明星）
    if len(gift) > 50 {
        fmt.Println("[经纪人] 抱歉，礼物太贵重了，明星不能收！")
        return "经纪人代为拒绝: 礼物太贵重"
    }

    // 过滤逻辑：违禁品不接受
    if gift == "炸弹" || gift == "辣椒水" {
        fmt.Println("[经纪人] 抱歉，这个不能收！")
        return "经纪人代为拒绝: 违禁品"
    }

    // 通过过滤，交给明星处理
    fmt.Println("[经纪人] 礼物检查通过，转交明星！")
    return p.realStar.ReceiveGift(gift)
}

func (p *StarProxy) AttendDinner(venue string) string {
    // 代理先检查晚宴地点
    fmt.Printf("[经纪人] 检查晚宴地点: %s\n", venue)

    // 过滤逻辑：太远的地点不去
    if venue == "非洲大草原" {
        fmt.Println("[经纪人] 抱歉，太远了，明星档期冲突！")
        return "经纪人代为拒绝: 档期冲突"
    }

    // 通过检查，转交明星
    return p.realStar.AttendDinner(venue)
}

func (p *StarProxy) SignName(fanName string) string {
    fmt.Printf("[经纪人] 检查签名请求: 粉丝 [%s]\n", fanName)

    // 过滤逻辑：检查是否是VIP粉丝
    if p.vipFans[fanName] {
        fmt.Println("[经纪人] VIP粉丝！直接转交明星！")
        return p.realStar.SignName(fanName)
    }

    // 不是VIP，那就只能签个名，明星不亲自写了
    fmt.Println("[经纪人] 普通粉丝，明星不亲自写，我代签吧！")
    return fmt.Sprintf("【代签】明星经纪人替明星[%s]为粉丝[%s]签名: 谢谢支持！", p.realStar.name, fanName)
}

 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

func main() {
    // 创建真实明星
    star := NewRealStar("小美")

    // 创建代理（经纪人）
    proxy := NewStarProxy(star)

    // 粉丝们开始请求了

    fmt.Println("=== 场景1: 普通粉丝送礼物 ===")
    result := proxy.ReceiveGift("一束鲜花")
    fmt.Println(result)
    fmt.Println()

    fmt.Println("=== 场景2: 有人送炸弹（违禁品） ===")
    result = proxy.ReceiveGift("炸弹")
    fmt.Println(result)
    fmt.Println()

    fmt.Println("=== 场景3: VIP粉丝王思聪请求签名 ===")
    result = proxy.SignName("王思聪")
    fmt.Println(result)
    fmt.Println()

    fmt.Println("=== 场景4: 普通粉丝请求签名 ===")
    result = proxy.SignName("普通粉丝")
    fmt.Println(result)
    fmt.Println()

    fmt.Println("=== 场景5: 有人邀请去非洲大草原 ===")
    result = proxy.AttendDinner("非洲大草原")
    fmt.Println(result)
    fmt.Println()

    fmt.Println("=== 场景6: 正常晚宴邀请 ===")
    result = proxy.AttendDinner("北京烤鸭店")
    fmt.Println(result)
}

 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

// Image 是图片接口
type Image interface {
    Display()
}

// RealImage 是真实的大图片，加载它需要很多资源
type RealImage struct {
    filename string
}

func NewRealImage(filename string) *RealImage {
    img := &RealImage{filename: filename}
    // 模拟：加载大文件需要消耗很多资源
    fmt.Printf("[RealImage] 正在加载大文件: %s (这需要3秒钟...)\n", filename)
    // time.Sleep(3 * time.Second) // 实际场景中，这里会真的很慢
    fmt.Printf("[RealImage] 文件 %s 加载完成！\n", filename)
    return img
}

func (img *RealImage) Display() {
    fmt.Printf("[RealImage] 显示图片: %s\n", img.filename)
}

// VirtualImageProxy 是虚代理——按需加载
type VirtualImageProxy struct {
    realImage *RealImage // 初始为 nil，表示还没加载
    filename  string
}

func NewVirtualImageProxy(filename string) *VirtualImageProxy {
    return &VirtualImageProxy{filename: filename}
}

// Display 方法会按需加载真实图片
func (proxy *VirtualImageProxy) Display() {
    // 懒加载：只有第一次真正需要显示的时候，才加载真实图片
    if proxy.realImage == nil {
        fmt.Printf("[VirtualProxy] 第一次访问，需要加载真实图片...\n")
        proxy.realImage = NewRealImage(proxy.filename)
    } else {
        fmt.Printf("[VirtualProxy] 图片已经加载过了，直接使用缓存！\n")
    }
    proxy.realImage.Display()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func main() {
    fmt.Println("=== 创建虚代理（这时候不会加载真实图片！） ===")
    proxy := NewVirtualImageProxy("test_image_100MB.jpg")
    fmt.Println("虚代理创建完成，真实图片还没有加载。")

    fmt.Println("\n=== 第一次调用 Display（这时候才会加载） ===")
    proxy.Display()

    fmt.Println("\n=== 第二次调用 Display（直接使用缓存） ===")
    proxy.Display()
}

 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

// 先定义各个子系统的"复杂"接口和实现
// 注意：这些接口通常都很专业，很复杂，普通用户不需要了解

// Projector 投影仪
type Projector struct{}

func (p *Projector) On() {
    fmt.Println("投影仪启动中...嗡嗡嗡...")
}

func (p *Projector) Off() {
    fmt.Println("投影仪关闭中...")
}

func (p *Projector) SetInput(input string) {
    fmt.Printf("投影仪输入切换到: %s\n", input)
}

// Amplifier 音响
type Amplifier struct{}

func (a *Amplifier) On() {
    fmt.Println("音响开启...")
}

func (a *Amplifier) Off() {
    fmt.Println("音响关闭...")
}

func (a *Amplifier) SetVolume(level int) {
    fmt.Printf("音响音量设置为: %d\n", level)
}

func (a *Amplifier) SetSource(source string) {
    fmt.Printf("音响音源切换到: %s\n", source)
}

// BluRayPlayer 蓝光播放器
type BluRayPlayer struct{}

func (b *BluRayPlayer) On() {
    fmt.Println("蓝光播放器开启...")
}

func (b *BluRayPlayer) Off() {
    fmt.Println("蓝光播放器关闭...")
}

func (b *BluRayPlayer) Play(movie string) {
    fmt.Printf("蓝光播放器正在播放: %s\n", movie)
}

// Screen 投影幕布
type Screen struct{}

func (s *Screen) Down() {
    fmt.Println("投影幕布正在下降...")
}

func (s *Screen) Up() {
    fmt.Println("投影幕布正在上升...")
}

// Lights 灯光
type Lights struct{}

func (l *Lights) Dim(level int) {
    fmt.Printf("灯光调暗到 %d%%\n", level)
}

func (l *Lights) Bright() {
    fmt.Println("灯光调亮")
}

// PopcornMachine 爆米花机（家庭影院怎么能少了爆米花！）
type PopcornMachine struct{}

func (p *PopcornMachine) On() {
    fmt.Println("爆米花机开启...")
}

func (p *PopcornMachine) Pop() {
    fmt.Println("*爆米花制作中* 嘭！嘭！嘭！...")
}

func (p *PopcornMachine) Off() {
    fmt.Println("爆米花机关闭...")
}

 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

// HomeTheaterFacade 就是我们的"一键看电影"外观
// 客户端不需要知道任何子系统的细节，只需要跟这个外观打交道
type HomeTheaterFacade struct {
    projector     *Projector
    amplifier     *Amplifier
    bluRayPlayer *BluRayPlayer
    screen       *Screen
    lights       *Lights
    popcornMachine *PopcornMachine
}

// 外观的构造函数，接收所有子系统
func NewHomeTheaterFacade() *HomeTheaterFacade {
    return &HomeTheaterFacade{
        projector:     &Projector{},
        amplifier:     &Amplifier{},
        bluRayPlayer:  &BluRayPlayer{},
        screen:        &Screen{},
        lights:        &Lights{},
        popcornMachine: &PopcornMachine{},
    }
}

// WatchMovie 就是那个神奇的一键操作
// 客户端只需要调用这一个方法，就能自动完成所有准备工作
func (facade *HomeTheaterFacade) WatchMovie(movie string) {
    fmt.Println("\n========================================")
    fmt.Println(">>> 家庭影院系统启动 <<<")
    fmt.Println("========================================")

    // 1. 打开爆米花机（看电影怎么能少了爆米花！）
    facade.popcornMachine.On()
    facade.popcornMachine.Pop()

    // 2. 调暗灯光
    facade.lights.Dim(20)

    // 3. 放下投影幕布
    facade.screen.Down()

    // 4. 打开投影仪
    facade.projector.On()
    facade.projector.SetInput("HDMI-1")

    // 5. 打开音响
    facade.amplifier.On()
    facade.amplifier.SetSource("BLU-RAY")
    facade.amplifier.SetVolume(25)

    // 6. 打开蓝光播放器并播放电影
    facade.bluRayPlayer.On()
    facade.bluRayPlayer.Play(movie)

    fmt.Println("========================================")
    fmt.Printf(">>> 享受您的电影: %s <<<\n", movie)
    fmt.Println("========================================\n")
}

// EndMovie 结束电影，一键关闭所有设备
func (facade *HomeTheaterFacade) EndMovie() {
    fmt.Println("\n========================================")
    fmt.Println(">>> 关闭家庭影院 <<<")
    fmt.Println("========================================")

    // 按相反的顺序关闭所有设备
    facade.bluRayPlayer.Off()
    facade.projector.Off()
    facade.screen.Up()
    facade.amplifier.Off()
    facade.popcornMachine.Off()
    facade.lights.Bright()

    fmt.Println("========================================")
    fmt.Println(">>> 家庭影院已关闭 <<<")
    fmt.Println("========================================\n")
}

// ListenToMusic 听音乐模式
func (facade *HomeTheaterFacade) ListenToMusic() {
    fmt.Println("\n========================================")
    fmt.Println(">>> 音乐模式启动 <<<")
    fmt.Println("========================================")

    facade.lights.Dim(40)
    facade.amplifier.On()
    facade.amplifier.SetSource("AUX")
    facade.amplifier.SetVolume(20)

    fmt.Println("========================================")
    fmt.Println(">>> 放松心情，享受音乐 <<<")
    fmt.Println("========================================\n")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func main() {
    // 创建外观对象——这就是你的"万能遥控器"
    homeTheater := NewHomeTheaterFacade()

    // 你只需要告诉它"要看什么电影"，剩下的全部自动搞定
    homeTheater.WatchMovie("阿凡达2：水之道")

    fmt.Println("... 电影看完了 ...")

    // 结束，一键关闭
    homeTheater.EndMovie()
}

1
2
3
4
5
6
7
8

// ========== 第一步：定义实现（发送渠道）接口 ==========

// MessageSender 是消息发送渠道的接口
// 注意：这个接口定义的是底层的"怎么发"
type MessageSender interface {
    Send(message string, receiver string) error
    GetChannelName() string
}

 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

// ========== 第二步：实现各种发送渠道 ==========

// SMSSender 短信发送渠道
type SMSSender struct{}

func (s *SMSSender) Send(message string, receiver string) error {
    // 短信发送逻辑
    fmt.Printf("[SMS] 发送给 %s: %s\n", receiver, message)
    fmt.Println("[SMS] 短信发送成功！（每条0.1元）")
    return nil
}

func (s *SMSSender) GetChannelName() string {
    return "短信"
}

// EmailSender 邮件发送渠道
type EmailSender struct{}

func (e *EmailSender) Send(message string, receiver string) error {
    fmt.Printf("[Email] 发送给 %s: %s\n", receiver, message)
    fmt.Println("[Email] 邮件发送成功！")
    return nil
}

func (e *EmailSender) GetChannelName() string {
    return "邮件"
}

// WeChatSender 微信推送渠道
type WeChatSender struct{}

func (w *WeChatSender) Send(message string, receiver string) error {
    fmt.Printf("[WeChat] 推送给 %s: %s\n", receiver, message)
    fmt.Println("[WeChat] 微信推送成功！")
    return nil
}

func (w *WeChatSender) GetChannelName() string {
    return "微信"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// ========== 第三步：定义抽象（消息类型） ==========

// Notification 是消息通知的抽象基类（用结构体模拟）
// 注意：它持有一个 MessageSender 的引用，这就是"桥"
type Notification struct {
    sender MessageSender // 持有实现的引用，桥接两个维度
}

// 发送消息的通用逻辑
func (n *Notification) Send(message string, receiver string) error {
    fmt.Printf("准备发送消息...\n")
    fmt.Printf("渠道: %s\n", n.sender.GetChannelName())
    return n.sender.Send(message, receiver)
}

 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

// ========== 第四步：扩展抽象（各种消息类型） ==========

// TextNotification 文本消息通知
type TextNotification struct {
    *Notification // 匿名嵌套，继承 Notification 的所有方法
}

func NewTextNotification(sender MessageSender) *TextNotification {
    return &TextNotification{
        Notification: &Notification{sender: sender},
    }
}

func (n *TextNotification) SendText(text string, receiver string) error {
    fmt.Println("[TextNotification] 发送文本消息")
    return n.Send(text, receiver)
}

// ImageNotification 图片消息通知
type ImageNotification struct {
    *Notification
}

func NewImageNotification(sender MessageSender) *ImageNotification {
    return &ImageNotification{
        Notification: &Notification{sender: sender},
    }
}

func (n *ImageNotification) SendImage(imageURL string, receiver string, caption string) error {
    fmt.Println("[ImageNotification] 发送图片消息")
    fmt.Printf("图片URL: %s, 说明: %s\n", imageURL, caption)
    return n.Send(fmt.Sprintf("[图片] %s", caption), receiver)
}

// VideoNotification 视频消息通知
type VideoNotification struct {
    *Notification
}

func NewVideoNotification(sender MessageSender) *VideoNotification {
    return &VideoNotification{
        Notification: &Notification{sender: sender},
    }
}

func (n *VideoNotification) SendVideo(videoURL string, receiver string, title string) error {
    fmt.Println("[VideoNotification] 发送视频消息")
    fmt.Printf("视频标题: %s, URL: %s\n", title, videoURL)
    return n.Send(fmt.Sprintf("[视频] %s", title), receiver)
}

 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

func main() {
    fmt.Println("=== 桥接模式演示 ===\n")

    // 创建各种发送渠道
    smsSender := &SMSSender{}
    emailSender := &EmailSender{}
    wechatSender := &WeChatSender{}

    // ===== 维度一：用不同渠道发送文本消息 =====

    fmt.Println("--- 用短信发送文本消息 ---")
    textViaSMS := NewTextNotification(smsSender)
    textViaSMS.SendText("您的验证码是：123456", "13800138000")

    fmt.Println()

    fmt.Println("--- 用邮件发送文本消息 ---")
    textViaEmail := NewTextNotification(emailSender)
    textViaEmail.SendText("您的验证码是：123456", "user@example.com")

    fmt.Println()

    fmt.Println("--- 用微信发送文本消息 ---")
    textViaWeChat := NewTextNotification(wechatSender)
    textViaWeChat.SendText("您的验证码是：123456", "user_wechat_id")

    fmt.Println("\n" + strings.Repeat("=", 50) + "\n")

    // ===== 维度二：用不同渠道发送图片消息 =====

    fmt.Println("--- 用微信发送图片消息 ---")
    imageViaWeChat := NewImageNotification(wechatSender)
    imageViaWeChat.SendImage(
        "https://example.com/photo.jpg",
        "user_wechat_id",
        "看看这张照片！",
    )

    fmt.Println()

    fmt.Println("--- 用邮件发送图片消息 ---")
    imageViaEmail := NewImageNotification(emailSender)
    imageViaEmail.SendImage(
        "https://example.com/photo.jpg",
        "user@example.com",
        "看看这张照片！",
    )

    fmt.Println("\n" + strings.Repeat("=", 50) + "\n")

    // ===== 维度三：用不同渠道发送视频消息 =====

    fmt.Println("--- 用微信发送视频消息 ---")
    videoViaWeChat := NewVideoNotification(wechatSender)
    videoViaWeChat.SendVideo(
        "https://example.com/video.mp4",
        "user_wechat_id",
        "精彩视频",
    )
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// ========== 第一步：定义组件接口 ==========

// FileSystemNode 是文件系统的组件接口
// 所有文件和文件夹都实现这个接口
type FileSystemNode interface {
    // GetName 获取节点名称
    GetName() string
    // GetSize 获取节点大小（文件返回文件大小，文件夹返回所有子节点的总大小）
    GetSize() int64
    // Print 打印节点信息
    Print(prefix string)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// ========== 第二步：实现叶子节点——文件 ==========

// File 是文件（叶子节点）
type File struct {
    name string
    size int64 // 文件大小，单位字节
}

func NewFile(name string, size int64) *File {
    return &File{name: name, size: size}
}

func (f *File) GetName() string {
    return f.name
}

func (f *File) GetSize() int64 {
    return f.size
}

func (f *File) Print(prefix string) {
    // 文件打印自己的信息
    fmt.Printf("%s├── [%s] 文件: %s, 大小: %d 字节\n", prefix, "📄", f.name, f.size)
}

 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

// ========== 第三步：实现容器节点——文件夹 ==========

// Folder 是文件夹（组合节点），可以包含子节点
type Folder struct {
    name  string
    nodes []FileSystemNode // 子节点，可以是文件，也可以是文件夹
}

func NewFolder(name string) *Folder {
    return &Folder{
        name:  name,
        nodes: make([]FileSystemNode, 0),
    }
}

func (f *Folder) GetName() string {
    return f.name
}

// GetSize 返回文件夹内所有子节点的总大小
func (f *Folder) GetSize() int64 {
    var total int64
    for _, node := range f.nodes {
        total += node.GetSize()
    }
    return total
}

// Add 添加子节点
func (f *Folder) Add(node FileSystemNode) {
    f.nodes = append(f.nodes, node)
}

// Remove 移除子节点
func (f *Folder) Remove(node FileSystemNode) {
    for i, n := range f.nodes {
        if n == node {
            f.nodes = append(f.nodes[:i], f.nodes[i+1:]...)
            return
        }
    }
}

// Print 打印文件夹及其所有子节点（递归）
func (f *Folder) Print(prefix string) {
    fmt.Printf("%s├── [%s] 文件夹: %s/ (包含 %d 个子项)\n", prefix, "📁", f.name, len(f.nodes))

    // 递归打印所有子节点
    // 最后一个子项的 prefix 要用 "│   " 而不是 "│   ├──"
    for i, node := range f.nodes {
        isLast := i == len(f.nodes)-1
        childPrefix := prefix
        if isLast {
            childPrefix += "│   "
        } else {
            childPrefix += "│   "
        }

        if isLast {
            // 如果是最后一个子项，用 "│   " 但最后一行用 "└──"
            // 这里简化处理，用同一个prefix
            node.Print(childPrefix)
        } else {
            node.Print(childPrefix)
        }
    }
}

 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

// FolderV2 是改进版的文件夹，打印更清晰
type FolderV2 struct {
    name  string
    nodes []FileSystemNode
}

func NewFolderV2(name string) *FolderV2 {
    return &FolderV2{
        name:  name,
        nodes: make([]FileSystemNode, 0),
    }
}

func (f *FolderV2) GetName() string {
    return f.name
}

func (f *FolderV2) GetSize() int64 {
    var total int64
    for _, node := range f.nodes {
        total += node.GetSize()
    }
    return total
}

func (f *FolderV2) Add(node FileSystemNode) {
    f.nodes = append(f.nodes, node)
}

// PrintTree 递归打印树形结构
func (f *FolderV2) PrintTree(indent int) {
    // indent 控制缩进
    prefix := ""
    for i := 0; i < indent; i++ {
        prefix += "    "
    }

    if indent == 0 {
        fmt.Printf("%s📁 %s/ (总计: %d 字节)\n", prefix, f.name, f.GetSize())
    } else {
        fmt.Printf("%s├── 📁 %s/ (%d 字节)\n", prefix, f.name, f.GetSize())
    }

    for _, node := range f.nodes {
        if file, ok := node.(*File); ok {
            fmt.Printf("%s│   ├── 📄 %s (%d 字节)\n", prefix, file.name, file.size)
        } else if folder, ok := node.(*FolderV2); ok {
            folder.PrintTree(indent + 1)
        }
    }
}