GoLang设计模式03 - 抽象工厂模式

之前我们介绍了工厂设计模式,现在我们再看一下抽象工厂设计模式。抽象工程模式顾名思义就是对工厂模式的一层抽象,也是创建型模式的一种,通常用来创建一组存在相关性的对象。

UML类图大致如下:

类图比较复杂,最好用个例子来说明。比方说,国内有两家生产运动服的工厂:nike和adidas 。现在我们想购买一套运动服,包含短裤(short)和运动鞋(shoe)。通常我们都会在同一家工厂购买整套的运动服。这时抽象工厂模式就可以发挥作用了。

现在我们需要的产品有两种:短裤(short)和运动鞋(shoe)。

生产这些产品的工厂有两家:nike和adidas。

nike和adidas都是运动服厂商,可以视为是 iSportsFactory接口的实现

然后,我们还要为具体的产品定义两个接口:

  • iShort,它有两个实现,分别是nikeShortadidasShort
  • iShoe,它也有两个实现,分别是nikeShoeadidasShoe

看下具体的代码:

iSportsFactory.go

package main

import "fmt"

type iSportsFactory interface {
	makeShoe() iShoe
	makeShort() iShort
}

func getSportsFactory(brand string) (iSportsFactory,error) {
	if brand == "adidas" {
		return &adidas{},nil
	}
	if brand == "nike" {
		return &nike{},nil
	}
	return nil,fmt.Errorf("Wrong brand type passed")
}

  iShort.go

package main

type iShort interface {
	setLogo(logo string)
	setSize(size int)
	getLogo() string
	getSize() int
}

type short struct {
	logo string
	size int
}

func (s *short) setLogo(logo string) {
	s.logo = logo
}

func (s *short) getLogo() string {
	return s.logo
}

func (s *short) setSize(size int) {
	s.size = size
}

func (s *short) getSize() int {
	return s.size
}

  iShoe.go

package main

type iShoe interface {
	setLogo(logo string)
	setSize(size int)
	getLogo() string
	getSize() int
}

type shoe struct {
	logo string
	size int
}

func (s *shoe) setLogo(logo string) {
	s.logo = logo
}

func (s *shoe) getLogo() string {
	return s.logo
}

func (s *shoe) setSize(size int) {
	s.size = size
}

func (s *shoe) getSize() int {
	return s.size
}

  nike.go

package main

type nike struct {
}

type nikeShoe struct {
	shoe
}

type nikeShort struct {
	short
}

func (n *nike) makeShoe() iShoe {
	return &nikeShoe{
		shoe: shoe{
			logo: "nike",size: 14,},}
}

func (n *nike) makeShort() iShort {
	return &nikeShort{
		short: short{
			logo: "nike",}
}

  adidas.go

package main

type adidas struct {
}

type adidasShoe struct {
	shoe
}

type adidasShort struct {
	short
}

func (a *adidas) makeShoe() iShoe {
	return &adidasShoe{
		shoe: shoe{
			logo: "adidas",}
}

func (a *adidas) makeShort() iShort {
	return &adidasShort{
		short: short{
			logo: "adidas",}
}

  main.go

package main

import "fmt"

func main() {
	adidasFactory,_ := getSportsFactory("adidas")
	nikeFactory,_ := getSportsFactory("nike")
	nikeShoe := nikeFactory.makeShoe()
	nikeShort := nikeFactory.makeShort()
	adidasShoe := adidasFactory.makeShoe()
	adidasShort := adidasFactory.makeShort()
	printShoeDetails(nikeShoe)
	printShortDetails(nikeShort)
	printShoeDetails(adidasShoe)
	printShortDetails(adidasShort)
}

func printShoeDetails(s iShoe) {
	fmt.Printf("Logo: %s",s.getLogo())
	fmt.Println()
	fmt.Printf("Size: %d",s.getSize())
	fmt.Println()
}

func printShortDetails(s iShort) {
	fmt.Printf("Logo: %s",s.getSize())
	fmt.Println()
}

 代码已上传至GitHub:zhyea / go-patterns / abstract-factory-pattern

End!

相关文章

Golang的文档和社区资源:为什么它可以帮助开发人员快速上手...
Golang:AI 开发者的实用工具
Golang的标准库:为什么它可以大幅度提高开发效率?
Golang的部署和运维:如何将应用程序部署到生产环境中?
高性能AI开发:Golang的优势所在
本篇文章和大家了解一下go语言开发优雅得关闭协程的方法。有...