面包芯语

【Go实现】实践GoF的23种设计模式：工厂方法模式

原创 元闰子的邀请 2022-05-21 15:53
TI MCU方案：电动汽车实时控制 【免注册下载】创新MCU提升高压系统的实时性能

上一篇：【Go实现】实践GoF的23种设计模式：建造者模式

简单的分布式应用系统（示例代码工程）：https://github.com/ruanrunxue/Practice-Design-Pattern--Go-Implementation

简述

工厂方法模式（Factory Method Pattern）跟上一篇讨论的建造者模式类似，都是将对象创建的逻辑封装起来，为使用者提供一个简单易用的对象创建接口。两者在应用场景上稍有区别，建造者模式常用于需要传递多个参数来进行实例化的场景；工厂方法模式常用于不指定对象具体类型的情况下创建对象的场景。

UML 结构

代码实现

示例

在简单的分布式应用系统（示例代码工程）中，我们设计了 Sidecar 边车模块， Sidecar 的作用是为了给原生的 Socket 增加额外的功能，比如流控、日志等。

Sidecar 模块的设计运用了装饰者模式，修饰的是 Socket 。所以客户端其实是把 Sidecar 当成是 Socket 来使用了，比如：

// demo/network/http/http_client.go
package http

// 创建一个新的HTTP客户端，以Socket接口作为入参
func NewClient(socket network.Socket, ip string) (*Client, error) {
  ... // 一些初始化逻辑
 return client, nil
}

// 使用NewClient时，我们可以传入Sidecar来给Http客户端附加额外的流控功能
client, err := http.NewClient(sidecar.NewFlowCtrlSidecar(network.DefaultSocket()), "192.168.0.1")

在服务消息中介中，每次收到上游服务的 HTTP 请求，都会调用 http.NewClient 来创建一个 HTTP 客户端，并通过它将请求转发给下游服务：

type ServiceMediator struct {
  ...
 server *http.Server
}

// Forward 转发请求，请求URL为 /{serviceType}+ServiceUri 的形式，如/serviceA/api/v1/task
func (s *ServiceMediator) Forward(req *http.Request) *http.Response {
    ...
    // 发现下游服务的目的IP地址
    dest, err := s.discovery(svcType)
    // 创建HTTP客户端，硬编码sidecar.NewFlowCtrlSidecar(network.DefaultSocket())
    client, err := http.NewClient(sidecar.NewFlowCtrlSidecar(network.DefaultSocket()), s.localIp)
    // 通过HTTP客户端转发请求
    resp, err := client.Send(dest, forwardReq)
    ...
}

在上述实现中，我们在调用 http.NewClient 时把 sidecar.NewFlowCtrlSidecar(network.DefaultSocket()) 硬编码进去了，那么如果以后要扩展 Sidecar ，就得修改这段代码逻辑，这违反了开闭原则 OCP。

有经验的同学可能会想到，可以通过让 ServiceMediator 依赖 Socket 接口，在 Forward 方法调用 http.NewClient 时把 Socket 接口作为入参；然后在 ServiceMediator 初始化时，将具体类型的 Sidecar 注入到 ServiceMediator 中：

type ServiceMediator struct {
  ...
 server *http.Server
  // 依赖Socket抽象接口
  socket network.Socket
}

// Forward 转发请求，请求URL为 /{serviceType}+ServiceUri 的形式，如/serviceA/api/v1/task
func (s *ServiceMediator) Forward(req *http.Request) *http.Response {
    ...
    // 发现下游服务的目的IP地址
    dest, err := s.discovery(svcType)
    // 创建HTTP客户端，将s.socket抽象接口作为入参
    client, err := http.NewClient(s.socket, s.localIp)
    // 通过HTTP客户端转发请求
    resp, err := client.Send(dest, forwardReq)
    ...
}

// 在ServiceMediator初始化时，将具体类型的Sidecar注入到ServiceMediator中
mediator := &ServiceMediator{
  socket: sidecar.NewFlowCtrlSidecar(network.DefaultSocket())
}

上述的修改，从原来依赖具体，改成了依赖抽象，符合了开闭原则。

但是， Forward 方法存在并发调用的场景，因此它希望每次被调用时都创建一个新的 Socket/Sidecar 来完成网络通信，否则就需要加锁来保证并发安全。而上述的修改会导致在 ServiceMediator 的生命周期内都使用同一个 Socket/Sidecar，显然不符合要求。

