设计模式--建造者(Builder)模式

将一个复杂对象的创建与他的表示分离，使得同样的构建过程可以创建不同的表示

1.需要生成的对象具有复杂的内部结构；

2.需要生成的对象内部属性本身相互依赖；

3.与不可变对象配合使用；

1.建造者独立，易扩展；

2.便于控制细节风险；

• Builder模式主要用于“分步骤构建一个复杂的对象”，在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化
• 变化点在哪里，封装哪里----Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动，其缺点在于难以应对“分步骤构建算法”的需求变动

Go语言代码实现

Builder.go

package Builder

type Builder interface {
   Part1()
   Part2()
   Part3()
}

type Director struct {
   builder Builder //建造者的接口
}

//创造接口
func NewDirector (builder Builder) *Director {
   return &Director{builder: builder}
}


func (d *Director) Makedata(){
   d.builder.Part1()
   d.builder.Part2()
   d.builder.Part3()
}

StringBuilder.go

package Builder

type StringBuilder struct {
   result string
}

func (sb *StringBuilder) Part1 ()  {
   sb.result += "1"
}

func (sb *StringBuilder) Part2 ()  {
   sb.result += "2"
}

func (sb *StringBuilder) Part3 ()  {
   sb.result += "3"
}

func (sb *StringBuilder) GetResult() string {
   return sb.result
}

IntBuilder.go

package Builder

type IntBuilder struct {
   result int64
}

func (ib *IntBuilder) Part1 ()  {
   ib.result += 1
}

func (ib *IntBuilder) Part2 ()  {
   ib.result += 2
}

func (ib *IntBuilder) Part3 ()  {
   ib.result += 3
}

func (ib *IntBuilder) GetResult() int64 {
   return ib.result
}

Builder_test.go

package Builder

import (
   "fmt"
   "testing"
)

func TestIntBuilder(t *testing.T) {
   sbuilder := &StringBuilder{}
   dict := NewDirector(sbuilder)
   dict.Makedata()
   fmt.Println(sbuilder.GetResult())

   ibuilder := &IntBuilder{}
   dict = NewDirector(ibuilder)
   dict.Makedata()
   fmt.Println(ibuilder.GetResult())
}