Golang 的静态特性如何减少对经典设计模式的依赖

很多人刚接触 Go 时，会本能地把 Java 的设计模式（GoF 23 种）套进去，结果写出一堆复杂的结构体 + 接口 + 工厂，结果发现：**Go 里很多经典模式要么简化了，要么干脆不需要了**。

为什么？因为 Go 是**静态类型 + 编译期决定一切**的语言，它缺少 Java 的“动态特性”（如运行时反射、继承、动态代理等），但也正是这些缺失，让 Go 避免了很多“为了绕弯子而发明”的模式。

下面用最常见的几个模式举例，告诉你 Go 是怎么“偷懒”却更简洁的。

### 1. 单例模式（Singleton） → 几乎不需要

Java 中经典单例：

```java
public class Logger {
    private static final Logger instance = new Logger();
    private Logger() {}
    public static Logger getInstance() { return instance; }
}
```

Go 里直接用**包级变量** + **init()**：

```go
package logger

var std = &Logger{}

func init() {
    std = NewLogger() // 或从配置加载
}

func Std() *Logger {
    return std
}
```

或者更简单：**全局变量就够了**（在小型服务中很常见）。

**为什么 Go 不需要复杂单例？**  
Go 是静态链接的二进制，没有类加载器、没有反射动态创建。包一旦导入，变量就存在了。并发安全用 `sync.Once` 包一下就行。

```go
var (
    once     sync.Once
    instance *Logger
)

func GetLogger() *Logger {
    once.Do(func() {
        instance = NewLogger()
    })
    return instance
}
```

### 2. 工厂模式（Factory） → 通常就是普通函数

Java 里：

```java
interface Transport { void deliver(); }
class Truck implements Transport { ... }
class Ship implements Transport { ... }

class TransportFactory {
    public static Transport create(String type) {
        if ("truck".equals(type)) return new Truck();
        if ("ship".equals(type)) return new Ship();
        throw new IllegalArgumentException();
    }
}
```

Go 里直接返回接口：

```go
type Transport interface {
    Deliver()
}

func NewTransport(typ string) Transport {
    switch typ {
    case "truck":
        return &Truck{}
    case "ship":
        return &Ship{}
    default:
        return nil // 或 panic / error
    }
}
```

**更地道做法**：直接用具名构造函数，不需要工厂类。

```go
func NewTruck() Transport { return &Truck{} }
func NewShip() Transport  { return &Ship{} }
```

因为 Go 接口是**隐式实现**，调用方不需要知道具体类型。

### 3. 策略模式（Strategy） → 接口 + 函数类型就够

Java 需要一堆类：

```java
interface PaymentStrategy { void pay(int amount); }
class CreditCard implements PaymentStrategy { ... }
class PayPal implements PaymentStrategy { ... }
```

Go 里函数本身可以是第一等公民：

```go
type PayFunc func(amount int) error

func ProcessPayment(pay PayFunc, amount int) error {
    return pay(amount)
}

// 使用
ProcessPayment(func(amount int) error {
    fmt.Println("Paying with credit card:", amount)
    return nil
}, 100)
```

或者用接口（但通常不需要一堆 struct）。

### 4. 装饰器模式（Decorator） → 嵌入 + 组合

Java 需要一堆 wrapper 类。

Go 直接用**嵌入**（embedding）：

```go
type Logger interface {
    Log(msg string)
}

type ConsoleLogger struct{}

func (c ConsoleLogger) Log(msg string) { fmt.Println(msg) }

type TimedLogger struct {
    Logger // 嵌入
}

func (t TimedLogger) Log(msg string) {
    fmt.Printf("[%s] ", time.Now().Format(time.Kitchen))
    t.Logger.Log(msg)
}
```

**一句话总结**：Go 用**组合优于继承** + **嵌入**，天然支持装饰。

### 5. 观察者模式（Observer） → channel + goroutine 更常见

Java 用一堆 Listener 接口。

Go 里直接用 **channel** 广播：

```go
type EventBus struct {
    subs map[string][]chan string
    mu   sync.RWMutex
}

func (b *EventBus) Subscribe(topic string) <-chan string {
    ch := make(chan string, 10)
    b.mu.Lock()
    b.subs[topic] = append(b.subs[topic], ch)
    b.mu.Unlock()
    return ch
}

func (b *EventBus) Publish(topic, msg string) {
    b.mu.RLock()
    for _, ch := range b.subs[topic] {
        ch <- msg
    }
    b.mu.RUnlock()
}
```

更简单场景：直接用 `chan` 就完事。

### 核心原因总结：Go 的“静态”让很多模式消失

| 特性                  | Java（动态/反射重）          | Go（静态/简单）                     | 结果                              |
|-----------------------|------------------------------|-------------------------------------|-----------------------------------|
| 接口实现              | 必须显式 implements          | 隐式实现（duck typing）             | 少写 adapter、proxy               |
| 继承                  | 广泛使用                     | 没有继承，只有嵌入 + 组合           | 少用 decorator、template method   |
| 函数一等公民          | 较晚支持 lambda              | 原生支持闭包、方法值                | 策略、命令、visitor 简化          |
| 反射/动态代理         | 强大（Spring AOP 等）        | 几乎不用（性能优先）                | 少用 proxy、动态工厂              |
| 包级作用域            | 没有（public/protected 等）  | 有（大写导出，小写私有）            | 少用 singleton、utility 类        |
| 并发原语              | Thread + synchronized        | goroutine + channel + sync 包      | observer、pub-sub 用 channel 代替 |

**一句话结论**：  
**设计模式是语言缺陷的补丁**。Go 通过简洁的语法（接口隐式、组合优先、函数一等、channel 原语）把很多“经典问题”直接消灭了，所以你写 Go 代码时，**少想模式，多想简单**。

记住 Rob Pike 的名言：

> “Less is exponentially more.”

写 Go 的时候，先问自己：**能不能用一个函数 / 一个接口 / 一个 channel 解决？**  
能的话，就别硬套工厂、单例、装饰器了。

Happy Go coding！🚀