golang设计模式——工厂模式

最新推荐文章于 2024-09-04 09:49:15 发布
最新推荐文章于 2024-09-04 09:49:15 发布
阅读量513 收藏 2
点赞数 1
分类专栏： 设计模式 文章标签： golang 设计模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53267860/article/details/126233533
版权

工厂模式

目录

图解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9YEcz60x-1659954698730)(C:/Users/86158/AppData/Roaming/Typora/typora-user-images/image-20220808090041304.png)]

简单工厂

由于 Go 本身是没有构造函数的，一般而言我们采用 NewName 的方式创建对象/接口，当它返回的是接口的时候，其实就是简单工厂模式

代码编写

package factory

// IRuleConfigParser IRuleConfigParser
type IRuleConfigParser interface {
	Parse(data []byte)
}

// jsonRuleConfigParser jsonRuleConfigParser
type jsonRuleConfigParser struct {
}

// Parse Parse
func (J jsonRuleConfigParser) Parse(data []byte) {
	panic("implement me")
}

// yamlRuleConfigParser yamlRuleConfigParser
type yamlRuleConfigParser struct {
}

// Parse Parse
func (Y yamlRuleConfigParser) Parse(data []byte) {
	panic("implement me")
}

// NewIRuleConfigParser NewIRuleConfigParser
func NewIRuleConfigParser(t string) IRuleConfigParser {
	switch t {
	case "json":
		return jsonRuleConfigParser{}
	case "yaml":
		return yamlRuleConfigParser{}
	}
	return nil
}

单元测试

package factory

import (
	"reflect"
	"testing"
)

func TestNewIRuleConfigParser(t *testing.T) {
	type args struct {
		t string
	}
	tests := []struct {
		name string
		args args
		want IRuleConfigParser
	}{
		{
			name: "json",
			args: args{t: "json"},
			want: jsonRuleConfigParser{},
		},
		{
			name: "yaml",
			args: args{t: "yaml"},
			want: yamlRuleConfigParser{},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := NewIRuleConfigParser(tt.args.t); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("NewIRuleConfigParser() = %v, want %v", got, tt.want)
			}
		})
	}
}

工厂方法

当对象的创建逻辑比较复杂，不只是简单的 new 一下就可以，而是要组合其他类对象，做各种初始化操作的时候，推荐使用工厂方法模式，将复杂的创建逻辑拆分到多个工厂类中，让每个工厂类都不至于过于复杂

代码编写

// IRuleConfigParserFactory 工厂方法接口
type IRuleConfigParserFactory interface {
	CreateParser() IRuleConfigParser
}

// yamlRuleConfigParserFactory yamlRuleConfigParser 的工厂类
type yamlRuleConfigParserFactory struct {
}

// CreateParser CreateParser
func (y yamlRuleConfigParserFactory) CreateParser() IRuleConfigParser {
	return yamlRuleConfigParser{}
}

// jsonRuleConfigParserFactory jsonRuleConfigParser 的工厂类
type jsonRuleConfigParserFactory struct {
}

// CreateParser CreateParser
func (j jsonRuleConfigParserFactory) CreateParser() IRuleConfigParser {
	return jsonRuleConfigParser{}
}

// NewIRuleConfigParserFactory 用一个简单工厂封装工厂方法
func NewIRuleConfigParserFactory(t string) IRuleConfigParserFactory {
	switch t {
	case "json":
		return jsonRuleConfigParserFactory{}
	case "yaml":
		return yamlRuleConfigParserFactory{}
	}
	return nil
}

单元测试

package factory

import (
	"reflect"
	"testing"
)

func TestNewIRuleConfigParserFactory(t *testing.T) {
	type args struct {
		t string
	}
	tests := []struct {
		name string
		args args
		want IRuleConfigParserFactory
	}{
		{
			name: "json",
			args: args{t: "json"},
			want: jsonRuleConfigParserFactory{},
		},
		{
			name: "yaml",
			args: args{t: "yaml"},
			want: yamlRuleConfigParserFactory{},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := NewIRuleConfigParserFactory(tt.args.t); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("NewIRuleConfigParserFactory() = %v, want %v", got, tt.want)
			}
		})
	}
}

抽象工厂

代码编写

package factory

// IRuleConfigParser IRuleConfigParser
type IRuleConfigParser interface {
	Parse(data []byte)
}

// jsonRuleConfigParser jsonRuleConfigParser
type jsonRuleConfigParser struct{}

// Parse Parse
func (j jsonRuleConfigParser) Parse(data []byte) {
	panic("implement me")
}

