go语言实现简单工厂模式

已于 2023-03-12 10:26:56 修改
阅读量449 收藏
点赞数
文章标签： 简单工厂模式 go
于 2023-03-04 11:01:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_46792762/article/details/129331753
版权
本文介绍了如何使用Go语言实现简单工厂模式，通过对比不同版本的代码展示其优势和缺点。简单工厂模式能实现对象创建与使用的解耦，但增加新产品时需要修改工厂类，违反开闭原则。文中还探讨了适用的场景，如对象创建过程复杂或子类有共同属性和方法的情况。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

前言

本系列文章将介绍使用go语言实现23种设计模式，今天将要介绍的是使用go语言实现简单工厂模式。

定义

简单工厂的定义：提供创建对象的接口。

关键：

1.公共父类：定义公共属性，公共的方法，所有子类都必须有这些公共属性和公共方法。它是工厂类创建的所有对象的父类，封装了各种产品对象的共有方法

2.继承公共父类的子类：在继承父类基础上，增加区别与其他子类的业务。它是简单工厂模式的创建目标。

3.生产子类的工厂：用于new各个子类的中间类。也即是：Factory（工厂角色）：即工厂类，它是简单工厂模式的核心，负责实现创建所有产品实例的内部逻辑；其可以被外界直接调用，创建所需的产品对象。

例子

实现一个发不同样式短信的功能，比如说可以发纯文本的短信，带视频的短信，带卡片的短信，纯图片的短信等。

版本1.0的代码如下所示：

package main

import (
   "errors"
   "fmt"
   "github.com/prometheus/common/log"
)

/**
实现发不同样式的短信版本1.0
*/

const (
   _ = iota
   Text
   Picture
   Card
   Video
)

func SendText(content string, typ int) (isSuccess bool, err error) {
   if typ != Text {
      err = errors.New("140001")
      return
   }
   if content == "" {
      err = errors.New("150001")
      log.Errorf("发送内容不能空 content(%+v) err(%+v)", content, err)
      return
   }
   isSuccess = true
   fmt.Printf("发送的内容为：%s\n", content)
   return
}

func SendPicture(content string, typ int) (isSuccess bool, err error) {
   if typ != Picture {
      err = errors.New("1400002")
      return
   }
   if content == "" {
      err = errors.New("150002")
      log.Errorf("发送内容不能空 content(%+v) err(%+v)", content, err)
      return
   }
   // 获取图片的内容，校验图片等
   isSuccess = true
   fmt.Printf("发送的内容为：%s\n", content)
   return
}

func SendCard(content string, typ int) (isSuccess bool, err error) {
   if typ != Card {
      err = errors.New("140003")
      return
   }
   if content == "" {
      err = errors.New("150003")
      log.Errorf("发送内容不能空 content(%+v) err(%+v)", content, err)
      return
   }
   // 获取卡片的参数校验
   isSuccess = true
   fmt.Printf("发送的内容为：%s\n", content)
   return
}

func SendVideo(content string, typ int) (isSuccess bool, err error) {
   if typ != Video {
      err = errors.New("140004")
      return
   }
   if content == "" {
      err = errors.New("150004")
      log.Errorf("发送内容不能空 content(%+v) err(%+v)", content, err)
      return
   }
   // 获取视频的参数校验
   isSuccess = true
   fmt.Printf("发送的内容为：%s\n", content)
   return
}

func main() {
   var (
      typ       = 1
      content   = "我是文本私信"
      isSuccess bool
      err       error
   )
   switch typ {
   case Text:
      isSuccess, err = SendText(content, Text)
      if err != nil {
         log.Fatal(err)
         return
      }
   case Picture:
      isSuccess, err = SendPicture(content, Picture)
      if err != nil {
         log.Fatal(err)
         return
      }
   case Card:
      isSuccess, err = SendCard(content, Card)
      if err != nil {
         log.Fatal(err)
         return
      }
   case Video:
      isSuccess, err = SendVideo(content, Video)
      if err != nil {
         log.Fatal(err)
         return
      }
   }
   if isSuccess {
      fmt.Println("消息发送成功")
      return
   }
   fmt.Println("消息发送失败")
}

这段代码的缺点：

1.完全没有使用面向对象的编程

2.不容易维护，扩展性不强，不符合开闭原则，每次增加新的功能都需要修改这段代码

3.各个功能耦合度太高

4.不灵活

5.。。。。

版本2.0的代码

package main

