go中的建造者模式

package main

import "fmt"

/*
意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

何时使用：一些基本部件不会变，而其组合经常变化的时候。

如何解决：将变与不变分离开。

关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

应用实例： 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。 2、JAVA 中的 StringBuilder。

优点： 1、建造者独立，易扩展。 2、便于控制细节风险。

缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。

使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。



*/

// 定义一个建造者接口
type Builder interface {
	BuilderCpu()
	BuilderDisk()
	BuilderMemory()
}

// 高端电脑
type HighComputer struct {}

func (h *HighComputer) BuilderCpu(){
	fmt.Println("建造一个高级的cpu........")
}

func (h *HighComputer) BuilderDisk(){
	fmt.Println("建造一个高级的硬盘........")
}

func (h *HighComputer) BuilderMemory(){
	fmt.Println("建造一个高级的内存........")
}

// 低端电脑
type LowComputer struct {}

func (h *LowComputer) BuilderCpu(){
	fmt.Println("建造一个低级的cpu........")
}

func (h *LowComputer) BuilderDisk(){
	fmt.Println("建造一个低级的硬盘........")
}

func (h *LowComputer) BuilderMemory(){
	fmt.Println("建造一个低级的内存........")
}

// 混合型电脑
type MixtureComputer struct {}

func (h *MixtureComputer) BuilderCpu(){
	fmt.Println("建造一个低级的cpu........")
}

func (h *MixtureComputer) BuilderDisk(){
	fmt.Println("建造一高级的硬盘........")
}

func (h *MixtureComputer) BuilderMemory(){
	fmt.Println("建造一个高级的内存........")
}


type Drictor struct {
	builder Builder
}

func NewConstruct(b Builder) *Drictor {
	return &Drictor{builder: b}
}

func (d *Drictor) Construct(){
	d.builder.BuilderCpu()
	d.builder.BuilderDisk()
	d.builder.BuilderMemory()
}


func main() {
	// 高级电脑
	hc := HighComputer{}
	d := NewConstruct(&hc)
	d.Construct()

	// 混合型电脑
	mc := MixtureComputer{}
	d1 := NewConstruct(&mc)
	d1.Construct()

	// 混合型电脑
	lc := LowComputer{}
	d2 := NewConstruct(&lc)
	d2.Construct()

	/*
	建造一个高级的cpu........
	建造一个高级的硬盘........
	建造一个高级的内存........
	建造一个低级的cpu........
	建造一高级的硬盘........
	建造一个高级的内存........
	建造一个低级的cpu........
	建造一个低级的硬盘........
	建造一个低级的内存........
	*/
}

package main

import "fmt"

/*
意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

何时使用：一些基本部件不会变，而其组合经常变化的时候。

如何解决：将变与不变分离开。

关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

应用实例： 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。 2、JAVA 中的 StringBuilder。

优点： 1、建造者独立，易扩展。 2、便于控制细节风险。

缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。

使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

*/

type Builder interface {
	Build()
}

type Director struct {
	builder Builder
}

func NewBuilder(b Builder) Director {
	return Director{builder:b}
}

func (d *Director) Construct(){
	d.builder.Build()
}

func NewDirector(builder Builder) Director {
	return Director{builder:builder}
}



type ConcreteBuilder struct {
	built bool
}

func NewConcreteBuilder() ConcreteBuilder {
	return ConcreteBuilder{built:false}
}

func (b *ConcreteBuilder) Build() {
	fmt.Println("我被调用了。。。。")
	b.built = true
}



type Product struct {
	Built bool
}

func (b *ConcreteBuilder) GetResult() Product {
	return Product{b.built}
}
func main() {
	cb := NewConcreteBuilder()
	d := NewDirector(&cb)
	d.Construct()
	p := cb.GetResult()
	fmt.Println(p.Built)

	/*
	我被调用了。。。。
	true
	*/
}