设计模式-03-简单工厂模式

Design Patterns Comments

工厂模式分为三种更加细分的类型

  1. 简单工厂(Simple Factory)
  2. 工厂方法(Factory Method)
  3. 抽象工厂(Abstract Factory)

由于 Go 本身是没有构造函数的，一般采用 NewName 的方式创建对象/接口，当它返回的是接口的时候，其实就是简单工厂模式

逻辑结构

SimpleFactory

代码实现

代码路径：https://github.com/XBoom/DesignPatterns/tree/main/02_SimpleFactory

  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
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    type Factory struct {
    }

    func (f *Factory) CreateCar(typ string) Car {
    	switch typ {
    	case "byd":
    		return &BYD{}
    	case "tesla":
    		return &Tesla{}
    	default:
    		panic("unknown type")
    	}
    }

单元测试

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

func TestFactory_CreateCar(t *testing.T) {
	factory := new(Factory)
	car1 := factory.CreateCar("byd")
	if !reflect.DeepEqual(car1.Name(), expectByd) {
		t.Fatalf("expect %s acture %s", expectByd, car1.Name())
	}

	car2 := factory.CreateCar("tesla")
	if !reflect.DeepEqual(car2.Name(), expectTesla) {
		t.Fatalf("expect %s acture %s", expectTesla, car2.Name())
	}
}

根据参数的参数不同构建不同的产品对象，当增加一种产品的时候，这里就需要修改 CreateCar 方法，并在使用的时候追加CreateCar 新的类型与业务，违反了开闭原则

总结

  1. 增加新的产品类型时需要修改工厂类的代码，违反了开闭原则
  2. 简单工厂模式适用于对象较少、对象类型固定的场景，可以提高对象的创建效率和统一管理对象的创建过程

参考文档

  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