《golang设计模式》第一部分·创建型模式-04-工厂方法模式（Factory Method）

1 概述

工厂方法类定义产品对象创建接口，但由子类实现具体产品对象的创建。

2.1 角色

• Product（抽象产品）：它是具体产品的抽象类，可以是结构体，也可以是接口
• ConcreteProduct（具体产品）：它实现了抽象产品接口，对应了一种具体产品
• Factroy（抽象工厂）：在抽象工厂类中声明了工厂方法，用于返回一个产品。
• ConcreteFactory（具体工厂）：实现了在抽象工厂中声明的工厂方法，并可由客户端调用，返回一个具体产品类的实例。

2.2 类图

2 代码示例

2.1 代码

package main

import (
	"fmt"
)
//定义产品接口
type Product interface {
    Get()
}
//定义具体产品A
type ConcreteProductA struct {
    Name string
	Kind string
}

//获取产品A方法
func (c *ConcreteProductA) Get() {
	fmt.Printf("%+v",c)
}

//定义具体产品B
type ConcreteProductB struct {
    Name string
	Kind string
}

//获取产品B方法
func (c *ConcreteProductB) Get() {
	fmt.Printf("%+v",c)
}
//定义产品C
type ConcreteProductC struct {
    Name string
	Kind string
}

//获取产品C方法
func (c *ConcreteProductC) Get() {
	fmt.Printf("%+v",c)
}

//定义工厂接口
type Factroy interface {
	CreateProduct(name string) Product
}
//创建具体工厂A，用于创建产品A
type ConcreteFactoryA struct {
}
//创建产品A的方法
func (f  *ConcreteFactoryA) CreateProduct(name string) Product {
	p := &ConcreteProductA{
		Name: name,
		Kind:"A",
	}
	return p
}
//定义具体工厂B
type ConcreteFactoryB struct {
}
//创建产品B的方法
func (f *ConcreteFactoryB) CreateProduct(name string) Product {
	p := &ConcreteProductB{
		Name: name,
		Kind: "B",
	}
	return p
}
//定义工厂C
type ConcreteFactoryC struct {
}
//创建产品C的方法
func (f *ConcreteFactoryC) CreateProduct(name string) Product {
	p := &ConcreteProductC{
		Name: name,
		Kind: "C",
	}
	return p
}
//定义函数，用于创建工厂（更加条件返回何种工厂）
func CreateProduct(myType int64) Factroy {
	switch myType {
	case 1:
		return  &ConcreteFactoryA{}
	case 2:
		return &ConcreteFactoryB{}
	case 3:
		return &ConcreteFactoryC{}
	}
	return nil
}

func main() {
    //创建一个实例化工厂（该条件创建的是具体工厂A的实例）
	factory := CreateProduct(1)
	//用该工厂创建一个产品（很明显，这个产品应该是产品A）
	product := factory.CreateProduct("nginx")
	//获取产品来验证
    product.Get()
}

• 输出

&{Name:nginx Kind:A}

2.2 类图

3. 简单工厂

在产品结构简单的情况下，我们可以把工厂模式简化成一个简单工厂

3.1 角色

• Product（抽象产品）：它是具体产品的抽象类，可以是结构体，也可以是接口
• ConcreteProduct（具体产品）：它实现了抽象产品接口，对应了一种具体产品
• Factroy（简单工厂）：根据一个条件用于返回一个产品

去掉了具体工厂角色，产品由简单工厂直接返回。

3.2 类图

3.3 代码示例

3.3.1 设计

• 定义一个抽象产品Product
• 定义三个具体产品ConcreteProductA、ConcreteProductB、ConcreteProductC
  • 它们各自的Get()方法会访问它本身
• 定义一个简单工厂
  • 简单工厂的CreateProduct()方法会返回一个产品
• 调用
  • 实例化一个简单工厂
  • 用简单工厂创建一个产品
  • 用产品的Get()方法查询结果

3.3.2 代码

package main

import (
	"fmt"
)

type Product interface {
	Get()
}

type ConcreteProductA struct {
	Name string
	Kind string
}

func (c *ConcreteProductA) Get() {
	fmt.Printf("%+v", c)
}

type ConcreteProductB struct {
	Name string
	Kind string
}

func (c *ConcreteProductB) Get() {
	fmt.Printf("%+v", c)
}

type ConcreteProductC struct {
	Name string
	Kind string
}

func (c *ConcreteProductC) Get() {
	fmt.Printf("%+v", c)
}

type Factroy struct {
}

func (f *Factroy) CreateProduct(myType int64, name string) Product {
	switch myType {
	case 1:
		return &ConcreteProductA{
			Name: name,
			Kind: "A",
		}
	case 2:
		return &ConcreteProductB{
			Name: name,
			Kind: "B",
		}
	case 3:
		return &ConcreteProductC{
			Name: name,
			Kind: "C",
		}
	}
	return nil
}

func main() {
	factory := &Factroy{}
	product := factory.CreateProduct(1, "nginx")
	product.Get()
}

• 输出

&{Name:nginx Kind:A}

3.3.3 类图

---