import (
	"errors"
	"fmt"
	"github.com/prometheus/common/log"
)

/**
发短信2.0
使用面向对象的思想
*/

const (
	_ = iota
	TextType
	PictureType
	CardType
	VideoType
)

type Message struct {
	Content  string
	Sender   string // 发送人
	Receiver string // 接收者
	Params   string //接收参数
}

type SendResult struct {
	isSuccess bool
}

func (msg *Message) CheckParams() (err error) {
	if msg.Content == "" {
		err = errors.New("601")
		log.Errorf("发送内容不能为空 err(%+v)", err)
		return
	}
	if msg.Sender == "" {
		err = errors.New("602")
		log.Errorf("发送人不能为空 err(%+v)", err)
		return
	}
	if len(msg.Receiver) == 0 {
		err = errors.New("603")
		log.Errorf("接收人不能为空")
	}
	return
}

func Send(sender, receiver, content string) (res bool, err error) {
	if content == "" {
		err = errors.New("14000")
		log.Errorf("发送内容不能为空 content(%s) err(%+v)", content, err)
		return
	}
	fmt.Printf("%s发送消息给：%s\n", sender, receiver)
	fmt.Println(content)
	res = true
	return
}

type SendMsg interface {
	SendMsg(msg *Message) (sendResult *SendResult, err error)
}

type TextMsg struct {
	Typ     int
	Message *Message
}

func (text *TextMsg) SendMsg(msg *Message) (res *SendResult, err error) {
	res = new(SendResult)
	if text.Typ != TextType {
		err = errors.New("151")
		log.Errorf("消息类型不合法 err(%+v)", err)
		return
	}
	err = text.Message.CheckParams()
	if err != nil {
		log.Errorf("参数校验不合法 err(%+v)", err)
		return
	}
	res.isSuccess, err = Send(msg.Sender, msg.Receiver, "文本消息："+msg.Content)
	if err != nil {
		log.Errorf("sendMsg err(%+v)", err)
		return
	}
	return
}

type PictureMsg struct {
	Typ     int
	Message *Message
}

func (text *PictureMsg) SendMsg(msg *Message) (res *SendResult, err error) {
	res = new(SendResult)
	if text.Typ != PictureType {
		err = errors.New("152")
		log.Errorf("消息类型不合法 err(%+v)", err)
		return
	}
	err = text.Message.CheckParams()
	if err != nil {
		log.Errorf("参数校验不合法 err(%+v)", err)
		return
	}
	res.isSuccess, err = Send(msg.Sender, msg.Receiver, "图片消息："+msg.Content)
	if err != nil {
		log.Errorf("sendMsg err(%+v)", err)
		return
	}
	return
}

type CardMsg struct {
	typ     int
	Message *Message
}

func (text *CardMsg) SendMsg(msg *Message) (res *SendResult, err error) {
	res = new(SendResult)
	if text.typ != CardType {
		err = errors.New("153")
		log.Errorf("消息类型不合法 err(%+v)", err)
		return
	}
	err = text.Message.CheckParams()
	if err != nil {
		log.Errorf("参数校验不合法 err(%+v)", err)
		return
	}
	res.isSuccess, err = Send(msg.Sender, msg.Receiver, "卡片消息："+msg.Content)
	if err != nil {
		log.Errorf("CardMsg err(%+v)", err)
		return
	}
	return
}

type VideoMsg struct {
	typ     int
	Message *Message
}

func (text *VideoMsg) SendMsg(msg *Message) (res *SendResult, err error) {
	res = new(SendResult)
	if text.typ != VideoType {
		err = errors.New("154")
		log.Errorf("消息类型不合法 err(%+v)", err)
		return
	}
	err = text.Message.CheckParams()
	if err != nil {
		log.Errorf("参数校验不合法 err(%+v)", err)
		return
	}
	res.isSuccess, err = Send(msg.Sender, msg.Receiver, "视频消息："+msg.Content)
	if err != nil {
		log.Errorf("sendMsg err(%+v)", err)
		return
	}
	return
}

func main() {
	// 客户端代码
	message := &Message{
		Content:  "在吗",
		Sender:   "张三",
		Receiver: "李四",
	}
	text := PictureMsg{
		Typ:     2,
		Message: message,
	}
	res, err := text.SendMsg(message)
	if err != nil {
		log.Errorf("err(%+v)", err)
	}

	if res.isSuccess {
		fmt.Println("消息发送成功")
	} else {
		fmt.Println("消息发送失败")
	}
}

