什么是工厂模式

工厂模式（Factory Pattern）是 常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
工厂模式提供了一种将对象的实例化过程封装在工厂类中的方式。通过使用工厂模式，可以将对象的创建与使用代码分离，提供一种统一的接口来创建不同类型的对象。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
常见的工厂模式有2种简单工厂模式和抽象工厂模式

简单工厂模式

抽象产品（Abstract Product）：定义了产品的共同接口或抽象类。它可以是具体产品类的父类或接口，规定了产品对象的共同方法。
具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为和属性。
抽象工厂（Abstract Factory）：声明了创建产品的抽象方法，可以是接口或抽象类。它可以有多个方法用于创建不同类型的产品。
具体工厂（Concrete Factory）：实现了抽象工厂接口，负责实际创建具体产品的对象。

图1

//抽象层
type Positions interface {
    Query()
}

//实现层
type Teacher struct {
}

func (t Teacher) Query() {
    fmt.Println("i am teacher")
}

type Scientist struct {
}

func (s Scientist) Query() {
    fmt.Println("i am scientist")
}

//业务逻辑层
type Factory struct {
}

func (f *Factory) NewPositionsFactory(name string) Positions {
    var positions Positions
    switch name {
    case "teacher":
        positions = new(Teacher)
    case "scientist":
        positions = new(Scientist)
    default:
        positions = nil
    }
    return positions
}

func main() {
    factory := new(Factory)
    //var factory Factory

    teacher := factory.NewPositionsFactory("teacher")
    if teacher != nil {
        teacher.Query()
    }

    scientist := factory.NewPositionsFactory("scientist")
    if scientist != nil {
        scientist.Query()
    }
}

优点：
实现创建对象和和使用的分离
不需要关注过多的业务类

缺点：
对工厂的职责过重
增加业务类的个数，复杂度增加
违反开闭原则，添加新产品修改工厂逻辑

适用：
创建对象比较少的情况，复杂度不高

抽象工厂模式

抽象工厂（Abstract Factory）：声明了一组用于创建产品对象的方法，每个方法对应一种产品类型。抽象工厂可以是接口或抽象类。
具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建具体产品对象的实例。
抽象产品（Abstract Product）：定义了一组产品对象的共同接口或抽象类，描述了产品对象的公共方法。
具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为和属性。

图2

业务功能抽象

type Positions interface {
    Query()
}

type AbstractPositions interface {
    CreatePositions() Positions //生产职位
}

具体产品

type Teacher struct {
}

func (t Teacher) Query() {
    fmt.Println("i am teacher")
}

type Scientist struct {
}

func (s Scientist) Query() {
    fmt.Println("i am scientist")
}

产品类工厂

//基础工厂模块
type TeacherFactory struct {
    AbstractPositions
}

func (t TeacherFactory) CreatePositions() Positions {
    var positions Positions
    positions = new(Teacher)
    return positions
}

type ScientistFactory struct {
    AbstractPositions
}

func (t Scientist) CreatePositions() Positions {
    var positions Positions
    positions = new(Scientist)
    return positions
}

测试

func main()  {
    //1. 创建工厂
    teacherFactory := new(TeacherFactory)
    //2.根据工厂生产对象，执行具体对象方法
    teacherFactory.CreatePositions().Query()
}

优点：
1.记忆点少，不记类名等
2.实现了对象的创建和使用分离
3.扩展性灵活
4.新产品接入更符合开闭原则
缺点：
1.复杂度相对简单工厂较高