// ISystemConfigParser ISystemConfigParser
type ISystemConfigParser interface {
	ParseSystem(data []byte)
}

// jsonSystemConfigParser jsonSystemConfigParser
type jsonSystemConfigParser struct{}

// Parse Parse
func (j jsonSystemConfigParser) ParseSystem(data []byte) {
	panic("implement me")
}

// IConfigParserFactory 工厂方法接口
type IConfigParserFactory interface {
	CreateRuleParser() IRuleConfigParser
	CreateSystemParser() ISystemConfigParser
}

type jsonConfigParserFactory struct{}

func (j jsonConfigParserFactory) CreateRuleParser() IRuleConfigParser {
	return jsonRuleConfigParser{}
}

func (j jsonConfigParserFactory) CreateSystemParser() ISystemConfigParser {
	return jsonSystemConfigParser{}
}

单元测试

package factory

import (
	"reflect"
	"testing"
)

func Test_jsonConfigParserFactory_CreateRuleParser(t *testing.T) {
	tests := []struct {
		name string
		want IRuleConfigParser
	}{
		{
			name: "json",
			want: jsonRuleConfigParser{},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			j := jsonConfigParserFactory{}
			if got := j.CreateRuleParser(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreateRuleParser() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_jsonConfigParserFactory_CreateSystemParser(t *testing.T) {
	tests := []struct {
		name string
		want ISystemConfigParser
	}{
		{
			name: "json",
			want: jsonSystemConfigParser{},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			j := jsonConfigParserFactory{}
			if got := j.CreateSystemParser(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreateSystemParser() = %v, want %v", got, tt.want)
			}
		})
	}
}

DI 容器

golang 现有的依赖注入框架:

  • 使用反射实现的: https://github.com/uber-go/dig
  • 使用 generate 实现的: https://github.com/google/wire

下文将通过反射实现一个类似 dig 简单的 demo，在课程里面的例子是读取配置文件，然后进行生成，下面提供是通过 provider 进行构建依赖关系。

代码实现

package di

import (
	"fmt"
	"reflect"
)

// Container DI 容器
type Container struct {
	// 假设一种类型只能有一个 provider 提供
	providers map[reflect.Type]provider

	// 缓存以生成的对象
	results map[reflect.Type]reflect.Value
}

type provider struct {
	value reflect.Value

	params []reflect.Type
}

// New 创建一个容器
func New() *Container {
	return &Container{
		providers: map[reflect.Type]provider{},
		results:   map[reflect.Type]reflect.Value{},
	}
}

// isError 判断是否是 error 类型
func isError(t reflect.Type) bool {
	if t.Kind() != reflect.Interface {
		return false
	}
	return t.Implements(reflect.TypeOf(reflect.TypeOf((*error)(nil)).Elem()))
}

// Provide 对象提供者，需要传入一个对象的工厂方法，后续会用于对象的创建
func (c *Container) Provide(constructor interface{}) error {
	v := reflect.ValueOf(constructor)

	// 仅支持函数 provider
	if v.Kind() != reflect.Func {
		return fmt.Errorf("constructor must be a func")
	}

	vt := v.Type()

	// 获取参数
	params := make([]reflect.Type, vt.NumIn())
	for i := 0; i < vt.NumIn(); i++ {
		params[i] = vt.In(i)
	}

	// 获取返回值
	results := make([]reflect.Type, vt.NumOut())
	for i := 0; i < vt.NumOut(); i++ {
		results[i] = vt.Out(i)
	}

	provider := provider{
		value:  v,
		params: params,
	}

	// 保存不同类型的 provider
	for _, result := range results {
		// 判断返回值是不是 error
		if isError(result) {
			continue
		}

		if _, ok := c.providers[result]; ok {
			return fmt.Errorf("%s had a provider", result)
		}

		c.providers[result] = provider
	}

	return nil
}

// Invoke 函数执行入口
func (c *Container) Invoke(function interface{}) error {
	v := reflect.ValueOf(function)

	// 仅支持函数 provider
	if v.Kind() != reflect.Func {
		return fmt.Errorf("constructor must be a func")
	}

	vt := v.Type()

	// 获取参数
	var err error
	params := make([]reflect.Value, vt.NumIn())
	for i := 0; i < vt.NumIn(); i++ {
		params[i], err = c.buildParam(vt.In(i))
		if err != nil {
			return err
		}
	}

	v.Call(params)

	// 获取 providers
	return nil
}

// buildParam 构建参数
// 1. 从容器中获取 provider
// 2. 递归获取 provider 的参数值
// 3. 获取到参数之后执行函数
// 4. 将结果缓存并且返回结果
func (c *Container) buildParam(param reflect.Type) (val reflect.Value, err error) {
	if result, ok := c.results[param]; ok {
		return result, nil
	}

	provider, ok := c.providers[param]
	if !ok {
		return reflect.Value{}, fmt.Errorf("can not found provider: %s", param)
	}

	params := make([]reflect.Value, len(provider.params))
	for i, p := range provider.params {
		params[i], err = c.buildParam(p)
	}

	results := provider.value.Call(params)
	for _, result := range results {
		// 判断是否报错
		if isError(result.Type()) && !result.IsNil() {
			return reflect.Value{}, fmt.Errorf("%s call err: %+v", provider, result)
		}

		if !isError(result.Type()) && !result.IsNil() {
			c.results[result.Type()] = result
		}
	}
	return c.results[param], nil
}

我们这里的实现比较粗糙，但是作为一个 demo 理解 di 容器也足够了，和 dig 相比还缺少很多东西，并且有许多的问题，例如 依赖关系，一种类型如果有多个 provider 如何处理等等等等。
可以看到我们总共就三个函数

  • Provide: 获取对象工厂，并且使用一个 map 将对象工厂保存
  • Invoke: 执行入口
  • buildParam: 核心逻辑，构建参数
    • 从容器中获取 provider
    • 递归获取 provider 的参数值
    • 获取到参数之后执行函数
    • 将结果缓存并且返回结果

example

package main

import (
	"fmt"

	di "github.com/mohuishou/go-design-pattern/02_factory/024_di"
)

// A 依赖关系 A -> B -> C
type A struct {
	B *B
}

// NewA NewA
func NewA(b *B) *A {
	return &A{
		B: b,
	}
}

// B B
type B struct {
	C *C
}

// NewB NewB
func NewB(c *C) *B {
	return &B{C: c}
}

// C C
type C struct {
	Num int
}

// NewC NewC
func NewC() *C {
	return &C{
		Num: 1,
	}
}

func main() {
	container := di.New()
	if err := container.Provide(NewA); err != nil {
		panic(err)
	}
	if err := container.Provide(NewB); err != nil {
		panic(err)
	}
	if err := container.Provide(NewC); err != nil {
		panic(err)
	}

	err := container.Invoke(func(a *A) {
		fmt.Printf("%+v: %d", a, a.B.C.Num)
	})
	if err != nil {
		panic(err)
	}
}
~庞贝
关注
专栏目录
思考（五十六）：Golang 编程之工厂模式
范安崇的博客
06-23 588
工厂模式 工厂模式： 在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象 micro/go-micro 在插件的可插拔上使用了工厂模式 micro/go-micro 工厂模式的应用 以Registry的etcd 插件为例 1. 接口 摘自： https://github.com/micro/go-micro/blob/master/registry/registr...
Go设计模式—工厂模式
专注基础架构领域
11-04 758
由于 Go 本身是没有构造函数的，一般而言我们采用NewName的方式创建对象/接口，当它返回的是接口的时候，其实就是简单工厂模式 1、简单工厂 package factory // IRuleConfigParser IRuleConfigParser type IRuleConfigParser interface { Parse(data []byte) } // jsonRuleConfigParser jsonRuleConfigParser t...
二）golang工厂模式
weixin_34208283的博客
02-27 152
在通用的工厂模式中，一般涉及到 简单工厂模式(顾名思义：工厂 &gt; 创建)、工厂方法(顾名思义：将方法工厂化)、抽象工厂模式(顾名思义：将工厂抽象化 工厂 &gt; 工厂 &gt; 创建) 特点：将接口与具体实现分离，根据需要实例化对象使用场景：日志记录，文件服务平台，数据库访问 1.定义产品接口 type P interface {...
Golang 设计模式之工厂方法模式
最新发布
a746277441的博客
09-04 343
工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它提供了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式在 Go 语言中可以用于多种场景，包括依赖注入、测试代码以及需要根据具体情况生成不同对象的场合。通过使用工厂方法模式，我们可以更好地管理代码的扩展性和可维护性。在 Golang 中，工厂方法模式通常用于解耦代码与特定实现之间的依赖关系，从而使代码更具可扩展性和灵活性。：不同的日志级别可能需要不同的日志记录方式。：不同类型的消息需要不同的处理器来处理。
Golang-工厂模式
ALEX_CYL的博客
11-28 319
工厂模式 Golang中的结构体没有构造函数，通常使用工厂模式来解决这个问题。 即：当结构体的首字母小写时，为了在其它包也能创建该结构体的实例，这时就需要工厂模式来解决（通常使用编写一个函数实现功能）。 同理，当字段名小写时，为了能在其它包也能调用该字段，通常使用编写一个方法来实现。 案例演示： model包 package model type Student struct { Name string Score float64 } type person struct { Name stri
【Golang工厂模式】
m0_60657566的博客
02-26 295
工厂模式工厂模式一、说明二、需求三、代码四、思考总结 工厂模式 一、说明 Golang 的结构体没有构造函数，通常可以使用工厂模式来解决这个问题 二、需求 三、代码 通过方法调用内部属性== package model type student struct{ Name string Score float64 } func NewStudent(n string,s float64)*student{ return &student{ Name:n, Score:s, } ..
golang设计模式——结构模式
qq_39280718的博客
09-03 750
结构模式主要关注类和对象的组合
golang设计模式——创建模式
qq_39280718的博客
09-03 640
创建模式是用来帮助我们创建对象的
golang设计模式——简介
qq_39280718的博客
09-03 603
设计模式是面向对象软件的设计经验，是解决特定问题的一系列套路。
golang设计模式——行为模式
qq_39280718的博客
09-03 695
行为模式主要关注对象之间的通信
设计模式——Go语言（Golang）版
weixin_42117918的博客
04-06 918
设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。 从本节开始，陆续介绍设计模式，该设计模式采用Go语言编码实现。 01_简单工厂模式 02_工厂方法模式 03_抽象工厂模式 04_单例模式 05_原型模式 06_建筑者模式 07_适配器模式 08_组合模式 09_代理模式 10_外观模式 1.
golang工厂方法模式
Kiven_super
11-01 386
工厂方法模式使用子类的方式延迟生成对象到子类中实现。 Go中不存在继承 所以使用匿名组合来实现 factorymethod.go package factorymethod //Operator 是被封装的实际类接口 type Operator interface { SetA(int) SetB(int) Result() int } //OperatorFactory 是工厂接口 type OperatorFactory interface { Create() Ope
工厂模式-golang
雨竹的博客
02-12 503
此篇中主要是工厂模式的练习，具体可以看菜鸟教程（http://www.runoob.com/design-pattern/factory-pattern.html）package main import ( "fmt" "strings" ) func main() { s := Shape(Rectangle{}) s.draw() s = Shape(Circ...
golang 工厂模式
qq_39657769的博客
03-09 1165
golang的结构体没有 构造函数，通常可以使用工厂模式来解决这个问题 使用场景，当使用结构体时，结构体名称首字母是小写时，外部就无法引用 此时就可以用工厂模式来解决 案例： 在model包里定义一个结构体首字母大写 package model //定义一个结构体 type Student struct{ Name string Scoute float64 } 在main包里引用 package main import( "fmt" "go_code/project01/o.
Golang 工厂设计模式（一）
王佳宇的个人博客
05-28 7133
设计模式： wiki百科:设计模式（Design pattern）代表了最佳的实践，通常被软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化...
简单工厂模式、工厂方法模式、抽象工厂模式 用图理解
weixin_34233679的博客
07-24 207
1.简单工厂模式 2. 工厂方法模式 3.抽象工厂模式 例子1 例子2 转载于:https://www.cnblogs.com/baxianhua/p/9360111.html
浅谈golang中的工厂模式
weixin_43471422的博客
04-28 676
来自一个大佬的博客，建议食用 设计模式不分语言，是一种思维层面的体现，但是不能在不同语言中使用同一套实现（每种语言有不同的特性），比如go，本身是没有继承一说，但是通过结构体的组合来实现语义上的继承。而多态也是通过接口的方式来实现的。 下方的图来自于大佬博客，贴在这里方便查看！！！ 设计原则 设计模式 创建型模式 工厂模式 工厂模式在大家写项目的时候用到的地方很多，可以用于代码的解耦以及方便拓展。 在说起工厂模式之前，帮大家回忆一下golang中接口的特性： 类型不需要显式声明它实现了某个接口：接口被
设计模式golang-工厂模式
感悟聚集的博客
03-08 131
工厂模式 定义 创建对象的接口，让其子类自己决定实例化哪个类，工厂模式使其创建过程延迟到子类进行。 角色 1.产品抽象接口 2.工厂创建产品方法 3.产品实例 例子 选银行借钱的例子，资质方法根据你的收入等其他情况给你选择银行。 //抽象产品接口 type Bank interface { BorrowMoney() } //具体银行产品实例 type BjBank struct{ } func...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值