概念

依赖倒置原则，是面向对象设计原则 SOLID 中的 D（Dependency Inversion），核心要义是：不要让高层依赖底层，而要让底层依赖高层的抽象。听起来和依赖注入很像对不对？实际上，依赖注入的最主要目的，就是为了实现依赖倒置。一个是手段，一个是目的。

代码实现

package dependency_inversion

type DiInterface interface {
    Config() bool
    Conn()
    Name() string
}

func Exec(di DiInterface) {
    if di.Config() {
       di.Conn()
    } else {
       println(di.Name() + " not config yet")
    }
}

测试代码实现

package dependency_inversion

import (
    "fmt"
    "testing"
)

type redisConn struct {
}

func (r *redisConn) Name() string {
    return "redis"
}

func (r *redisConn) Config() bool {
    return true
}

func (r *redisConn) Conn() {
    fmt.Println("redis connected success")
}

type mysqlConn struct {
}

func (m *mysqlConn) Name() string {
    return "mysql"
}

func (m *mysqlConn) Config() bool {
    return false
}

func (m *mysqlConn) Conn() {
    fmt.Println("mysql conn success")
}

func TestExec(t *testing.T) {
    m := mysqlConn{}
    Exec(&m)
    r := redisConn{}
    Exec(&r)
}

执行结果

=== RUN   TestExec
mysql not config yet
redis connected success
--- PASS: TestExec (0.00s)
PASS

总结

依赖倒置是一种通用的软件设计原则，不要让高层依赖底层，而要让底层依赖高层的抽象。

这个是我根据别人的博客里面的概念理解实现的，如有谬误欢迎指出