桥接是一种结构型设计模式， 可将事务逻辑或一个大类拆分为不同的层次结构， 从而能独登时进行开发。

层次结构中的第一层 （一般称为笼统部分） 将包括对第二层 （完成部分） 对象的引证。 笼统部分将能将一些 （有时是绝大部分） 对自己的调用委派给完成部分的对象。 所有的完成部分都有一个通用接口， 因而它们能在笼统部分内部彼此替换。

概念示例

假设你有两台电脑： 一台 Mac 和一台 Windows。 还有两台打印机： 爱普生和惠普。 这两台电脑和打印机可能会任意组合运用。 客户端不该去忧虑如何将打印机连接至计算机的细节问题。

如果引进新的打印机， 咱们也不会希望代码量成倍增长。 所以， 咱们创建了两个层次结构， 而不是 2×2 组合的四个结构体：

  • 笼统层： 代表计算机
  • 施行层： 代表打印机

这两个层次可通过桥接进行沟通， 其中笼统层 （计算机） 包括对于施行层 （打印机） 的引证。 笼统层和施行层均可独立开发， 不会彼此影响。

computer.go: 笼统

package main
type Computer interface {
    Print()
    SetPrinter(Printer)
}

mac.go: 准确笼统

package main
import "fmt"
type Mac struct {
    printer Printer
}
func (m *Mac) Print() {
    fmt.Println("Print request for mac")
    m.printer.PrintFile()
}
func (m *Mac) SetPrinter(p Printer) {
m.printer = p
}

windows.go: 准确笼统

package main
import "fmt"
type Windows struct {
    printer Printer
}
func (w *Windows) Print() {
    fmt.Println("Print request for windows")
    w.printer.PrintFile()
}
func (w *Windows) SetPrinter(p Printer) {
w.printer = p
}

printer.go: 施行

package main
type Printer interface {
    PrintFile()
}

epson.go: 具体施行

package main
import "fmt"
type Epson struct {}
func (p \*Epson) PrintFile() {
    fmt.Println("Printing by a EPSON Printer")
}

hp.go: 具体施行

package main
import "fmt"
type Hp struct {}
func (p *Hp) PrintFile() {
    fmt.Println("Printing by a HP Printer")
}

main.go: 客户端代码

package main
import "fmt"
func main() {
    hpPrinter := &Hp{}
    epsonPrinter := &Epson{}
    macComputer := &Mac{}
    macComputer.SetPrinter(hpPrinter)
    macComputer.Print()
    fmt.Println()
    macComputer.SetPrinter(epsonPrinter)
    macComputer.Print()
    fmt.Println()
    winComputer := &Windows{}
    winComputer.SetPrinter(hpPrinter)
    winComputer.Print()
    fmt.Println()
    winComputer.SetPrinter(epsonPrinter)
    winComputer.Print()
    fmt.Println()
}

output.txt: 履行成果

Print request for mac
Printing by a HP Printer
Print request for mac
Printing by a EPSON Printer
Print request for windows
Printing by a HP Printer
Print request for windows