因此，我们需要一个方法，既能够满足开闭原则，而且在每次调用Forward 方法时也能够创建新的 Socket/Sidecar 实例。工厂方法模式恰好就能满足这两点要求，下面我们通过它来完成代码的优化。

实现

// demo/sidecar/sidecar_factory.go

// 关键点1: 定义一个Sidecar工厂抽象接口
type Factory interface {
  // 关键点2: 工厂方法返回Socket抽象接口
 Create() network.Socket
}

// 关键点3: 按照需要实现具体的工厂


// demo/sidecar/raw_socket_sidecar_factory.go
// RawSocketFactory 只具备原生socket功能的sidecar，实现了Factory接口
type RawSocketFactory struct {
}
func (r RawSocketFactory) Create() network.Socket {
 return network.DefaultSocket()
}

// demo/sidecar/all_in_one_sidecar_factory.go
// AllInOneFactory 具备所有功能的sidecar工厂，实现了Factory接口
type AllInOneFactory struct {
 producer mq.Producible
}
func (a AllInOneFactory) Create() network.Socket {
 return NewAccessLogSidecar(NewFlowCtrlSidecar(network.DefaultSocket()), a.producer)
}

上述代码中，我们定义了一个工厂抽象接口 Factory ，并有了 2 个具体的实现 RawSocketFactory 和 AllInOneFactory。最后， ServiceMediator 依赖  Factory ，并在 Forward 方法中通过 Factory 来创建新的 Socket/Sidecar ：

// demo/service/mediator/service_mediator.go

type ServiceMediator struct {
  ...
 server *http.Server
  // 关键点4: 客户端依赖Factory抽象接口
  sidecarFactory sidecar.Factory
}

// Forward 转发请求，请求URL为 /{serviceType}+ServiceUri 的形式，如/serviceA/api/v1/task
func (s *ServiceMediator) Forward(req *http.Request) *http.Response {
    ...
    // 发现下游服务的目的IP地址
    dest, err := s.discovery(svcType)
    // 创建HTTP客户端，调用sidecarFactory.Create()生成Socket作为入参
    client, err := http.NewClient(s.sidecarFactory.Create(), s.localIp)
    // 通过HTTP客户端转发请求
    resp, err := client.Send(dest, forwardReq)
    ...
}

// 关键点5: 在ServiceMediator初始化时，将具体类型的sidecar.Factory注入到ServiceMediator中
mediator := &ServiceMediator{
  sidecarFactory: &AllInOneFactory{}
  // sidecarFactory: &RawSocketFactory{}
}

下面总结实现工厂方法模式的几个关键点：

  1. 定义一个工厂方法抽象接口，比如前文中的 sidecar.Factory。
  2. 工厂方法中，返回需要创建的对象/接口，比如 network.Socket。其中，工厂方法通常命名为 Create。
  3. 按照具体需要，定义工厂方法抽象接口的具体实现对象，比如 RawSocketFactory 和 AllInOneFactory。
  4. 客户端使用时，依赖工厂方法抽象接口。
  5. 在客户端初始化阶段，完成具体工厂对象的依赖注入。

扩展

Go 风格的实现

前文的工厂方法模式实现，是非常典型的面向对象风格，下面我们给出一个更具 Go 风格的实现。

// demo/sidecar/sidecar_factory_func.go

// 关键点1: 定义Sidecar工厂方法类型
type FactoryFunc func() network.Socket

// 关键点2: 按需定义具体的工厂方法实现，注意这里定义的是工厂方法的工厂方法，返回的是FactoryFunc工厂方法类型
func RawSocketFactoryFunc() FactoryFunc {
 return func() network.Socket {
  return network.DefaultSocket()
 }
}

func AllInOneFactoryFunc(producer mq.Producible) FactoryFunc {
 return func() network.Socket {
  return NewAccessLogSidecar(NewFlowCtrlSidecar(network.DefaultSocket()), producer)
 }
}

type ServiceMediator struct {
  ...
 server *http.Server
  // 关键点3: 客户端依赖FactoryFunc工厂方法类型
  sidecarFactoryFunc FactoryFunc
}

