Golang学习笔记_30——建造者模式
Golang学习笔记_31——原型模式
Golang学习笔记_32——适配器模式

---

---

桥接模式详解

一、桥接模式核心概念

1. 定义

桥接模式是一种 结构型设计模式，通过 将抽象部分与实现部分分离，使它们可以独立变化。它通过组合关系替代继承关系，解决多维度的扩展问题。

2. 解决的问题

• 多维度变化：当系统存在多个独立变化的维度时（如形状和颜色），避免类爆炸问题。
• 灵活扩展：允许抽象和实现部分独立扩展，无需修改原有代码。
• 降低耦合：通过组合关系替代继承，减少类之间的强依赖。

3. 核心角色

1. Abstraction（抽象化）：定义高层抽象接口，维护对实现化对象的引用。
2. RefinedAbstraction（扩展抽象化）：对抽象化的扩展，提供更精细的控制。
3. Implementor（实现化）：定义实现类的接口，提供基础操作。
4. ConcreteImplementor（具体实现化）：实现接口的具体类。

4. 类图

二、桥接模式的特点

优点

1. 解耦抽象与实现
   抽象层和实现层独立变化，提高系统灵活性。
2. 扩展性强
   新增维度只需添加对应实现类，无需修改现有代码。
3. 符合开闭原则
   对扩展开放，对修改关闭。

缺点

1. 设计复杂度增加
   需要正确识别系统中独立变化的维度。
2. 理解成本高
   组合关系比继承更难直观理解。

三、适用场景

1. 多维度变化

• 示例：图形绘制系统（形状 × 颜色 × 渲染引擎）
• 解决：将形状作为抽象，颜色和渲染作为独立实现。

2. 跨平台开发

• 示例：支持 Android/iOS 的 UI 组件库
• 解决：UI 组件抽象与平台具体实现分离。

3. 动态切换实现

• 示例：数据库驱动切换（MySQL/PostgreSQL）
• 解决：通过桥接接口动态替换底层实现。

四、与其他结构型模式的对比

模式	核心目标	关键区别
适配器	解决接口不兼容问题	关注接口转换，通常在系统设计后期使用
组合	处理树形结构	强调部分与整体的层次关系
桥接	分离抽象与实现	关注多维度的独立扩展

五、Go 语言代码示例

场景描述
实现跨平台图形渲染系统，支持不同形状（圆形/矩形）在不同平台（Windows/Linux）的绘制。

代码实现

package bridgedemo

import "fmt"

// Renderer 渲染器接口
type Renderer interface {
   RenderCircle(radius float32)
   RenderRectangle(width, height float32)
}

// WindowsRenderer windows渲染器实现
type WindowsRenderer struct{}

func (w *WindowsRenderer) RenderCircle(radius float32) {
   // 渲染windows矩形的实现
   fmt.Printf("windows render circle: radius = %f\n", radius)
}

func (w *WindowsRenderer) RenderRectangle(width, height float32) {
   // 渲染Windows矩形的实现
   fmt.Printf("windows render rectangle: width = %f, height = %f\n", width, height)
}

// LinuxRenderer linux渲染器实现
type LinuxRenderer struct{}

func (l *LinuxRenderer) RenderCircle(radius float32) {
   // 渲染Linux圆形的实现
   fmt.Printf("linux render circle: radius = %f\n", radius)
}

func (l *LinuxRenderer) RenderRectangle(width, height float32) {
   // 渲染Linux矩形的实现
   fmt.Printf("linux render rectangle: width = %f, height = %f\n", width, height)
}

// Shape 图形接口
type Shape interface {
   Draw()
}

// Circle 圆形
type Circle struct {
   Radius   float32
   Renderer Renderer
}

func NewCircle(radius float32, renderer Renderer) *Circle {
   return &Circle{
      Radius:   radius,
      Renderer: renderer,
   }
}

func (c *Circle) Draw() {
   c.Renderer.RenderCircle(c.Radius)
}

// Rectangle 矩形
type Rectangle struct {
   Width    float32
   Height   float32
   Renderer Renderer
}

func newRectangle(width, height float32, renderer Renderer) *Rectangle {
   return &Rectangle{
      Width:    width,
      Height:   height,
      Renderer: renderer,
   }
}

func (r *Rectangle) Draw() {
   r.Renderer.RenderRectangle(r.Width, r.Height)
}

func test() {
   // 创建Windows渲染器
   windowsRenderer := &WindowsRenderer{}
   // 创建Linux渲染器
   linuxRenderer := &LinuxRenderer{}

   // 创建跨平台图形
   shapes := []Shape{
      NewCircle(5.0, windowsRenderer),
      NewCircle(8.0, linuxRenderer),
      newRectangle(10.0, 20.0, windowsRenderer),
      newRectangle(15.0, 25.0, linuxRenderer),
   }

   // 绘制图形
   for _, shape := range shapes {
      shape.Draw()
   }
}

输出结果

=== RUN   Test_test
windows render circle: radius = 5.000000
linux render circle: radius = 8.000000
windows render rectangle: width = 10.000000, height = 20.000000
linux render rectangle: width = 15.000000, height = 25.000000
--- PASS: Test_test (0.00s)
PASS

六、桥接模式的高级用法

1. 多维度组合

// 添加颜色维度
type ColorImplementor interface {
    SetColor(color string)
}

type ColoredShape struct {
    shape  Shape
    color  string
}

func (c *ColoredShape) Draw() {
    fmt.Printf("设置颜色: %s\n", c.color)
    c.shape.Draw()
}

2. 动态切换实现

// 运行时切换渲染引擎
rect := NewRectangle(winRenderer, 15, 25)
rect.Draw() // Windows渲染

rect.renderer = linuxRenderer
rect.Draw() // Linux渲染

七、总结

桥接模式通过 分离抽象与实现 解决多维度扩展问题，特别适合以下场景：

1. 多维度变化：独立管理不同维度的变化
2. 跨平台开发：统一抽象接口，差异化实现
3. 动态配置：运行时切换实现逻辑

在 Go 中实现时需注意 组合优于继承 的原则，通过接口定义清晰的抽象边界。当系统存在多个独立变化维度时，桥接模式能显著降低代码复杂度。