缺点：

1.耦合性太高，而且如果要增加一个短信的类型，要修改代码

2.每次都要new一个对象，客户端要每次判断前端传过来的对象，使用switch

版本3.0代码之-简单工厂

package main

import (
	"errors"
	"fmt"
	"github.com/prometheus/common/log"
)

/**
发短信2.0
使用面向对象的思想
*/

const (
	_ = iota
	TextType
	PictureType
	CardType
	VideoType
)

type Message struct {
	Content  string
	Sender   string // 发送人
	Receiver string // 接收者
	Params   string //接收参数
}

type SendResult struct {
	isSuccess bool
}

func (msg *Message) CheckParams() (err error) {
	if msg.Content == "" {
		err = errors.New("601")
		log.Errorf("发送内容不能为空 err(%+v)", err)
		return
	}
	if msg.Sender == "" {
		err = errors.New("602")
		log.Errorf("发送人不能为空 err(%+v)", err)
		return
	}
	if len(msg.Receiver) == 0 {
		err = errors.New("603")
		log.Errorf("接收人不能为空")
	}
	return
}

func Send(sender, receiver, content string) (res bool, err error) {
	if content == "" {
		err = errors.New("14000")
		log.Errorf("发送内容不能为空 content(%s) err(%+v)", content, err)
		return
	}
	fmt.Printf("%s发送消息给：%s\n", sender, receiver)
	fmt.Println(content)
	res = true
	return
}

type SendMsg interface {
	SendMsg() (sendResult *SendResult, err error)
}

type TextMsg struct {
	*Message
}

func (text *TextMsg) SendMsg() (res *SendResult, err error) {
	res = new(SendResult)
	err = text.Message.CheckParams()
	if err != nil {
		log.Errorf("参数校验不合法 err(%+v)", err)
		return
	}
	res.isSuccess, err = Send(text.Sender, text.Receiver, "文本消息："+text.Content)
	if err != nil {
		log.Errorf("sendMsg err(%+v)", err)
		return
	}
	return
}

type PictureMsg struct {
	*Message
}

func (text *PictureMsg) SendMsg() (res *SendResult, err error) {
	res = new(SendResult)
	err = text.Message.CheckParams()
	if err != nil {
		log.Errorf("参数校验不合法 err(%+v)", err)
		return
	}
	res.isSuccess, err = Send(text.Sender, text.Receiver, "图片消息："+text.Content)
	if err != nil {
		log.Errorf("sendMsg err(%+v)", err)
		return
	}
	return
}

type CardMsg struct {
	*Message
}

func (text *CardMsg) SendMsg() (res *SendResult, err error) {
	res = new(SendResult)
	err = text.Message.CheckParams()
	if err != nil {
		log.Errorf("参数校验不合法 err(%+v)", err)
		return
	}
	res.isSuccess, err = Send(text.Sender, text.Receiver, "卡片消息："+text.Content)
	if err != nil {
		log.Errorf("CardMsg err(%+v)", err)
		return
	}
	return
}

type VideoMsg struct {
	*Message
}

func (text *VideoMsg) SendMsg() (res *SendResult, err error) {
	res = new(SendResult)
	err = text.Message.CheckParams()
	if err != nil {
		log.Errorf("参数校验不合法 err(%+v)", err)
		return
	}
	res.isSuccess, err = Send(text.Sender, text.Receiver, "视频消息："+text.Content)
	if err != nil {
		log.Errorf("sendMsg err(%+v)", err)
		return
	}
	return
}

type MessageFactory struct {
}

func (factory *MessageFactory) MessageFactory(message *Message, tpy int) SendMsg {
	msg := message
	switch tpy {
	case TextType:
		return &TextMsg{msg}
	case CardType:
		return &CardMsg{msg}
	case PictureType:
		return &PictureMsg{msg}
	case VideoType:
		return &VideoMsg{msg}
	default:
		return nil
	}
	return nil
}

func main() {
	// 客户端代码
	message := &Message{
		Content:  "在吗",
		Sender:   "张三",
		Receiver: "李四",
	}

	messageFactory := &MessageFactory{}
	res := messageFactory.MessageFactory(message, 2)
	result, err := res.SendMsg()
	if err != nil {
		log.Errorf("err(%+v)", err)
	}

	if result.isSuccess {
		fmt.Println("消息发送成功")
	} else {
		fmt.Println("消息发送失败")
	}
}

简单工程的使用场景