func (s *ServiceMediator) Forward(req *http.Request) *http.Response {
    ...
    dest, err := s.discovery(svcType)
    // 关键点4: 创建HTTP客户端，调用sidecarFactoryFunc()生成Socket作为入参
    client, err := http.NewClient(s.sidecarFactoryFunc(), s.localIp)
    resp, err := client.Send(dest, forwardReq)
    ...
}

// 关键点5: 在ServiceMediator初始化时，将具体类型的FactoryFunc注入到ServiceMediator中
mediator := &ServiceMediator{
  sidecarFactoryFunc: RawSocketFactoryFunc()
  // sidecarFactory: AllInOneFactoryFunc(producer)
}

上述的实现，利用了 Go 语言中函数作为一等公民的特点，少定义了几个 interface 和 struct，代码更加的简洁。

几个实现的关键点与面向对象风格的实现类似。值得注意的是 关键点2 ，我们相当于定义了一个工厂方法的工厂方法，这么做是为了利用函数闭包的特点来传递参数。如果直接定义工厂方法，那么 AllInOneFactoryFunc 的实现是下面这样的，无法实现多态：

// 并非FactoryFunc类型，无法实现多态
func AllInOneFactoryFunc(producer mq.Producible) network.Socket {
    return NewAccessLogSidecar(NewFlowCtrlSidecar(network.DefaultSocket()), producer)
}

简单工厂

工厂方法模式的另一个变种是简单工厂，它并不通过多态，而是通过简单的 switch-case/if-else 条件判断来决定创建哪种产品：

// demo/sidecar/sidecar_simple_factory.go

// 关键点1: 定义sidecar类型
type Type uint8

// 关键点2: 按照需要定义sidecar具体类型
const (
 Raw Type = iota
 AllInOne
)

// 关键点3: 定义简单工厂对象
type SimpleFactory struct {
 producer mq.Producible
}

// 关键点4: 定义工厂方法，入参为sidecar类型，根据switch-case或者if-else来创建产品
func (s SimpleFactory) Create(sidecarType Type) network.Socket {
 switch sidecarType {
 case Raw:
  return network.DefaultSocket()
 case AllInOne:
  return NewAccessLogSidecar(NewFlowCtrlSidecar(network.DefaultSocket()), s.producer)
 default:
  return nil
 }
}

// 关键点5: 创建产品时传入具体的sidecar类型，比如sidecar.AllInOne
simpleFactory := &sidecar.SimpleFactory{producer: producer}
sidecar := simpleFactory.Create(sidecar.AllInOne)

静态工厂方法

静态工厂方法是 Java/C++ 的说法，主要用于替代构造函数来完成对象的实例化，能够让代码的可读性更好，而且起到了与客户端解耦的作用。比如 Java 的静态工厂方法实现如下：

public class Packet {
    private final Endpoint src;
    private final Endpoint dest;
    private final Object payload;

    private Packet(Endpoint src, Endpoint dest, Object payload) {
        this.src = src;
        this.dest = dest;
        this.payload = payload;
    }

    // 静态工厂方法
    public static Packet of(Endpoint src, Endpoint dest, Object payload) {
        return new Packet(src, dest, payload);
    }
  ...
}

// 用法
packet = Packet.of(src, dest, payload)

Go 中并没有静态一说，直接通过普通函数来完成对象的构造即可，比如：

// demo/network/packet.go
type Packet struct {
 src     Endpoint
 dest    Endpoint
 payload interface{}
}

// 工厂方法
func NewPacket(src, dest Endpoint, payload interface{}) *Packet {
 return &Packet{
  src:     src,
  dest:    dest,
  payload: payload,
 }
}

// 用法
packet := NewPacket(src, dest, payload)

典型应用场景

  1. 对象实例化逻辑较为复杂时，可选择使用工厂方法模式/简单工厂/静态工厂方法来进行封装，为客户端提供一个易用的接口。
  2. 如果实例化的对象/接口涉及多种实现，可以使用工厂方法模式实现多态。
  3. 普通对象的创建，推荐使用静态工厂方法，比直接的实例化（比如 &Packet{src: src, dest: dest, payload: payload}）具备更好的可读性和低耦合。

优缺点

优点

  1. 代码的可读性更好。
  2. 与客户端程序解耦，当实例化逻辑变更时，只需改动工厂方法即可，避免了霰弹式修改。

