Go 抽象工厂模式讲解和代码示例-阿里云开发者社区

Go 抽象工厂模式讲解和代码示例

2023-09-19 38

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： Go 抽象工厂模式讲解和代码示例

抽象工厂是一种创建型设计模式，它能创建一系列相关的对象，而无需指定其具体类。

抽象工厂定义了用于创建不同产品的接口，但将实际的创建工作留给了具体工厂类。每个工厂类型都对应一个特定的产品变体。

在创建产品时，客户端代码调用的是工厂对象的构建方法，而不是直接调用构造函数（new操作符）。由于一个工厂对应一种产品变体，因此它创建的所有产品都可相互兼容。

客户端代码仅通过其抽象接口与工厂和产品进行交互。该接口允许同一客户端代码与不同产品进行交互。你只需创建一个具体工厂类并将其传递给客户端代码即可。

概念示例

让我们假设一下，如果你想要购买一组运动装备，比如一双鞋与一件衬衫这样由两种不同产品组合而成的套装。相信你会想去购买同一品牌的商品，这样商品之间能够互相搭配起来。

如果我们把这样的行为转换成代码的话，帮助我们创建此类产品组的工具就是抽象工厂，便于产品之间能够相互匹配。

iSportsFactory.go: 抽象工厂接口

package main
import "fmt"
type iSportsFactory interface {
    makeShoe() iShoe
    makeShirt() iShirt
}
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")
}
 adidas.go: 具体工厂
package main
type adidas struct {
}
func (a *adidas) makeShoe() iShoe {
    return &adidasShoe{
        shoe: shoe{
            logo: "adidas",
            size: 14,
        },
    }
}
func (a *adidas) makeShirt() iShirt {
    return &adidasShirt{
        shirt: shirt{
            logo: "adidas",
            size: 14,
        },
    }
}

nike.go: 具体工厂

package main
type nike struct {
}
func (n *nike) makeShoe() iShoe {
    return &nikeShoe{
        shoe: shoe{
            logo: "nike",
            size: 14,
        },
    }
}
func (n *nike) makeShirt() iShirt {
    return &nikeShirt{
        shirt: shirt{
            logo: "nike",
            size: 14,
        },
    }
}

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
}

adidasShoe.go: 具体产品

package main
type adidasShoe struct {
    shoe
}

nikeShoe.go: 具体产品

package main
type nikeShoe struct {
    shoe
}

iShirt.go: 抽象产品

package main
type iShirt interface {
    setLogo(logo string)
    setSize(size int)
    getLogo() string
    getSize() int
}

type shirt struct {
    logo string
    size int
}
func (s *shirt) setLogo(logo string) {
    s.logo = logo
}
func (s *shirt) getLogo() string {
    return s.logo
}
func (s *shirt) setSize(size int) {
    s.size = size
}
func (s *shirt) getSize() int {
    return s.size
}

adidasShirt.go: 具体产品

package main
type adidasShirt struct {
    shirt
}

nikeShirt.go: 具体产品

package main
type nikeShirt struct {
    shirt
}

main.go: 客户端代码

package main
import "fmt"
func main() {
    adidasFactory, _ := getSportsFactory("adidas")
    nikeFactory, _ := getSportsFactory("nike")
    nikeShoe := nikeFactory.makeShoe()
    nikeShirt := nikeFactory.makeShirt()
    adidasShoe := adidasFactory.makeShoe()
    adidasShirt := adidasFactory.makeShirt()
    printShoeDetails(nikeShoe)
    printShirtDetails(nikeShirt)
    printShoeDetails(adidasShoe)
    printShirtDetails(adidasShirt)
}
func printShoeDetails(s iShoe) {
    fmt.Printf("Logo: %s", s.getLogo())
    fmt.Println()
    fmt.Printf("Size: %d", s.getSize())
    fmt.Println()
}
func printShirtDetails(s iShirt) {
    fmt.Printf("Logo: %s", s.getLogo())
    fmt.Println()
    fmt.Printf("Size: %d", s.getSize())
    fmt.Println()
}

output.txt: 执行结果

Logo: nike
Size: 14
Logo: nike
Size: 14
Logo: adidas
Size: 14
Logo: adidas
Size: 14