缘起

最近复习设计模式
拜读谭勇德的<<设计模式就该这样学>>
本系列笔记拟采用golang练习之

组合模式

组合模式（Composite Pattern）又叫作整体-部分（Part-Whole）模式，它的宗旨是通过将单个对象（叶子节点）和组合对象（树枝节点）用相同的接口进行表示，使得客户对单个对象和组合对象的使用具有一致性，属于结构型设计模式。
_

透明组合vs安全组合

  • 透明组合: 叶子节点和树枝节点具有完全一致的接口
  • 安全组合: 叶子节点和树枝节点从公共接口继承, 并做个性化扩展

场景

  • 某线上学校, 提供系列java学习课程
  • 提供某些简单课程, 如”java基础”, 学员可一次性学完
  • 提供某些组合课程, 内部包含了若干简单课程, 如”java架构师”课程, 内部包含”java基础”, “java高级编程”等多门课程, 需要分步依次学习, 才能完成
  • 为方便业务层调用, 根据安全组合模式, 简单课程和组合课程均实现公共接口的Learn方法.

设计

  • IUser: 定义学员用户接口
  • ICourse: 定义课程的公共接口
  • ICompositeCourse: 组合课程的个性化接口, 从ICourse继承, 并添加了Append(子课程)的方法
  • tMockUser: 虚拟学员的实现类
  • tSimpleCourse: 简单课程的实现类, 实现ICourse接口
  • tCompositeCourse: 组合课程的实现类, 继承tSimpleCourse, 并实现了ICompositeCourse接口

单元测试

composite_pattern_test.go

  1. package structural_patterns
  3. import (
  4.     "learning/gooop/structural_patterns/composite"
  5.     "testing"
  6. )
  8. func Test_CompositePattern(t *testing.T) {
  9.     user := composite.NewMockUser(1, "张三")
  11.     sc := composite.NewSimpleCourse(11, "Java基础", 100)
  12.     user.Learn(sc)
  14.     user = composite.NewMockUser(2, "李四")
  15.     cc := composite.NewCompositeCourse(21, "Java架构师", 500)
  16.     cc.Append(composite.NewSimpleCourse(11, "Java基础", 100))
  17.     cc.Append(composite.NewSimpleCourse(12, "Java高级编程", 100))
  18.     cc.Append(composite.NewSimpleCourse(13, "设计模式", 100))
  19.     cc.Append(composite.NewSimpleCourse(14, "Spring技术内幕", 100))
  20.     cc.Append(composite.NewSimpleCourse(15, "SpringCloud架构指南", 100))
  21.     user.Learn(cc)
  22. }

测试输出

  1. $ go test -v composite_pattern_test.go 
  2. === RUN   Test_CompositePattern
  3. 张三 is learning Java基础
  4. 李四 is learning Java架构师.Java基础
  5. 李四 is learning Java架构师.Java高级编程
  6. 李四 is learning Java架构师.设计模式
  7. 李四 is learning Java架构师.Spring技术内幕
  8. 李四 is learning Java架构师.SpringCloud架构指南
  9. --- PASS: Test_CompositePattern (0.00s)
  10. PASS
  11. ok      command-line-arguments  0.005s

IUser.go

定义学员用户接口

  1. package composite
  3. type IUser interface {
  4.     ID() int
  5.     Name() string
  6.     Learn(course ICourse)
  7. }

ICourse.go

定义课程的公共接口

  1. package composite
  3. type ICourse interface {
  4.     ID() int
  5.     Name() string
  6.     Price() float64
  8.     SetUser(user IUser)
  9.     Learn() LearningStates
  10. }
  13. type LearningStates int
  14. const MORE LearningStates = 1
  15. const DONE LearningStates = 2

ICompositeCourse.go

组合课程的个性化接口, 从ICourse继承, 并添加了Append(子课程)的方法

  1. package composite
  3. type ICompositeCourse interface {
  4.     ICourse
  6.     Append(course ICourse)
  7. }

tMockUser.go

虚拟学员的实现类

  1. package composite
  4. type tMockUser struct {
  5.     iID int
  6.     sName string
  7. }
  9. func NewMockUser(id int, name string) IUser {
  10.     return &tMockUser{
  11.         id, name,
  12.     }
  13. }
  15. func (me *tMockUser) ID() int {
  16.     return me.iID
  17. }
  19. func (me *tMockUser) Name() string {
  20.     return me.sName
  21. }
  23. func (me *tMockUser) Learn(course ICourse) {
  24.     course.SetUser(me)
  26.     for {
  27.         state := course.Learn()
  28.         if state == DONE {
  29.             break
  30.         }
  31.     }
  32. }

tSimpleCourse.go

简单课程的实现类, 实现ICourse接口

  1. package composite
  3. import "fmt"
  5. type tSimpleCourse struct {
  6.     iID int
  7.     sName string
  8.     fPrice float64
  9.     mUser IUser
  10. }
  13. func NewSimpleCourse(id int, name string, price float64) ICourse {
  14.     return &tSimpleCourse{
  15.         id, name, price, nil,
  16.     }
  17. }
  19. func (me *tSimpleCourse) ID() int {
  20.     return me.iID
  21. }
  23. func (me *tSimpleCourse) Name() string {
  24.     return me.sName
  25. }
  27. func (me *tSimpleCourse) Price() float64 {
  28.     return me.fPrice
  29. }
  31. func (me *tSimpleCourse) SetUser(user IUser) {
  32.     me.mUser = user
  33. }
  35. func (me *tSimpleCourse) Learn() LearningStates {
  36.     fmt.Printf("%s is learning %s\n", me.mUser.Name(), me.sName)
  37.     return DONE
  38. }

tCompositeCourse.go

组合课程的实现类, 继承tSimpleCourse, 并实现了ICompositeCourse接口

  1. package composite
  3. import "fmt"
  5. type tCompositeCourse struct {
  6.     tSimpleCourse
  8.     mCourseList []ICourse
  9.     iCourseIndex int
  10. }
  13. func NewCompositeCourse(id int, name string, price float64) ICompositeCourse {
  14.     return &tCompositeCourse {
  15.         tSimpleCourse: tSimpleCourse{
  16.             id, name, price, nil,
  17.         },
  18.         mCourseList: make([]ICourse, 0),
  19.         iCourseIndex: 0,
  20.     }
  21. }
  23. func (me *tCompositeCourse) Append(course ICourse) {
  24.     me.mCourseList = append(me.mCourseList, course)
  25. }
  27. func (me *tCompositeCourse) Learn() LearningStates {
  28.     if me.IsDone() {
  29.         fmt.Printf("%s is learning %s: no more courses\n", me.mUser.Name(), me.Name())
  30.         return DONE
  31.     }
  34.     course := me.mCourseList[me.iCourseIndex]
  35.     fmt.Printf("%s is learning %s.%s\n", me.mUser.Name(), me.Name(), course.Name())
  36.     me.iCourseIndex++
  38.     if me.IsDone() {
  39.         return DONE
  40.     } else {
  41.         return MORE
  42.     }
  43. }
  45. func (me *tCompositeCourse) IsDone() bool {
  46.     return me.iCourseIndex >= len(me.mCourseList)
  47. }

组合模式小结

组合模式的优点
（1）清楚地定义各层次的复杂对象，表示对象的全部或部分层次。
（2）让客户端忽略了层次的差异，方便对整个层次结构进行控制。
（3）简化客户端代码。
（4）符合开闭原则。
组合模式的缺点
（1）限制类型时会较为复杂。
（2）使设计变得更加抽象。

(end)