Go语言设计模式入门：简单工厂和单例怎么用？

// 支付接口
type Payment interface {
    Pay(amount float64) string
}

// 微信支付
type WechatPay struct{}

func (w *WechatPay) Pay(amount float64) string {
    return fmt.Sprintf("微信支付：¥%.2f", amount)
}

// 支付宝支付
type Alipay struct{}

func (a *Alipay) Pay(amount float64) string {
    return fmt.Sprintf("支付宝支付：¥%.2f", amount)
}

// 简单工厂：根据类型返回对应的支付实例
func NewPayment(payType string) Payment {
    switch payType {
    case "wechat":
        return &WechatPay{}
    case "alipay":
        return &Alipay{}
    default:
        return nil
    }
}

// 产品接口
type Logger interface {
    Log(message string)
}

// 具体产品：文件日志
type FileLogger struct {
    filePath string
}

func (f *FileLogger) Log(message string) {
    fmt.Printf("[文件日志 %s] %s\n", f.filePath, message)
}

// 具体产品：控制台日志
type ConsoleLogger struct{}

func (c *ConsoleLogger) Log(message string) {
    fmt.Printf("[控制台] %s\n", message)
}

// 工厂接口：每个具体工厂返回一个 Logger
type LoggerFactory interface {
    CreateLogger() Logger
}

// 文件日志工厂
type FileLoggerFactory struct {
    Path string
}

func (f *FileLoggerFactory) CreateLogger() Logger {
    return &FileLogger{filePath: f.Path}
}

// 控制台日志工厂
type ConsoleLoggerFactory struct{}

func (c *ConsoleLoggerFactory) CreateLogger() Logger {
    return &ConsoleLogger{}
}

func UseLogger(factory LoggerFactory) {
    logger := factory.CreateLogger()
    logger.Log("系统启动")
}

// 切换日志方式只需换工厂
UseLogger(&ConsoleLoggerFactory{})
UseLogger(&FileLoggerFactory{Path: "/var/log/app.log"})

// 产品接口
type Button interface {
    Render() string
}

type Checkbox interface {
    Toggle() string
}

// 抽象工厂：能创建一组产品
type UIFactory interface {
    CreateButton() Button
    CreateCheckbox() Checkbox
}

// ===== Windows 主题 =====
type WindowsButton struct{}

func (w *WindowsButton) Render() string { return "[Windows 风格按钮]" }

type WindowsCheckbox struct{}

func (w *WindowsCheckbox) Toggle() string { return "[Windows 复选框: ✓]" }

type WindowsFactory struct{}

func (w *WindowsFactory) CreateButton() Button       { return &WindowsButton{} }
func (w *WindowsFactory) CreateCheckbox() Checkbox   { return &WindowsCheckbox{} }

// ===== Mac 主题 =====
type MacButton struct{}

func (m *MacButton) Render() string { return "[Mac 风格按钮 · 圆角]" }

type MacCheckbox struct{}

func (m *MacCheckbox) Toggle() string { return "[Mac 复选框: ✓ · 半透明]" }

type MacFactory struct{}

func (m *MacFactory) CreateButton() Button       { return &MacButton{} }
func (m *MacFactory) CreateCheckbox() Checkbox   { return &MacCheckbox{} }

func BuildUI(factory UIFactory) {
    btn := factory.CreateButton()
    cb := factory.CreateCheckbox()
    fmt.Println(btn.Render())
    fmt.Println(cb.Toggle())
}

// 一键切换整套主题
BuildUI(&WindowsFactory{})  // 全部 Windows 风格
BuildUI(&MacFactory{})      // 全部 Mac 风格

package db

import (
    "database/sql"
    "sync"
)

var (
    instance *sql.DB
    once     sync.Once
)

// GetDB 返回唯一的数据库连接实例
func GetDB() *sql.DB {
    once.Do(func() {
        // 这段代码只会执行一次，无论多少个 goroutine 同时调用
        var err error
        instance, err = sql.Open("mysql", "user:pass@tcp(localhost:3306)/mydb")
        if err != nil {
            panic(err)
        }
    })
    return instance
}

var instance *Config

func init() {
    instance = &Config{
        Host: "localhost",
        Port: 8080,
    }
}

func GetConfig() *Config {
    return instance
}

var (
    instance *Logger
    mu       sync.Mutex
)

func GetLogger() *Logger {
    if instance == nil {
        mu.Lock()
        defer mu.Unlock()
        if instance == nil { // 双重检查
            instance = &Logger{}
        }
    }
    return instance
}