一、什么是工厂模式
专门定义一个类来负责创建其他类的实例，根据参数的不同创建不同类的实例，被创建的实例通常具有共同的父类，这个模式叫简单工厂模式（Simple Factory Pattern）。
简单工厂模式又称为静态工厂方法模式。之所以叫“静态”，是因为在很多静态语言（如Java、C++）中方法通常被定义成一个静态（static）方法，这样便可通过类名来直接调用方法。
1.1根据剧情来体会
生活中咖啡机的使用也非常简单，咖啡机旁边有已经准备好的咖啡豆，想喝咖啡，只要往咖啡机里加入少量的咖啡豆，然后选择杯数和浓度，再按一下开关，10分钟后，带着浓香的咖啡就为你准备好了！当然，如果你想喝一些其他口味的咖啡，也可以自备咖啡豆，无论你要拿铁还是摩卡，都不是问题。那么问题来了，你要拿铁还是摩卡呢？
用python代码来演绎：
from abc import ABCMeta, abstractmethod
# 引入ABCMeta和abstractmethod来定义抽象类和抽象方法
class Coffee(metaclass=ABCMeta):
def __init__(self, name):
self.name = name
def getName(self):
return self.name
@abstractmethod
def getTaste(self):
pass
class LatteCaffe(Coffee):
"""拿铁咖啡"""
def __init__(self, name):
super().__init__(name)
def getTaste(self):
return "轻柔而香醇"
class MochaCoffee(Coffee):
"""摩卡咖啡"""
def __init_(self, name):
super().__init__(name)
def getTaste(self):
return "丝滑与醇厚"
class Coffeemaker:
"""咖啡机"""
@staticmethod
def makeCoffee(coffeeBean):
"""通过staticmethod装饰器修饰来定义一个静态方法。"""
if coffeeBean == "拿铁咖啡豆":
coffee = LatteCaffe("拿铁咖啡")
elif coffeeBean == "摩卡咖啡豆":
coffee = MochaCoffee("摩卡咖啡")
else:
raise ValueError("不支持的参数：%s", coffeeBean)
return coffee
def testCoffeeMaker():
latte = Coffeemaker.makeCoffee("拿铁咖啡豆")
print("%s己为您准各好了，口感：%s。请慢慢享用!" % (latte.getName(), latte.getTaste()))
mocha = Coffeemaker.makeCoffee("摩卡咖啡豆")
print("%s己为您准备好了，口感：%s。请慢慢享用！" % (mocha.getName(), mocha.getTaste()))
if __name__ == "__main__":
testCoffeeMaker()
用golang代码来演示：
package main
import (
"errors"
"fmt"
)
type abcCoffee interface {
GetName() string
GetTask() string
}
// Coffee 咖啡的抽象类
type Coffee struct {
Name string
}
func (c Coffee) GetName() string {
return c.Name
}
func (c Coffee) GetTask() string {
return ""
}
// LatteCoffee 拿铁咖啡
type LatteCoffee struct {
Coffee
}
func (l LatteCoffee) GetTask() string {
return "轻柔而香醇"
}
// MochaCoffee 摩卡咖啡
type MochaCoffee struct {
Coffee
}
func (m MochaCoffee) GetTask() string {
return "丝滑与醇厚"
}
// CoffeeMaker 咖啡机
type CoffeeMaker struct {
}
func (c CoffeeMaker) makeCoffee(coffeeBean string) (abcCoffee, error) {
if coffeeBean == "拿铁咖啡豆" {
coffee := LatteCoffee{Coffee{coffeeBean}}
return coffee, nil
}
if coffeeBean == "摩卡咖啡豆" {
coffee := MochaCoffee{Coffee{coffeeBean}}
return coffee, nil
}
return nil, errors.New(fmt.Sprintf("不支持的参数：%s", coffeeBean))
}
func main() {
cm := CoffeeMaker{}
if latte, err := cm.makeCoffee("拿铁咖啡豆"); err != nil {
fmt.Println(err)
} else {
fmt.Printf("%s 已经为您准备好了，口感：%s。请慢慢享用！\n", latte.GetName(), latte.GetTask())
}
if mocha, err := cm.makeCoffee("摩卡咖啡豆"); err != nil {
fmt.Println(err)
} else {
fmt.Printf("%s 已经为您准备好了，口感：%s。请慢慢享用！\n", mocha.GetName(), mocha.GetTask())
}
}
运行结果：
拿铁咖啡豆 已经为您准备好了，口感：轻柔而香醇。请慢慢享用！
摩卡咖啡豆 已经为您准备好了，口感：丝滑与醇厚。请慢慢享用！
1.2定义
简单工厂模式
定义一个创建对象（实例化对象）的接口，通过参数来决定创建哪个类的实例。
1.3 优缺点
优点：
（1）实现简单、结构清晰。
（2）抽象出一个专门的类来负责某类对象的创建，分割出创建的职责，不能直接创建具体的对象，只需传入适当的参数即可。
（3）使用者可以不关注具体对象的类名称，只需知道传入什么参数可以创建哪些需要的对象。
缺点：
（1）不易拓展，一旦添加新的产品类型，就不得不修改工厂的创建逻辑。不符合“开放封闭”原则，如果要增加或删除一个产品类型，就要修改switch...case...（或if...else...）的判断代码。
（2）当产品类型较多时，工厂的创建逻辑可能过于复杂，switch...case...（或if...else...）判断会变得非常多。一旦出错可能造成所有产品创建失败，不利于系统的维护。
1.4 应用场景
（1）产品具有明显的继承关系，且产品的类型不太多。
（2）所有的产品具有相同的方法和类似的属性，使用者不关心具体的类型，只希望传入合适的参数能返回合适的对象。
尽管简单工厂模式不符合“开放-封闭”原则，但因为它简单，所以仍然能在很多项目中看到它。
二、工厂方法模式
工厂方法模式是简单工厂模式的一个升级版本，为解决简单工厂模式不符合“开放-封闭”原则的问题，我们对 SimpleFactory 进行了一个拆分，抽象出一个父类 Factory，并增加多个子类分别负责创建不同的具体产品。
2.1 定义
定义一个创建对象（实例化对象）的接口，让子类来决定创建哪个类的实例。工厂方法使一个类的实例化延迟到其子类。
2.2 代码实例：
package main
import (
"errors"
"fmt"
)
type Coffee interface {
getName() string
getTask() string
}
type AbsCoffee struct {
Name string
}
func (c AbsCoffee) getName() string {
return c.Name
}
func (c AbsCoffee) getTask() string {
return ""
}
type LatteCoffee struct {
AbsCoffee
}
func (c LatteCoffee) getTask() string {
return "轻柔而香醇"
}
type MochaCoffee struct {
AbsCoffee
}
func (c MochaCoffee) getTask() string {
return "丝滑与醇厚"
}
type AbsCoffeeMaker struct {
}
func (m AbsCoffeeMaker) makeCoffee() (Coffee, error) {
return AbsCoffee{}, errors.New("空的咖啡杯")
}
type LatteCoffeeMaker struct {
AbsCoffeeMaker
}
func (c LatteCoffeeMaker) makeCoffee() (Coffee, error) {
return LatteCoffee{AbsCoffee{"拿铁咖啡"}}, nil
}
type MochaCoffeeMaker struct {
AbsCoffeeMaker
}
func (c MochaCoffeeMaker) makeCoffee() (Coffee, error) {
return MochaCoffee{AbsCoffee{"摩卡咖啡"}}, nil
}
func main() {
lcm := LatteCoffeeMaker{}
if latte, err := lcm.makeCoffee(); err != nil {
fmt.Println(err)
} else {
fmt.Printf("%s 已经为您准备好了，口感：%s。请慢慢享用！\n", latte.getName(), latte.getTask())
}
mcm := MochaCoffeeMaker{}
if mocha, err := mcm.makeCoffee(); err != nil {
fmt.Println(err)
} else {
fmt.Printf("%s 已经为您准备好了，口感：%s。请慢慢享用！\n", mocha.getName(), mocha.getTask())
}
}
2.3 优缺点
“优点：
（1）解决了简单工厂模式不符合“开放-封闭”原则的问题，使程序更容易拓展。
（2）实现简单。
缺点：
对于有多种分类的产品，或具有二级分类的产品，工厂方法模式并不适用。
多种分类：如我们有一个电子白板程序，可以绘制各种图形，那么画笔的绘制功能可以理解为一个工厂，而图形可以理解为一种产品；图形可以根据形状分为直线、矩形、椭圆等，也可以根据颜色分为红色图形、绿色图形、蓝色图形等。
二级分类：如一个家电工厂，它可能同时生产冰箱、空调和洗衣机，那么冰箱、空调、洗衣机属于一级分类；而洗衣机又可分为高效型的和节能型的，高效型洗衣机和节能型洗衣机就属于二级分类。
2.4.应用场景
（1）客户端不知道它所需要的对象的类。
（2）工厂类希望通过其子类来决定创建哪个具体类的对象。
三、抽象工厂模式
抽象工厂模式是工厂方法模式的升级版本，工厂方法模式不能解决具有二级分类的产品的创建问题，抽象工厂模式就是用来解决这一问题的。
3.1 定义
提供一个创建一系列相关或相互依赖的对象的接口，而无须指定它们的具体类。
3.2代码实现
package main
import "fmt"
type HomeAppliances interface {
getName() string
}
// Refrigerator 冰箱
type Refrigerator struct {
name string
}
func (r Refrigerator) getName() string {
return "冰箱"
}
// EfficientRefrigerator 高效冰箱
type EfficientRefrigerator struct {
Refrigerator
}
func (e EfficientRefrigerator) getName() string {
return e.name
}
// EnergySavingRefrigerator 节能冰箱
type EnergySavingRefrigerator struct {
Refrigerator
}
func (e EnergySavingRefrigerator) getName() string {
return e.name
}
// WashingMachine 洗衣机
type WashingMachine struct {
name string
}
func (w WashingMachine) getName() string {
return "洗衣机"
}
// EfficientWashingMachine 高效洗衣机
type EfficientWashingMachine struct {
WashingMachine
}
func (e EfficientWashingMachine) getName() string {
return e.name
}
// EnergySavingWashingMachine 节能洗衣机
type EnergySavingWashingMachine struct {
WashingMachine
}
func (e EnergySavingWashingMachine) getName() string {
return e.name
}
type AppliancesFactory interface {
CreateRefrigerator() HomeAppliances
CreateWashingMachine() HomeAppliances
}
type EfficientFactory struct {
}
func (e EfficientFactory) CreateRefrigerator() HomeAppliances {
return &EfficientRefrigerator{Refrigerator{
name: "高效冰箱",
}}
}
func (e EfficientFactory) CreateWashingMachine() HomeAppliances {
return &EfficientWashingMachine{WashingMachine{
name: "高效洗衣机",
}}
}
type EnergySavingFactory struct {
}
func (e EnergySavingFactory) CreateRefrigerator() HomeAppliances {
return &EnergySavingRefrigerator{Refrigerator{
name: "节能冰箱",
}}
}
func (e EnergySavingFactory) CreateWashingMachine() HomeAppliances {
return &EnergySavingWashingMachine{WashingMachine{
name: "节能洗衣机",
}}
}
func main() {
efficientFactory := new(EfficientFactory)
energySavingFactory := new(EnergySavingFactory)
efficRefrigerator := efficientFactory.CreateRefrigerator()
efficWashingMachine := efficientFactory.CreateWashingMachine()
engryRefrigerator := energySavingFactory.CreateRefrigerator()
engryWashingMachine := energySavingFactory.CreateWashingMachine()
fmt.Println(efficRefrigerator.getName())
fmt.Println(efficWashingMachine.getName())
fmt.Println(engryRefrigerator.getName())
fmt.Println(engryWashingMachine.getName())
}
AppliancesFactory是一个抽象的工厂类，定义了三个方法，分别用来生产冰箱（Refrigerator）、空调（Air-conditioner）、洗衣机（WashingMachine）。EfficientFactory和EnergySavingFactory是两个具体的工厂类，分别用来生产高效型的家电和节能型的家电。
3.3 优缺点
优点：
解决了具有二级分类的产品的创建。
缺点：
（1）如果产品的分类超过二级，如三级甚至更多级，抽象工厂模式将会变得非常臃肿。
（2）不能解决产品有多种分类、多种组合的问题。
3.4应用场景
（1）系统中有多于一个的产品族，而每次只使用其中某一产品族。
（2）产品等级结构稳定，设计完成之后，不会向系统中增加新的产品等级结构或者删除已有的产品等级结构。
资料：
《人人都懂设计模式：从生活中领悟设计模式》
