缘起

最近复习设计模式
拜读谭勇德的<<设计模式就该这样学>>
该书以java语言演绎了常见设计模式
本系列笔记拟采用golang练习之

依赖倒置原则

  • 依赖倒置原则（Dependence Inversion Principle, DIP）指设计代码结构时，高层模块不应该依赖底层模块，二者都应该依赖其抽象。
  • 抽象不应该依赖细节，细节应该依赖抽象。
  • 常见的依赖注入方式有: 方法参数注入, 构造器参数注入, setter方法注入

_

场景

  • 线上学校有一系列课程
  • 用户可选择若干门课程进行学习
  • 如果把学习课程的过程直接实现为用户的方法, 则每增加一门课程, 就需要增加一个学习方法
  • 根据依赖倒置原则, 可以把学习过程抽象为学习接口, 由不同的课程实例各自实现

BadUser.go

不好的示例: BadUser以不同方法实现各种课程的学习过程, 课程的增加导致BadUser代码越来越臃肿

  1. package dependence_inversion
  3. import "fmt"
  5. type BadUser struct {
  6.     iID int
  7.     sName string
  8. }
  10. func NewBadUser(id int, name string) *BadUser {
  11.     return &BadUser{
  12.         iID: id,
  13.         sName: name,
  14.     }
  15. }
  17. func (me *BadUser) StudyJavaCourse() {
  18.     fmt.Printf("%v is learning %v\n", me.sName, "java")
  19. }
  21. func (me *BadUser) StudyGolangCourse() {
  22.     fmt.Printf("%v is learning %v\n", me.sName, "golang")
  23. }

GoodUser.go

GoodUser通过实现IUser接口提供用户基本信息, 并把不同课程的学习过程, 委托给ICourse接口去实现

  1. package dependence_inversion
  4. type IUser interface {
  5.     ID() int
  6.     Name() string
  7.     Study(ICourse)
  8. }
  11. type GoodUser struct {
  12.     iID int
  13.     sName string
  14. }
  16. func NewGoodUser(id int, name string) IUser {
  17.     return &GoodUser{
  18.         iID: id,
  19.         sName: name,
  20.     }
  21. }
  23. func (me *GoodUser) ID() int {
  24.     return me.iID
  25. }
  27. func (me *GoodUser) Name() string {
  28.     return me.sName
  29. }
  31. func (me *GoodUser) Study(course ICourse) {
  32.     course.SetUser(me)
  33.     course.Study()
  34. }

GolangCourse.go

通过setter方法注入IUser, ICourse接口封装了具体课程的学习过程

  1. package dependence_inversion
  3. import "fmt"
  5. type ICourse interface {
  6.     ID() int
  7.     Name() string
  8.     SetUser(IUser)
  9.     Study()
  10. }
  12. type GolangCourse struct {
  13.     iID int
  14.     sName string
  15.     xCurrentUser IUser
  16. }
  18. func NewGolangCourse() ICourse {
  19.     return &GolangCourse{
  20.         iID: 11,
  21.         sName: "golang",
  22.         xCurrentUser: nil,
  23.     }
  24. }
  26. func (me *GolangCourse) ID() int {
  27.     return me.iID
  28. }
  31. func (me *GolangCourse) Name() string {
  32.     return me.sName
  33. }
  35. func (me *GolangCourse) SetUser(user IUser) {
  36.     me.xCurrentUser = user
  37. }
  39. func (me *GolangCourse) Study() {
  40.     fmt.Printf("%v is learning %v\n", me.xCurrentUser.Name(), me.Name())
  41. }

dependence_inversion_test.go

测试用例

  1. package main
  3. import "testing"
  4. import (
  5.     dip "learning/gooop/principles/dependence_inversion"
  6. )
  8. func TestDIP(t *testing.T) {
  9.     bu := dip.NewBadUser(1, "Tom")
  10.     bu.StudyGolangCourse()
  12.     gu := dip.NewGoodUser(2, "Mike")
  13.     gu.Study(dip.NewGolangCourse())
  14. }

测试输出

  1. $ go test -v main/dependence_inversion_test.go 
  2. === RUN   TestDIP
  3. Tom is learning golang
  4. Mike is learning golang
  5. --- PASS: TestDIP (0.00s)
  6. PASS
  7. ok      command-line-arguments  0.002s