设计模式-04-工厂方法模式

Design Patterns Comments

简单工厂模式违背的开闭原则，拓展新的产品的时候都需要修改旧的代码

逻辑结构

FactoryMethod

代码实现

代码路径：https://github.com/XBoom/DesignPatterns/tree/main/03_FactoryMethod

  1. 有一个简单的产品接口(这里指汽车)

    1
    2
    3
    type Car interface {
    	Name() string
    }

  2. 有两个具体的实现类

    1
    2
    3
    4
    5
    6
    7
    8
    type BYD struct {
    }

    func (B BYD) Name() string {
    	return "BYD"
    }

    var _ Car = (*BYD)(nil)

    另外一个具体类

    1
    2
    3
    4
    5
    6
    7
    8
    type Tesla struct {
    }

    func (t Tesla) Name() string {
    	return "Tesla"
    }

    var _ Car = (*Tesla)(nil)

  3. 工厂方法有一个抽象接口，对应具体的产品

    1
    2
    3
    type Factory interface {
    	CreateCar() Car
    }

  4. 实现具体产品的工厂

    1
    2
    3
    4
    5
    6
    7
    8
    type BYDFactory struct {
    }

    func (B BYDFactory) CreateCar() Car {
    	return &BYD{}
    }

    var _ Factory = (*BYDFactory)(nil)

    另外一个对应具体产品的工厂

    1
    2
    3
    4
    5
    6
    7
    8
    type TeslaFactory struct {
    }

    func (t TeslaFactory) CreateCar() Car {
    	return &Tesla{}
    }

    var _ Factory = (*TeslaFactory)(nil)

单元测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var expectBYD = "BYD"
var expectTesla = "Tesla"

func TestBYDFactory_CreateCar(t *testing.T) {
	factory := new(BYDFactory)
	car := factory.CreateCar()
	if !reflect.DeepEqual(car.Name(), expectBYD) {
		t.Fatalf("expect %s acture %s", expectBYD, car.Name())
	}
}

func TestTeslaFactory_CreateCar(t *testing.T) {
	factory := new(TeslaFactory)
	car := factory.CreateCar()
	if !reflect.DeepEqual(car.Name(), expectTesla) {
		t.Fatalf("expect %s acture %s", expectTesla, car.Name())
	}
}

跟简单工厂模式相比，当需要增加新的产品的时候，完全不会影响旧的逻辑

总结

  1. 工厂方法相当于简单工厂模式，实际是通过将对象的创建延迟到具体的工厂类中来解决简单工厂模式的缺点
  2. 工厂方法模式完全符合开闭原则
  3. 工厂方法模式适用于类型创建比较复杂不是简单的New，将复杂的创建逻辑拆分到多个工厂类中

参考文档

  1. https://lailin.xyz/post/factory.html
  2. https://github.com/senghoo/golang-design-pattern
  3. https://chat.openai.com/c/574c8562-2f17-4d1c-8a02-9d1c65f1f6c3