0
点赞
收藏
分享

微信扫一扫

4 抽象工厂方法 -- go语言设计模式

春意暖洋洋 2023-08-04 阅读 85
抽象工厂模式Go语言后端开发yyds干货盘点

工厂方法模式通过引入工厂等级结构，解决了简单工厂模式中工厂类职责太重的问题，但由于工厂方法模式中的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，势必会增加系统的开销。因此，可以考虑将一些相关的产品组成一个“产品族”，由同一个工厂来统一生产，这就是本文将要学习的抽象工厂模式的基本思想。

抽象工厂方法模式的实现代码

package main

import "fmt"

// ======= 抽象层 =========
type AbstractApple interface {
	ShowApple()
}

type AbstractBanana interface {
	ShowBanana()
}

type AbstractPear interface {
	ShowPear()
}

//抽象工厂
type AbstractFactory interface {
	CreateApple() AbstractApple
	CreateBanana() AbstractBanana
	CreatePear() AbstractPear
}

// ======== 实现层 =========
/*  中国产品族 */
type ChinaApple struct {}
func (ca *ChinaApple) ShowApple() {
	fmt.Println("中国苹果")
}

type ChinaBanana struct {}
func (cb *ChinaBanana) ShowBanana() {
	fmt.Println("中国香蕉")
}

type ChinaPear struct {}
func (cp *ChinaPear) ShowPear() {
	fmt.Println("中国梨")
}

type ChinaFactory struct {}
func (cf *ChinaFactory) CreateApple() AbstractApple {
	apple := new(ChinaApple)

	return apple
}

func (cf *ChinaFactory) CreateBanana() AbstractBanana {
	banana := new(ChinaBanana)

	return banana
}

func (cf *ChinaFactory) CreatePear() AbstractPear {
	pear := new(ChinaPear)

	return pear
}

/*  日本产品族 */
type JapanApple struct {}
func (ja *JapanApple) ShowApple() {
	fmt.Println("日本苹果")
}

type JapanBanana struct {}
func (jb *JapanBanana) ShowBanana() {
	fmt.Println("日本香蕉")
}

type JapanPear struct {}
func (cp *JapanPear) ShowPear() {
	fmt.Println("日本梨")
}

type JapanFactory struct {}
func (jf *JapanFactory) CreateApple() AbstractApple {
	apple := new(JapanApple)
	return apple
}

func (jf *JapanFactory) CreateBanana() AbstractBanana {
	banana := new(JapanBanana)
	return banana
}

func (cf *JapanFactory) CreatePear() AbstractPear {
	pear := new(JapanPear)

	return pear
}

/*  美国产品族 */
type AmericanApple struct {}
func (aa *AmericanApple) ShowApple() {
	fmt.Println("美国苹果")
}

type AmericanBanana struct {}
func (ab *AmericanBanana) ShowBanana() {
	fmt.Println("美国香蕉")
}

type AmericanPear struct {}
func (ap *AmericanPear) ShowPear() {
	fmt.Println("美国梨")
}

type AmericanFactory struct {}

func (af *AmericanFactory) CreateApple() AbstractApple {
	apple := new(AmericanApple)
	return apple
}

func (af *AmericanFactory) CreateBanana() AbstractBanana {
	banana := new(AmericanBanana)
	return banana
}

func (af *AmericanFactory) CreatePear() AbstractPear {
	pear := new(AmericanPear)
	return pear
}

// ======== 业务逻辑层 =======
func main() {
	//需求1: 需要美国的苹果、香蕉、梨 等对象
	//1-创建一个美国工
	aFac := new(AmericanFactory)

	//2-生产美国苹果
	aApple := aFac.CreateApple()
	aApple.ShowApple()

	//3-生产美国香蕉
	aBanana := aFac.CreateBanana()
	aBanana.ShowBanana()

	//4-生产美国梨
	aPear := aFac.CreatePear()
	aPear.ShowPear()

	//需求2: 需要中国的苹果、香蕉
	//1-创建一个中国工厂
	cFac := new(ChinaFactory)

	//2-生产中国苹果
	cApple := cFac.CreateApple()
	cApple.ShowApple()

	//3-生产中国香蕉
	cBanana := cFac.CreateBanana()
	cBanana.ShowBanana()
}

