2.创建型--工厂模式

• 简单工厂

        在简单工厂模式中，可以根据参数的不同返回不同类的实例；但是如果要想新增一种产品的时候，需要在运算工厂里的方法加‘Case’分支条件的，修改原有的类，违反了“开放-封闭原则”。

        依赖唯一的工厂对象，如果我们需要实例化一个产品，那么就要向工厂对象中传入一个参数获取对应对象，如果要增加一种产品，就要在工厂中修改创建产品的函数，耦合度过高。

pakcage factory

//声明工厂结构体
type Factory struct {
}

//声明产品的接口
type Product interface {
   create()
}

//产品A
type ProductA struct {
}

func (pA ProductA) create() {
   fmt.Println("这是产品A")
}

//产品B
type ProductB struct {
}

func (pB ProductB) create() {
   fmt.Println("这是产品B")
}

//为工厂结构体添加方法用于生产产品
func (f Factory) Generate(name string) Product {
   switch name {
   case "productA":
      return ProductA{}
   case "productA":
      return ProductB{}
   default:
      return nil
   }
}

//测试简单工厂
func TestSimpleFactory(t *testing.T) {
   //创建一个工厂类
   factory := new(Factory)

   pA := factory.Generate("productA")
   pA.create()

   pB := factory.Generate("productB")
   pB.create()
}

• 工厂模式

定义一个用于创建对象的接口，让子类界定实例化哪个类。工厂方法使一个类的实例化延迟到子类。

        依赖工厂接口，我们可以通过实现工厂接口，创建多种工厂，将对象创建由一个对象负责所有具体类的实例化变成由一群子类来负责对具体类的实例化，将过程解耦。

        工厂模式与简单工厂模式的最大区别就是增加了一个工厂接口，使所有工厂都 依赖这个工厂接口。

pakcage factorymethod

//声明工厂接口
type FactoryInterface interface {
   CreateProduct(t string) ProductInterface
}

//工厂A结构体实现工厂接口，生产产品A
type FactoryA struct {
}

func (f FactoryA) CreateProduct(t string) ProductInterface {
    switch t {
    case "productA":
        return productA{}
    default:
        return nil
    }
}

//产品接口
type ProductInterface interface {
   ShowProduct()
}

//声明产品A结构体
type productA struct {
}

//实现产品A的接口
func (p productA) ShowProduct() {
   fmt.Println("这是产品A")
}

//测试工厂方法接口
func TestFactoryMethod(t *testing.T) {
   f := new(FactoryA)
   pA := f.CreateProduct("productA")
   pA.ShowProduct()
}

• 抽象工厂模式

        抽象工程模式顾名思义就是对工厂模式的一层抽象，也是创建型模式的一种，通常用来创建一组存在相关性的对象。

        抽象工程的好处就是可以不用修改工厂的代码，直接进行扩展。

        抽象工厂针对的使多个产品等级结构，我们可以将一种产品等级想象为一个产品族，所谓产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族。

package main

import "fmt"

// package abstractFactoryMethod

//工厂接口
type factoryInterface interface {
	CreateProductA() ProductAInter
	CreateProductB() ProductBInter
}

//产品A接口
type ProductAInter interface {
	ShowProductA()
}

//产品A结构体
type productA struct {
}

func (p productA) ShowProductA() {
	fmt.Println("这是产品A")
}

//产品B接口
type ProductBInter interface {
	ShowProductB()
}

//产品B 结构体
type productB struct {
}

func (p productB) ShowProductB() {
	fmt.Println("这是产品B")
}

//工厂结构体
type factory struct {
}

//利用工厂A结构体  生产A产品
func (f *factory) CreateProductA() ProductAInter {
	return new(productA)
}

//利用工厂B结构体  生产B产品
func (f *factory) CreateProductB() ProductBInter {
	return new(productB)
}

func main() {
	//生产产品A
	var f factoryInterface
	f = new(factory)
	a := f.CreateProductA()
	a.ShowProductA()

	//生产产品B
	b := f.CreateProductB()
	b.ShowProductB()
}

输出结果：

抽象工厂可参考：https://www.cnblogs.com/amunote/p/15236587.html

简单工厂、工厂方法和抽象工厂的区别：

Go!Go!Go!设计模式-创建型模式(简单工厂，工厂方法，抽象工厂) - 水鬼子 - 博客园

golang 工厂模式与抽象工厂模式_m0_37681974的博客-CSDN博客