缺点

  1. 引入工厂方法模式会新增一些对象/接口的定义，滥用会导致代码更加复杂。

与其他模式的关联

很多同学容易将工厂方法模式和抽象工厂模式混淆，抽象工厂模式主要运用在实例化“产品族”的场景，可以看成是工厂方法模式的一种演进。

参考

[1] 【Go实现】实践GoF的23种设计模式：SOLID原则, 元闰子

[2] Design Patterns, Chapter 3. Creational Patterns, GoF

[3] Factory patterns in Go (Golang), Soham Kamani

[4] 工厂方法, 维基百科

更多文章请关注微信公众号：元闰子的邀请


登录阅读全文
免责声明： 该内容由专栏作者授权发布或作者转载，目的在于传递更多信息，并不代表本网赞同其观点，本站亦不保证或承诺内容真实性等。若内容或图片侵犯您的权益，请及时联系本站删除。侵权投诉联系：  nick.zong@aspencore.com！
元闰子的邀请
评论
  • Linux系统更换开机logo方法教程，触觉智能RK3562开发板演示
    本文介绍Linux系统更换开机logo方法教程，通用RK3566、RK3568、RK3588、RK3576等开发板，触觉智能RK3562开发板演示，搭载4核A53处理器，主频高达2.0GHz；内置独立1Tops算力NPU，可应用于物联网网关、平板电脑、智能家居、教育电子、工业显示与控制等行业。制作图片开机logo图片制作注意事项（1）图片必须为bmp格式；（2）图片大小不能大于4MB；（3）BMP位深最大是32，建议设置为8；（4）图片名称为logo.bmp和logo_kernel.bmp；开机
    Industio_触觉智能 2025-01-06 10:43 75浏览
  • 国产高性能CPU--米尔瑞芯微RK3576赋能AIoT、工业、智能显示终端
    随着市场需求不断的变化，各行各业对CPU的要求越来越高，特别是近几年流行的 AIOT，为了有更好的用户体验，CPU的算力就要求更高了。今天为大家推荐由米尔基于瑞芯微RK3576处理器推出的MYC-LR3576核心板及开发板。关于RK3576处理器国产CPU，是这些年的骄傲，华为手机全国产化，国人一片呼声，再也不用卡脖子了。RK3576处理器，就是一款由国产是厂商瑞芯微，今年第二季推出的全新通用型的高性能SOC芯片，这款CPU到底有多么的高性能，下面看看它的几个特性：8核心6 TOPS超强算力双千
    米尔电子嵌入式 2025-01-03 17:04 49浏览
  • PLC组态的方式与比较
    PLC组态方式主要有三种，每种都有其独特的特点和适用场景。下面来简单说说： 1. 硬件组态   定义：硬件组态指的是选择适合的PLC型号、I/O模块、通信模块等硬件组件，并按照实际需求进行连接和配置。    灵活性：这种方式允许用户根据项目需求自由搭配硬件组件，具有较高的灵活性。    成本：可能需要额外的硬件购买成本，适用于对系统性能和扩展性有较高要求的场合。 2. 软件组态   定义：软件组态主要是通过PLC
    丙丁先生 2025-01-06 09:23 71浏览
  • Matter 标准：破生态枷锁，启家居智能新时代
    在智能家居领域中，Wi-Fi、蓝牙、Zigbee、Thread与Z-Wave等无线通信协议是构建短距物联局域网的关键手段，它们常在实际应用中交叉运用，以满足智能家居生态系统多样化的功能需求。然而，这些协议之间并未遵循统一的互通标准，缺乏直接的互操作性，在进行组网时需要引入额外的网关作为“翻译桥梁”，极大地增加了系统的复杂性。 同时，Apple HomeKit、SamSung SmartThings、Amazon Alexa、Google Home等主流智能家居平台为了提升市占率与消费者
    华普微HOPERF 2025-01-06 17:23 102浏览
  • 如何区分315MHz和433MHz遥控模块？
    每日可见的315MHz和433MHz遥控模块，你能分清楚吗？众所周知，一套遥控设备主要由发射部分和接收部分组成，发射器可以将控制者的控制按键经过编码，调制到射频信号上面，然后经天线发射出无线信号。而接收器是将天线接收到的无线信号进行解码，从而得到与控制按键相对应的信号，然后再去控制相应的设备工作。当前，常见的遥控设备主要分为红外遥控与无线电遥控两大类，其主要区别为所采用的载波频率及其应用场景不一致。红外遥控设备所采用的射频信号频率一般为38kHz，通常应用在电视、投影仪等设备中；而无线电遥控设备
    华普微HOPERF 2025-01-06 15:29 100浏览
  • 封闭式电机行业发展现状及市场潜力分析报告
    根据Global Info Research项目团队最新调研，预计2030年全球封闭式电机产值达到1425百万美元，2024-2030年期间年复合增长率CAGR为3.4%。 封闭式电机是一种电动机，其外壳设计为密闭结构，通常用于要求较高的防护等级的应用场合。封闭式电机可以有效防止外部灰尘、水分和其他污染物进入内部，从而保护电机的内部组件，延长其使用寿命。 环洋市场咨询机构出版的调研分析报告【全球封闭式电机行业总体规模、主要厂商及IPO上市调研报告，2025-2031】研究全球封闭式电机总体规
    GIRtina 2025-01-06 11:10 89浏览
  • 德鲁克著作的解读：从“人”与“事”看管理的本质
    彼得·德鲁克被誉为“现代管理学之父”，他的管理思想影响了无数企业和管理者。然而，关于他的书籍分类，一种流行的说法令人感到困惑：德鲁克一生写了39本书，其中15本是关于管理的，而其中“专门写工商企业或为企业管理者写的”只有两本——《为成果而管理》和《创新与企业家精神》。这样的表述广为流传，但深入探讨后却发现并不完全准确。让我们一起重新审视这一说法，解析其中的矛盾与根源，进而重新认识德鲁克的管理思想及其著作的真正价值。从《创新与企业家精神》看德鲁克的视角《创新与企业家精神》通常被认为是一本专为企业管
    优思学院 2025-01-06 12:03 84浏览
  • MCU应用第008篇 Eclipse环境下MCU寄存器描述文件的存储位置
        为控制片内设备并且查询其工作状态，MCU内部总是有一组特殊功能寄存器（SFR，Special Function Register）。    使用Eclipse环境调试MCU程序时，可以利用 Peripheral Registers Viewer来查看SFR。这个小工具是怎样知道某个型号的MCU有怎样的寄存器定义呢？它使用一种描述性的文本文件——SVD文件。这个文件存储在下面红色字体的路径下。    例：南京沁恒  &n
    电子知识打边炉 2025-01-04 20:04 89浏览
  • 硅电容系列一：硅电容概述
    这篇内容主要讨论三个基本问题，硅电容是什么，为什么要使用硅电容，如何正确使用硅电容？1.  硅电容是什么首先我们需要了解电容是什么？物理学上电容的概念指的是给定电位差下自由电荷的储藏量，记为C，单位是F，指的是容纳电荷的能力，C=εS/d=ε0εrS/4πkd（真空）=Q/U。百度百科上电容器的概念指的是两个相互靠近的导体，中间夹一层不导电的绝缘介质。通过观察电容本身的定义公式中可以看到，在各个变量中比较能够改变的就是εr，S和d，也就是介质的介电常数，金属板有效相对面积以及距离。当前
    知白 2025-01-06 12:04 121浏览
  • 带驱动隔离器的自动化生产设备的未来
    自动化已成为现代制造业的基石，而驱动隔离器作为关键组件，在提升效率、精度和可靠性方面起到了不可或缺的作用。随着工业技术不断革新，驱动隔离器正助力自动化生产设备适应新兴趋势，并推动行业未来的发展。本文将探讨自动化的核心趋势及驱动隔离器在其中的重要角色。自动化领域的新兴趋势智能工厂的崛起智能工厂已成为自动化生产的新标杆。通过结合物联网（IoT）、人工智能（AI）和机器学习（ML），智能工厂实现了实时监控和动态决策。驱动隔离器在其中至关重要，它确保了传感器、执行器和控制单元之间的信号完整性，同时提供高
    腾恩科技-彭工 2025-01-03 16:28 169浏览
我要评论
0
点击右上角，分享到朋友圈 我知道啦
请使用浏览器分享功能 我知道啦