终端输出

1.png

代码解析

func new(Type) *Type
// 内建函数new分配内存。其第一个实参为类型，而非值。其返回值为指向该类型的新分配的零值的指针。

工厂方法模式的代码拆分

1.项目的准备工作

找到 go 的 GOPATH

$ go env		//可以查看 GOPATH

在 GOPATH 目录下创建3个文件夹

1.bin文件夹		-- 存放编译后的二进制文件

2.pkg文件夹		-- 存放编译后的库文件

3.src文件夹		-- 存放源码文件

2.创建文件夹

​ -- 在项目文件夹 abstruct_fac 里创建新文件夹

​ unify -- 统一，用于存放接口文件

​ module -- 模块，用于存放结构体文件

​ -- 在 module 文件夹里创建

​ china -- 存储与中国相关的结构体

​ japan -- 存储与日本相关的结构体

​ american -- 存储与美国相关的结构体

2.png

3.接口文件 -- unify文件夹

文件1 -- abstractapple.go

package unify

type AbstractApple interface {
	ShowApple()
}

文件2 -- abstractbanana.go

package unify

type AbstractBanana interface {
	ShowBanana()
}

文件3 -- abstractpear.go

package unify

type AbstractPear interface {
	ShowPear()
}

3.png

4.结构体文件 -- module文件夹

1.中国包 -- china 文件夹

文件1 -- chinaapple.go

package china

import "fmt"

/*  中国产品族 */
type ChinaApple struct {}
func (ca *ChinaApple) ShowApple() {
	fmt.Println("中国苹果")
}

文件2 -- chinabanana.go

package china

import "fmt"

type ChinaBanana struct {}
func (cb *ChinaBanana) ShowBanana() {
	fmt.Println("中国香蕉")
}

文件3 -- chinapear.go

package china

import "fmt"

type ChinaPear struct {}
func (cp *ChinaPear) ShowPear() {
	fmt.Println("中国梨")
}

文件1 -- chinafactory.go

package china

import (
		"design/abstract_fac/unify"
)

type ChinaFactory struct {}
func (cf *ChinaFactory) CreateApple() unify.AbstractApple {
	apple := new(ChinaApple)

	return apple
}

func (cf *ChinaFactory) CreateBanana() unify.AbstractBanana {
	banana := new(ChinaBanana)

	return banana
}

func (cf *ChinaFactory) CreatePear() unify.AbstractPear {
	pear := new(ChinaPear)

	return pear
}

4.png

2.日本包 -- japan 文件夹

文件1 -- japanapple.go

package japan

import "fmt"

/*  日本产品族 */
type JapanApple struct {}
func (ja *JapanApple) ShowApple() {
	fmt.Println("日本苹果")
}

文件2 -- japanbanana.go

package japan

import "fmt"

type JapanBanana struct {}
func (jb *JapanBanana) ShowBanana() {
	fmt.Println("日本香蕉")
}

文件3 -- japanpear.go

package japan

import "fmt"

type JapanPear struct {}
func (jp *JapanPear) ShowPear() {
	fmt.Println("日本梨")
}

文件1 -- japanfactory.go

package japan

import (
		"design/abstract_fac/unify"
)

type JapanFactory struct {}
func (jf *JapanFactory) CreateApple() unify.AbstractApple {
	apple := new(JapanApple)
	return apple
}

func (jf *JapanFactory) CreateBanana() unify.AbstractBanana {
	banana := new(JapanBanana)
	return banana
}

func (cf *JapanFactory) CreatePear() unify.AbstractPear {
	pear := new(JapanPear)

	return pear
}

5.png

