【设计模式】简单工厂模式(Simple Factory Pattern)Go 实例

文章目录

      • 概述
      • 优缺点及适用环境
      • 实现
      • 测试
      • 测试结果

概述

简单工厂模式:定义一个工厂类,它可以根据参数的不同返回不同的实例,被创建的实例通常都具有共同的父类。

简单工厂模式属于创建型模式,但不属于 GOF 23 种设计模式。

优缺点及适用环境

优点:

  • 实现了创建对象和使用对象的分离;
  • 无需知道具体产品的类名;
  • 通过引入配置文件,无需修改代码即可更换和增加新的具体产品类,提高系统的灵活性。

缺点:

  • 职责过重,一旦程序出错,整个系统都不能运行;
  • 引入新的工厂,会导致增加了系统的复杂性和理解难度;
  • 违反了开闭原则,一旦新增产品必须修改原有代码;
  • 简单工厂模式由于使用了静态工厂方法,造成工厂角色无法形成基于继承的等级结构。

适用环境

  • 创建的对象较少,不会造成工厂方法中的业务逻辑太过复杂;
  • 客户端只需要传入工厂方法参数,无需知道对象如何创建;

实现

角色

工厂方法模式由具体工厂、抽象产品和具体产品等 3 个要素构成。

  • 具体工厂(Concrete Factory):它是简单工厂模式的核心,负责实现创建所有产品实例的内部逻辑;工厂类可以被外界直接调用,创建所需的产品对象;在工厂类中提供了静态的工厂方法 factoryMethod,它的返回类型为抽象产品类型 AbstractProduct。
  • 抽象产品(Abstract Product):它是工厂类所创建的所有对象的父类,封装了各种产品对象的公有方法,它的引入将提高系统的灵活性,使得在工厂类中只需定义一个通用的工厂方法,因为所有创建的具体产品对象都是其子类对象。
  • 具体产品(Concrete Product):它是简单工厂模式的创建目标,所有被创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了抽象产品角色,需要实现在抽象产品中声明的抽象方法。

UML 类图如下:
【设计模式】简单工厂模式(Simple Factory Pattern)Go 实例_第1张图片

也就是定义一个抽象工厂,其定义了产品的上层接口,但不负责具体的产品,将生成任务交给不同的派生类工厂。这样就不用通过指定类型来创建对象了。

下面我们来讲解该模式:

抽象产品

package simple_factory

// 实现一个抽象的产品
// 声明 AbstractProduct 接口
// 包含 setName 和 getName 方法
type AbstractProduct interface {
     
	SetName(name string)
	GetName() string
}

具体产品 1

package simple_factory

// 实现一个具体的产品:ConcreteProduct1 的产品
type ConcreteProduct1 struct {
     
	name string
}

// ConcreteProduct1 的方法 setName
func (b *ConcreteProduct1) SetName(name string) {
     
	b.name = name
}

// ConcreteProduct1 的方法 getName
func (b *ConcreteProduct1) GetName() string {
     
	return "产品 1 的名称是:" + b.name
}

具体产品 2

package simple_factory

// 实现一个具体的产品:ConcreteProduct2 的产品
type ConcreteProduct2 struct {
     
	name string
}

// ConcreteProduct2 的方法 setName
func (b *ConcreteProduct2) SetName(name string) {
     
	b.name = name
}

// ConcreteProduct2 的方法 getName
func (b *ConcreteProduct2) GetName() string {
     
	return "产品 2 的名称是:" + b.name
}

工厂

package simple_factory

type productType string

const (
	product1 productType = "product1"
	product2 productType = "product2"
)

type Factory struct {
     
}

// 产品生产工厂
// 具体产品类 ConcreteProduct1 和 ConcreteProduct2 都实现了抽象产品类 AbstractProduct 的接口
// 工厂类实现的两种方法:使用 switch 判断来创建对象
func (c Factory) Create(productType string) AbstractProduct {
     
	switch productType {
     
	case "product1":
		// 生产产品 1
		return &ConcreteProduct1{
     }
	case "product2":
		// 生产产品 2
		return &ConcreteProduct2{
     }
	default:
		return nil
	}
}

测试

package simple_factory

import (
	"fmt"
	"testing"
)

func TestCar_Create(t *testing.T) {
     
	// 实例化
	byd := &ConcreteProduct1{
     }
	byd.SetName("产品1")
	fmt.Println(byd.GetName())

	// 实例化
	bmw := &ConcreteProduct2{
     }
	bmw.SetName("产品2")
	fmt.Println(bmw.GetName())
}

func TestCarFactory_Create(t *testing.T) {
     
	// 实例化
	carFactory := Factory{
     }

	byd := carFactory.Create(string(product1))
	byd.SetName("产品1")
	fmt.Println(byd.GetName())

	bmw := carFactory.Create(string(product2))
	bmw.SetName("产品2")
	fmt.Println(bmw.GetName())
}

测试结果

=== RUN   TestCar_Create
产品 1 的名称是:产品1
产品 2 的名称是:产品2
--- PASS: TestCar_Create (0.00s)
=== RUN   TestCarFactory_Create
产品 1 的名称是:产品1
产品 2 的名称是:产品2
--- PASS: TestCarFactory_Create (0.00s)
PASS

Process finished with exit code 0

你可能感兴趣的:(#,创建型模式)