设计模式2-创造型模式及应用

// -----抽象层-----
// 构建引擎接口
type Engine interface {
  Build()
  Push()
  Clean()
}

// -----实现层-----
// Docker引擎，实现Engine接口
type EDocker struct {}
func (d *EDocker)Build() {}
func (d *EDocker)Push() {}
func (d *EDocker)Clean() {}

// Img引擎，实现Engine接口
type EImg struct {}
func (i *EImg)Build() {}
func (i *EImg)Push() {}
func (i *EImg)Clean() {}

// -----工厂模块-----
// 简单工厂
type SimpleFactory struct {}
// 创造引擎
func (s *SimpleFactory) NewEngine(name string) Engine{
  if name == "docker" {
    return &EDocker{}
  } else if name == "img" {
    return &EImg{}
  }
  return &EDocker{}
}

// -----业务逻辑层-----
func main() {
  // 初始化一个工厂
  f := SimpleFactory{}
  // 工厂造引擎
  engine := f.NewEngine("img")
  // 拿到引擎
  engine.build()
}	

package main

type Engine interface {
	Build()
	Push()
	Clean()
}

type AbstractFactory interface {
	CreateEngine() Engine
}

// -----实现层-----
// Docker引擎，实现Engine接口
type EDocker struct{}

func (d *EDocker) Build() {}
func (d *EDocker) Push()  {}
func (d *EDocker) Clean() {}

// Img引擎，实现Engine接口
type EImg struct{}

func (i *EImg) Build() {}
func (i *EImg) Push()  {}
func (i *EImg) Clean() {}

// -----工厂模块-----
// Docker引擎工厂
type EDockerFactory struct {}

// 实现抽象工厂接口
func (s *EDockerFactory) CreateEngine() Engine {
	return &EDocker{}
}

// Img引擎工厂
type EImgFactory struct{}

// 实现抽象工厂接口
func (s *EImgFactory) CreateEngine() Engine {
	return &EImg{}
}

// -----业务逻辑层-----
func main() {
	// 初始化抽象工厂
	var DockerFac AbstractFactory

	// 选择一个工厂
	DockerFac = &EDockerFactory{}
	d := DockerFac.CreateEngine()
	d.Build()

	var ImgFac AbstractFactory

	// 选择一个工厂
	ImgFac = &EImgFactory{}
	i := ImgFac.CreateEngine()
	i.Build()
}

package main

// -----抽象层-----
type AbstractEDocker interface {
	Build()
	Push()
	Clean()
}
type AbstractEImg interface {
	Build()
	Push()
	Clean()
}

type AbstractFactory interface {
	CreateDockerEngine() AbstractEDocker
	CreateImgEngine() AbstractEImg
}

// -----实现层-----
// test版本Docker引擎，实现Engine接口
type TestEDocker struct{}

func (d *TestEDocker) Build() {}
func (d *TestEDocker) Push()  {}
func (d *TestEDocker) Clean() {}

// test版本Img引擎，实现Engine接口
type TestEImg struct{}

func (i *TestEImg) Build() {}
func (i *TestEImg) Push()  {}
func (i *TestEImg) Clean() {}

// -----工厂模块-----
// test版本工厂
type TestVersionFactory struct{}

func (f *TestVersionFactory) CreateDockerEngine() AbstractEDocker {
	return &TestEDocker{}
}
func (f *TestVersionFactory) CreateImgEngine() AbstractEImg {
	return &TestEImg{}
}

// release版本Docker引擎，实现Engine接口
type ReleaseEDocker struct{}

func (d *ReleaseEDocker) Build() {}
func (d *ReleaseEDocker) Push()  {}
func (d *ReleaseEDocker) Clean() {}

// test版本Img引擎，实现Engine接口
type ReleaseEImg struct{}

func (i *ReleaseEImg) Build() {}
func (i *ReleaseEImg) Push()  {}
func (i *ReleaseEImg) Clean() {}

// release版本工厂
type ReleaseVersionFactory struct{}

func (f *ReleaseVersionFactory) CreateDockerEngine() AbstractEDocker {
	return &ReleaseEDocker{}
}
func (f *ReleaseVersionFactory) CreateImgEngine() AbstractEImg {
	return &ReleaseEImg{}
}

// -----业务逻辑层-----
func main() {
	// 初始化抽象工厂
	var Fac AbstractFactory
	// 创建测试版本的工厂
	Fac = &TestVersionFactory{}
	// 创建一个测试版本的Img引擎
	ti := Fac.CreateImgEngine()
	ti.Build()
	// 创建一个测试版本的docker引擎
	td := Fac.CreateDockerEngine()
	td.Build()

	// 创建公开版本的工厂
	Fac = &ReleaseVersionFactory{}
	ri := Fac.CreateImgEngine()
	ri.Build()

	rd := Fac.CreateDockerEngine()
	rd.Build()
}

package main

import "fmt"

/*
三个要点：
		一是某个类只能有一个实例；
		二是它必须自行创建这个实例；
		三是它必须自行向整个系统提供这个实例。
*/

/*
	保证一个类永远只能有一个对象
*/


//1、保证这个类非公有化，外界不能通过这个类直接创建一个对象
//   那么这个类就应该变得非公有访问 类名称首字母要小写
type singelton struct {}

//2、但是还要有一个指针可以指向这个唯一对象，但是这个指针永远不能改变方向
//   Golang中没有常指针概念，所以只能通过将这个指针私有化不让外部模块访问
var instance *singelton = new(singelton)

//3、如果全部为私有化，那么外部模块将永远无法访问到这个类和对象，
//   所以需要对外提供一个方法来获取这个唯一实例对象
//   注意：这个方法是否可以定义为singelton的一个成员方法呢？
//       答案是不能，因为如果为成员方法就必须要先访问对象、再访问函数
//        但是类和对象目前都已经私有化，外界无法访问，所以这个方法一定是一个全局普通函数
func GetInstance() *singelton {
	return instance
}

func (s *singelton) SomeThing() {
	fmt.Println("单例对象的某方法")
}

func main() {
	s := GetInstance()
	s.SomeThing()
}