（1）对象的创建过程(实例化)很复杂，需要初始化很多参数，比如查询数据库等

（2）子类有相同的属性和方法

简单工厂的优缺点 

优点

1、解耦：把对象的创建和使用分开

2、统一创建对象，方便管理

缺点

1、增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

golang创建式设计模式---工厂模式
weixin_55418082的博客
05-19 1388
工厂模式(Factory Method Pattern)是一种设计模式，旨在创建对象时，将对象的创建与使用进行分离。通过定义一个工厂类，这个类具有创建不同具体产品对象的方法。用户只需与工厂类交互，告诉工厂自己想要什么类型的产品，工厂就会负责创建并返回相应的产品对象。这样做的好处是使得系统的架构更加清晰、灵活，方便扩展和维护产品的种类，同时也降低了代码之间耦合度。简单来说，就是有个专门负责生产对象的“地方”，根据需求生产出对应的对象。其uml类图由图可知，工厂方法模式的角色组成如下。
Go语言设计模式——简单工厂模式
youm2003的博客
01-15 643
简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
Go 实现简单工厂模式
啦啦丶德玛西亚的博客
02-09 462
简单工厂模式 又称为静态工厂方法，它属于类创建型模式 简单工厂模式的要点 当需要什么时，只需要传入一个正确的参数，就可以获取到你所需要的对象，不需要知道它的创建细节 什么时候需要简单工厂模式？ 1、创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。 2、客户端只知道传入工厂类的参数，对于如何创建对象不关心，只需要知道类型对应的参数即可。 案例演示 1、背景 我去奶茶店买奶茶。 2、背景解析 我 ==> 客户端 ==> 我的目标 ==> 要买奶茶（我不关心奶茶是怎么做的，是谁做的，我
剖析 Go 语言中的工厂模式：创建对象的优雅之道
cloudman08的博客
03-29 767
工厂模式是 Go 语言中一种非常实用的创建型设计模式，它提供了一种优雅、灵活的方式来创建对象。简单工厂模式适用于对象创建逻辑简单的场景；工厂方法模式适用于需要根据不同条件创建不同类型对象的场景；抽象工厂模式适用于需要创建一组相关或相互依赖对象的场景。在实际项目中，我们可以根据具体的需求选择合适的工厂模式，以提高代码的可维护性和可扩展性。
Go语言实现简单工厂模式
weixin_51195721的博客
05-17 314
go语言实现简单工厂模式
go语言中工厂模式
wtt234的专栏
04-15 506
mode.go代码 package model //定义一个结构体 type student struct { Name string Score float64 } //因为student结构体首字母是小写，不能为model外的模块使用，解决方法 //通过工厂模式来解决，如下代码, func NewStudent(n string,ss float64)*student{ return &student{ n, ss, } } main.go代码 v.
二）golang工厂模式
weixin_34208283的博客
02-27 184
在通用的工厂模式中，一般涉及到 简单工厂模式(顾名思义：工厂 > 创建)、工厂方法(顾名思义：将方法工厂化)、抽象工厂模式(顾名思义：将工厂抽象化 工厂 > 工厂 > 创建) 特点：将接口与具体实现分离，根据需要实例化对象使用场景：日志记录，文件服务平台，数据库访问 1.定义产品接口 type P interface {...
go语言设计模式待代码简单实现
05-08
本篇文章将基于"Go语言设计模式待代码简单实现"这一主题，探讨Go语言中常见的设计模式及其应用。 1. 工厂模式：工厂模式是创建型设计模式的一种，它提供了一种创建对象的最佳方式。在Go语言中，可以通过定义一个...
Go语言实现设计模式：简单工厂模式
为了实现简单工厂模式，定义了一个`OperationFactory`结构体，它包含一个`createOperation`方法。这个方法接收一个表示运算符的字符串作为参数，然后根据运算符返回相应的运算类实例。例如，如果运算符是"+"，则返回...
Go语言设计模式：单例与工厂模式的并发安全实现.pdf
最新发布
05-05
Go 语言以极简设计理念和出色工程性能，成为云原生时代的首选编程语言。从 Docker 到 Kubernetes，全球顶尖科技企业都在采用 Go。点击了解 Go 语言的核心优势、实战窍门和未来走向，开启高效编程的全新体验！
Go语言设计模式：简单工厂模式的实现与优缺点
简单工厂模式在Go语言中的实现和在其他面向对象语言中类似，但要注意Go语言的一些特性，如接口的使用和函数式编程的倾向。对于设计模式的学习和应用，重要的是理解每种模式的使用场景和优缺点，然后结合具体语言的...
Go：工厂模式
weixin_34221112的博客
05-28 164
Go的结构体没有构造函数，通常可以使用工厂模式来解决这个问题。 一个结构体的声明是这样的： package model type Student struct { Name string } 因为 Student 的首字母 S 是大写的，如果我们想在其他包创建 Student 的实例（比如 main 包），引入 model 包后，就可以直接创建 Student 的实例...
go的工厂模式
z3551906947的博客
08-06 1129
工厂模式是一种常用的软件设计模式，它属于创建型模式之一，其核心思想是将对象的创建和使用分离，以此来提高代码的模块化和可维护性。定义：创建相关或依赖对象的家族，而不需明确指定具体类。提供一个接口以创建一族相关或依赖的对象，而不需要构造它们的具体类。适用场景：当需要生成多个产品族时。优点：易于扩展新的产品族，同时保持了产品的一致性。缺点：新增产品等级结构困难，增加了系统的复杂度。简单工厂模式是一种创建型设计模式，它使用一个工厂类根据传入的参数来决定创建出哪一种产品类的实例。
设计模式-简单工厂模式（Go实现）
关注网络安全、云原生安全
07-31 640
目录简单工厂模式需求修改前错误设计代码修改后正确设计代码实现测试测试代码测试结果总结适用场景优点缺点 简单工厂模式 简单工厂模式并不属于GoF的23个经典设计模式，但通常将它作为学习其他工厂模式的基础，它的设计思想很简单，其基本流程如下： 首先将需要创建的各种不同对象（例如各种不同的Food对象）的相关代码封装到不同的类中，这些类称为具体产品类，而将它们公共的代码进行抽象和提取后封装在一个抽象产品类中，每一个具体产品类都是抽象产品类的子类；然后提供一个工厂类用于创建各种产品，在工厂类中提供一个创建产品的工
go语言实现设计模式（二）：简易工厂
做一只会做软件的程序猴
11-01 2105
简易工厂主要是用来解决对象“创建”的问题。以下的例子取自《大话设计模式》中第一章，实现一个可扩展的“计算器”。当增加新的功能时，并不需改动原来已经实现的算法。由于是简易工厂，所以我们还是需要对工厂类进行相应修改。1.首先，我们定义一个计算的接口package calctype CalcSuper interface { SetData(data ...interface{}) Cal
Go实现设计模式系列（3）——Go实现简单工厂模式
pigff的博客
07-28 566
Simple Factory Pattern（简单工厂模式） 简单工厂模式属于创建型模式，不会对外暴露创建对象的逻辑，并且我们通过一个共同的接口来创建不同的对象。 形象地理解就是，使用同一个工厂，可以创建出不同的产品，比如玩具工厂，可以生产出不同的玩具。 五大要素 来看看New模式的五大要素： 模式名称：简单工厂模式 目的（What）：定义一个创建具体对象的工厂，有工厂调用者自己决定创建哪个对象 解决的问题（Why）：当我们明确知道不同地条件下需要创建不同的对象时，使用这种模式 解决方案（How）：通
Go 语言 设计模式-工厂模式
Ch3nnn的博客
09-13 380
gun­Fac­to­ry枪支工厂结构体将发挥工厂的作用， 即通过传入参数构建所需类型的枪支。由于 Go 中缺少类和继承等 OOP 特性， 所以无法使用 Go 来实现经典的工厂方法模式。首先， 我们来创建一个名为 i­Gun的接口， 其中将定义一支枪所需具备的所有方法。ak47或 mus­ket进行互动， 而是依靠 gun­Fac­to­ry来创建多种枪支的实例， 仅使用字符参数来控制生产。两种具体的枪支——ak47与 mus­ket火枪 ——两者都嵌入了枪支结构体， 且间接实现了所有的 i­Gun方法。
[go设计模式]简单工厂模式
有用用之，无用弃之
10-06 436
优点 工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。 缺点 由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了...
go工厂模式
人在码途
09-24 743
Go：工厂模式 Go的结构体没有构造函数，通常可以使用工厂模式来解决这个问题。 一个结构体的声明是这样的： packageexer typeExersstruct{ accountNo string pwd string balanced float64 } 因为 Exers 的首字母 E是大写的，如果我们想在其他包创建 Exers 的实例（比如 main...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值