1. 简单工厂模式定义
简单工厂模式（Simple Factory Pattern）是一种创建型设计模式，它通过专门定义一个类来负责创建其他类的实例，这个类通常被称为工厂类。简单工厂模式并不是一种正式的设计模式，但它确实是一种常用的编程技巧。
在简单工厂模式中，工厂类包含了一个方法，这个方法根据传入的参数来决定创建哪种具体对象，并返回这个对象的实例。这样做的好处是，将对象创建的逻辑集中管理，客户端代码不需要直接实例化对象，而是通过工厂方法来获取所需的对象。
从上面的定义中可以看出，简单工厂模式包含以下三个部分：
- 工厂：负责实现创建所有产品的逻辑，可以说是在这个工厂里面可以实例化所有相关的类；
- 产品接口：这里面封装了所有产品的公共方法，这也是一类产品的特性，比如披萨制作过程都会包括：切等等。
- 具体产品：一般就是会实现产品接口里面所用公共方法的产品。比如奶酪披萨，素食披萨，他们的制作过程是差不多的，所以都会实现制作披萨这个公共方法。
2. 简单工厂模式UML图表示
2.1 相关代码实现
package simple_factory_pattern
// 产品接口
type Pizza interface {
MakePizza()
}
package simple_factory_pattern
import "fmt"
// 具体产品---奶酪披萨
type CheesePizza struct{}
func NewCheesePizza() *CheesePizza {
return &CheesePizza{}
}
func (c *CheesePizza) Prepare() {
fmt.Println("Prepare Cheese Pizza")
}
func (c *CheesePizza) Bake() {
fmt.Println("Bake Cheese Pizza")
}
func (c *CheesePizza) Cut() {
fmt.Println("Cut Cheese Pizza")
}
func (c *CheesePizza) Box() {
fmt.Println("Box Cheese Pizza")
}
func (c *CheesePizza) MakePizza() {
c.Prepare()
c.Bake()
c.Cut()
c.Box()
}
package simple_factory_pattern
import "fmt"
// 具体产品2---素食披萨
type VeggiePizza struct{}
func NewVeggiePizza() *VeggiePizza {
return &VeggiePizza{}
}
func (v *VeggiePizza) Prepare() {
fmt.Println("Prepare Veggie Pizza")
}
func (v *VeggiePizza) Bake() {
fmt.Println("Bake Veggie Pizza")
}
func (v *VeggiePizza) Cut() {
fmt.Println("Cut Veggie Pizza")
}
func (v *VeggiePizza) Box() {
fmt.Println("Box Veggie Pizza")
}
func (v *VeggiePizza) MakePizza() {
v.Prepare()
v.Bake()
v.Cut()
v.Box()
}
package simple_factory_pattern
// 披萨工厂，专门用来实例化pizza对象
type PizzaFactory struct{}
// CreatePizza creates a pizza based on the pizzaType
func (p *PizzaFactory) CreatePizza(pizzaType string) Pizza {
switch pizzaType {
case "cheese":
return NewCheesePizza()
case "veggie":
return NewVeggiePizza()
default:
return nil
}
}2.2 优缺点
简单工厂模式的优点包括：
-
客户端代码与具体类的实现解耦，便于后期的扩展和维护。
-
中央化了对象创建的逻辑，使代码更易读、更易管理。
缺点包括：
-
工厂类集中了所有实例创建的逻辑，可能会导致该类变得过于复杂。
-
增加新的产品类型时需要修改工厂类的代码，违背了开闭原则（对扩展开放，对修改关闭）。
3. 工厂方法模式
为了不违背开闭原则，因此有了工厂方法模式。在每次新增产品类型的时候，把对工厂类的修改放到了客户端进行判断，不需要再改变工厂类，从而不会违背开闭原则。
工厂方法模式是一种创建型模式，它通过定义一个创建对象的接口，让子类决定实例化哪一个类。工厂方法模式让一个类的实例化延迟到其子类。在工厂方法模式中，每个具体产品都有一个对应的具体工厂来创建。下面是将简单工厂模式改写成工厂方法模式的实现：
-
首先定义一个
Pizza接口及其实现类。 -
然后为每个具体的
Pizza类定义一个具体的工厂类，这些工厂类实现一个共同的PizzaFactory接口。
3.1 UML图表示
3.2 相关代码实现
// 产品接口
package factory_method_pattern
// 产品接口type Pizza interface {
MakePizza()
}
// 具体产品实现--奶酪披萨
package factory_method_pattern
import "fmt"
// 具体产品---奶酪披萨type CheesePizza struct{}
func NewCheesePizza() *CheesePizza {
return &CheesePizza{}
}
func (c *CheesePizza) Prepare() {
fmt.Println("Prepare Cheese Pizza")
}
func (c *CheesePizza) Bake() {
fmt.Println("Bake Cheese Pizza")
}
func (c *CheesePizza) Cut() {
fmt.Println("Cut Cheese Pizza")
}
func (c *CheesePizza) Box() {
fmt.Println("Box Cheese Pizza")
}
func (c *CheesePizza) MakePizza() {
c.Prepare()
c.Bake()
c.Cut()
c.Box()
}
// 具体产品实现2---素食披萨
go复制代码
package factory_method_pattern
import "fmt"
// 具体产品---素食披萨type VeggiePizza struct{}
func NewVeggiePizza() *VeggiePizza {
return &VeggiePizza{}
}
func (v *VeggiePizza) Prepare() {
fmt.Println("Prepare Veggie Pizza")
}
func (v *VeggiePizza) Bake() {
fmt.Println("Bake Veggie Pizza")
}
func (v *VeggiePizza) Cut() {
fmt.Println("Cut Veggie Pizza")
}
func (v *VeggiePizza) Box() {
fmt.Println("Box Veggie Pizza")
}
func (v *VeggiePizza) MakePizza() {
v.Prepare()
v.Bake()
v.Cut()
v.Box()
}
// 工厂接口
package factory_method_pattern
// 工厂接口
type PizzaFactory interface {
CreatePizza() Pizza
}
// 奶酪披萨工厂
package factory_method_pattern
// 奶酪披萨工厂
type CheesePizzaFactory struct{}
func NewCheesePizzaFactory() *CheesePizzaFactory {
return &CheesePizzaFactory{}
}
func (c *CheesePizzaFactory) CreatePizza() Pizza {
return NewCheesePizza()
}
// 素食披萨工厂
package factory_method_pattern
// 素食披萨工厂type VeggiePizzaFactory struct{}
func NewVeggiePizzaFactory() *VeggiePizzaFactory {
return &VeggiePizzaFactory{}
}
func (v *VeggiePizzaFactory) CreatePizza() Pizza {
return NewVeggiePizza()
}
// 使用实例
package main
import (
"fmt"
"factory_method_pattern"
)
func main() {
var factory factory_method_pattern.PizzaFactory
// 使用 CheesePizzaFactory 创建 CheesePizza
factory = factory_method_pattern.NewCheesePizzaFactory()
cheesePizza := factory.CreatePizza()
cheesePizza.MakePizza()
// 使用 VeggiePizzaFactory 创建 VeggiePizza
factory = factory_method_pattern.NewVeggiePizzaFactory()
veggiePizza := factory.CreatePizza()
veggiePizza.MakePizza()
} 在这个实现中，每个具体的披萨工厂都实现了 PizzaFactory 接口，并提供了自己的 CreatePizza 方法。这样，客户端代码可以根据需要选择不同的工厂来创建不同的披萨对象，而不需要直接依赖具体的披萨类。这种设计使得系统更灵活，更容易扩展。不会违背开闭原则
