创建式设计模式—工厂模式

目录导航

• • 创建式设计模式---工厂模式
  • • 1)什么是工厂模式
    • 2)使用场景
    • 3)实现方式
    • 4)实践案例
    • 5)优缺点分析

      1)什么是工厂模式

      工厂模式(Factory Method Pattern)是一种设计模式，旨在创建对象时，将对象的创建与使用进行分离。通过定义一个工厂类，这个类具有创建不同具体产品对象的方法。用户只需与工厂类交互，告诉工厂自己想要什么类型的产品，工厂就会负责创建并返回相应的产品对象。这样做的好处是使得系统的架构更加清晰、灵活，方便扩展和维护产品的种类，同时也降低了代码之间耦合度。简单来说，就是有个专门负责生产对象的“地方”，根据需求生产出对应的对象。

      其uml类图

      由图可知，工厂方法模式的角色组成如下

      • 工厂(Factory)：声明返回的产品对象的工厂方法的接口。该方法返回的对象类型必须与产品接口类型相匹配。
      • 具体工厂(ConCreateFactory):实现工厂接口的类，会重写基础工厂方法，使其返回不同类型的产品
      • 产品(Product):声明产品方法的接口。对于所有由具体工厂类及其子类构建的对象，该接口是通用的。
      • 具体产品(ConcreateProduct):实现产品接口的类

        2)使用场景

        • 在程序开发过程中，如果开发者无法预知对象的具体类型及其依赖关系，则可以使用工厂方法模式。工厂方法模式将创建产品的工厂代码与产品代码分离，从而降低代码之间的耦合度。例如，如果需要添加一种新产品，则只需创建一个新的具体工厂类，然后重写其工厂方法。
        • 如果开发者希望其他开发者可以扩展软件库或框架的内部组件，则可以使用工厂模式。
        • 如果一个类需要通过子类指定其创建的对象，则可以使用工厂模式

          3)实现方式

          package modes
          import "fmt"
          // 定义工厂接口
          type Factory interface {
          	//定义一个工厂方法，返回Product
          	FacMethod(user string) Product
          }
          // 定义一个具体的工厂类
          type ConcreateFactory struct {
          }
          // 再实现接口的方法
          func (cf *ConcreateFactory) FacMethod(user string) Product {
          	p := &ConcreateFactory{} //创建一个具体的工厂实例
          	return p
          }
          // 定义一个产品接口
          type Product interface {
          	Use()
          }
          //具体的产品类
          type ConcreateProduct struct {
          }
          func (cf *ConcreateFactory) Use() {
          	//TODO implement me
          	fmt.Println("生产一个产品")
          }
          

          调用main.go进行测试

          package main
          import "factoryMode/modes"
          func main() {
          	factory := modes.ConcreateFactory{}
          	//生产相关的产品
          	product := factory.FacMethod("fac1")
          	product.Use()
          }
          

          4)实践案例

          使用工厂模式演示生产两种不同品牌的鞋子(以生产出Nike和aidas为例子吧)

          1.定义一个产品接口TShoes,该接口有两个私有方法–setName()和setSize()，以及两个公共方法----GetName()和GetSize()

          再定义一个shoes产品类，以及方法用于实现接口的方法,MakeShoes()则是根据shoes品牌的不同生成不同的产品对象并返回：

          shoes.go

          package example
          import "fmt"
          // 定义鞋子产品接口
          type TShoes interface {
          	SetName(name string)
          	SetSize(size int)
          	GetName() string
          	GetSize() int
          }
          // 定义一个shoes类
          type shoes struct {
          	name string
          	size int
          }
          func (c *shoes) SetName(name string) {
          	c.name = name
          }
          func (c *shoes) GetName() string {
          	return c.name
          }
          func (c *shoes) SetSize(size int) {
          	c.size = size
          }
          func (c *shoes) GetSize() int {
          	return c.size
          }
          func MakeShoes(shoesType string) (TShoes, error) {
          	if shoesType == "Nike" {
          		return newNike(), nil
          	}
          	if shoesType == "Adidas" {
          		return newAdidas(), nil
          	}
          	return nil, fmt.Errorf("鞋子类型不对")
          }
          

          2.顶一个Nike产品类

          package example
          // 生产Nike鞋子的产品类
          type Nike struct {
          	shoes
          }
          func newNike() TShoes {
          	return &Nike{
          		shoes: shoes{
          			name: "Nike shoes",
          			size: 37,
          		},
          	}
          }
          

          定义Adidas产品类

          package example
          // 生产Adidas鞋子产品
          type Adidas struct {
          	shoes
          }
          func newAdidas() TShoes {
          	return &Adidas{
          		shoes: shoes{
          			name: "Adidas shoes",
          			size: 38,
          		},
          	}
          }
          

          3.main.go进行测试

          package main
          import (
          	"factoryMode/example"
          	"fmt"
          )
          func main() {
              //创建一个Nike产品对象
          	Nike, _ := example.MakeShoes("Nike")
              //创建一个Adidas产品对象
          	Adidas, _ := example.MakeShoes("Adidas")
          	PrintInformations(Nike)
          	fmt.Println("----------")
          	PrintInformations(Adidas)
          } 
          // 此方法用于输出相关鞋子产品的信息，比如名字和尺码
          func PrintInformations(s example.TShoes) {
          	fmt.Printf("Shoes:%s", s.GetName())
          	fmt.Println()
          	fmt.Printf("Size:%d", s.GetSize())
          }
          //输出结果为，
          Shoes:Nike shoes
          Size:37---------- 
          Shoes:Adidas shoes
          Size:38     
          

          5)优缺点分析

          优点：

          • 应用程序具有可扩展性。在工厂模式中，调用一个方法与新类的实现是完全分离的。这种情况对如何扩展软件有特殊的影响：工厂模式具有高度的自治性，开发者在添加新类后，无须以任何方式更改程序。
          • 工厂组件具有单独可测试性。eg:如果工厂模式实现了4个或多个类，则可以单独测试每个类的功能实现

            缺点：

            • 系统里的类的数量会大幅度成对增加，从而提高该系统的复杂性。工厂模式的实现会导致集成类的数量大量增加，因为每个具体的产品类都需要一个具体的工厂类。尽管工厂模式有利于软件的扩展，但是会增加工作量。如果要扩展工厂模式的产品系列，则必须要调整工厂接口和相应的具体工厂类。因此，针对所需产品类型提前进行可靠规划是非常重要的。

            • 工厂组件具有单独可测试性。eg:如果工厂模式实现了4个或多个类，则可以单独测试每个类的功能实现

              缺点：

              • 系统里的类的数量会大幅度成对增加，从而提高该系统的复杂性。工厂模式的实现会导致集成类的数量大量增加，因为每个具体的产品类都需要一个具体的工厂类。尽管工厂模式有利于软件的扩展，但是会增加工作量。如果要扩展工厂模式的产品系列，则必须要调整工厂接口和相应的具体工厂类。因此，针对所需产品类型提前进行可靠规划是非常重要的。
              • 随着抽象层的引入，提高了开发者对系统的理解难度。如果下一个人要接着上一个人的进度，需要阅读和理解抽象层的代码。