go语言设计模式-里氏代换与依赖倒转原则

里氏代换LSP ：任何抽象类(interface接口)出现的地方都可以用它的实现类进行替换，实际就是虚拟机制，语言级别实现面向对象功能。能用实例和接口的尽可能抽象成接口，然后用子类来实现。

依赖倒转原则DIP: 依赖于抽象(接口)，不要依赖具体实现(类)，也就是针对接口编程。

耦合度极高的业务实现：

package main

import "fmt"

//司机张三 李四，汽车奔驰 宝马
//1 张3 开奔驰
//2 李4 开宝马

//奔驰汽车
type Benz struct {
}

func (b *Benz) Run() {
  fmt.Println("Benz is running...")
}

//宝马汽车
type BMW struct {
}

func (b *BMW) Run() {
  fmt.Println("BMW is running...")
}

//司机张三
type Zhang3 struct {
  //...
}

func (z3 *Zhang3) DriveBenz(ben *Benz) {
  fmt.Println("zhang3 Drive benz")
  ben.Run()
}

// 新+ 司机张三开宝马
func (z3 *Zhang3) DriveBmw(bmw *BMW) {
  fmt.Println("z3 Drive BMW")
  bmw.Run()
}

//司机李四
type Li4 struct {
  //...
}

func (l4 *Li4) DriveBmw(bmw *BMW) {
  fmt.Println("li4 Drive BMW")
  bmw.Run()
}

//新+ 司机李四开奔驰
func (l4 *Li4) DriveBenz(ben *Benz) {
  fmt.Println("z3 Drive Benz")
  ben.Run()
}

func main() {
  //1 张3 开奔驰
  benz := &Benz{}
  zhang3 := Zhang3{}
  zhang3.DriveBenz(benz)

  //2 李4 开宝马
  bmw := &BMW{}
  li4 := Li4{}
  li4.DriveBmw(bmw)
}

如下图所示，新增丰田车需要了解张三，李四的drive方法是如何实现的，它们是如何调用drive方法的。这样每次新加人物或者汽车都需要尝试跟其所依赖的每个接口进行耦合式调试，使得系统的稳定性维护和改造变得极其困难。

如下图所示，如果我们在设计一个系统的时候，将模块分为3个层次，抽象层、实现层、业务逻辑层。那么首先将抽象层的模块和接口定义出来，这里就需要interface接口的设计，我们依照抽象层，依次实现每个实现层的模块，在我们写实现层的代码的时候，实际上我们只需要参照对应的抽象层实现就好了，实现每个模块，也和其他的实现的模块没有关系，这样也符合了上面介绍的开闭原则。这样实现起来每个模块只依赖对象的接口，而和其他的模块没关系，依赖关系单一。系统容易扩展和维护。

依赖倒转原则改造耦合度极高的业务实现：

此时新增汽车只需要知道抽象汽车有哪些方法就行了，而无需关注司机方法的实现。

package main

import "fmt"

//---抽象层---
type Car interface {
  Run()
}

type Driver interface {
  Drive(car Car)
}

//---实现层---
type BenZ struct {
  //...
}

func (b *BenZ) Run() {
  fmt.Println("Benz is Running...")
}

type Bmw struct {
  //...
}

func (b *Bmw) Run() {
  fmt.Println("Bmw is Running...")
}

// 编写zhangsan lisi面向drive方法，无须关注奔驰宝马的实现,知道car如何调用Run方法即可
type Zhangsan struct {
  //...
}

func (z3 *Zhangsan) Drive(car Car) {
  fmt.Println("zhang3 drive car")
  car.Run()
}

type Lisi struct {
  //...
}

func (l4 *Lisi) Drive(car Car) {
  fmt.Println("li4 drive car")
  car.Run()
}

//---业务逻辑层---
func main() {
  // zhang3-benz
  var benz Car //面向抽象层
  benz = new(BenZ)

  var zhang3 Driver //面向抽象层
  zhang3 = new(Zhangsan)
  zhang3.Drive(benz)

  //li4---bmw
  var bmw Car
  bmw = new(Bmw)

  var li4 Driver
  li4 = new(Lisi)
  li4.Drive(bmw)
}

结果：

zhang3 drive car
Benz is Running...
li4 drive car
Bmw is Running...