3.美国包 -- american 文件夹

文件1 -- americanapple.go

package american

import "fmt"

/*  美国产品族 */
type AmericanApple struct {}
func (aa *AmericanApple) ShowApple() {
	fmt.Println("美国苹果")
}

文件2 -- americanbanana.go

package american

import "fmt"

type AmericanBanana struct {}
func (ab *AmericanBanana) ShowBanana() {
	fmt.Println("美国香蕉")
}

文件3 -- americanpear.go

package american

import "fmt"

type AmericanPear struct {}
func (ap *AmericanPear) ShowPear() {
	fmt.Println("美国梨")
}

文件1 -- americanfactory.go

package american

import (
		"design/abstract_fac/unify"
)

type AmericanFactory struct {}

func (af *AmericanFactory) CreateApple() unify.AbstractApple {
	apple := new(AmericanApple)
	return apple
}

func (af *AmericanFactory) CreateBanana() unify.AbstractBanana {
	banana := new(AmericanBanana)
	return banana
}

func (af *AmericanFactory) CreatePear() unify.AbstractPear {
	pear := new(AmericanPear)
	return pear
}

6.png

5.主文件 -- main.go 在项目文件夹

package main

import (
  "design/abstract_fac/module/china"
  "design/abstract_fac/module/japan"
  "design/abstract_fac/module/american"
)

func main() {
	//需求1: 需要中国的苹果、香蕉、梨
	//1-创建一个中国工厂
	cFac := new(china.ChinaFactory)

	//2-生产中国苹果
	cApple := cFac.CreateApple()
	cApple.ShowApple()

	//3-生产中国香蕉
	cBanana := cFac.CreateBanana()
	cBanana.ShowBanana()

	//4-生产中国梨
	cPear := cFac.CreatePear()
	cPear.ShowPear()


	//需求2: 需要日本的苹果、香蕉、梨
	//1-创建一个日本工厂
	jFac := new(japan.JapanFactory)

	//2-生产日本苹果
	jApple := jFac.CreateApple()
	jApple.ShowApple()

	//3-生产日本香蕉
	jBanana := jFac.CreateBanana()
	jBanana.ShowBanana()

	//4-生产日本梨
	jPear := jFac.CreatePear()
	jPear.ShowPear()


	//需求3: 需要美国的苹果、香蕉、梨
	//1-创建一个美国工厂
	aFac := new(american.AmericanFactory)

	//2-生产美国苹果
	aApple := aFac.CreateApple()
	aApple.ShowApple()

	//3-生产美国香蕉
	aBanana := aFac.CreateBanana()
	aBanana.ShowBanana()

	//4-生产美国梨
	aPear := aFac.CreatePear()
	aPear.ShowPear()
}

终端输出

7.png

6.全部文件图

8.png

举报

相关推荐

OOP设计模式_工厂类设计模式的区别（简单工厂方法，工厂方法，抽象工厂模式）

Java程序员程序员技术栈

设计模式(10) -- 工厂设计模式(简单工厂，工厂方法，抽象工厂模式)

设计模式工厂模式ide简单工厂模式构造器虚拟化云计算

设计模式之工厂方法和抽象工厂

工厂类工厂方法抽象工厂软件设计软件研发yyds干货盘点

设计模式之工厂模式(简单工厂、工厂方法、抽象工厂)

java开发语言后端工厂方法模式抽象工厂模式

【设计模式】简单工厂、工厂方法和抽象工厂

c#开发语言

抽象工厂方法模式

工厂方法模式

设计模式——4、工厂方法模式

设计模式javaxml抽象工厂类名Linux系统/运维

【设计模式】单例模式、工厂方法模式、抽象工厂模式

java电子招投标系统源码spring cloud

工厂方法模式和抽象工厂模式

设计模式工厂模式抽象工厂模式工厂方法模式解决方案编程语言

Go 语言 设计模式-抽象工厂模式

抽象工厂工厂类Go语言编程语言
0 条评论