Golang日常开发常用的设计模式大全

启明闻道

已于 2023-07-08 11:46:05 修改

阅读量676

点赞数 2

文章标签： golang

于 2023-07-08 11:43:49 首次发布

本文链接：https://blog.csdn.net/qq_29337533/article/details/131610093

版权

包含Golang日常开发常用的设计模式：单例+工厂+门面+适配器+观察者+职责链及相关的设计模式，举一反三。

创建型设计模式

单例模式

定义：保证一个类仅有一个实例，并提供一个全局访问它的全局访问点。
例子：配置信息类、连接池类、ID生成器类。

// 使用结构体代替类
type Tool struct {
	Name string
}

// 锁对象
var lock sync.Mutex

// 建立私有变量
var instance *Tool

// 加锁保证线程安全
func GetInstance() *Tool {
	lock.Lock()
	defer lock.Unlock()
	if instance == nil {
		instance = &Tool{
			Name: "我已经初始化了",
		}
	}
	return instance
}

简单工厂模式（静态农场模式）

根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。
是工厂方法模式的特例。工厂类负责创建的对象比较少，客户只知道传入了工厂类的参数，对于始何创建对象（逻辑）不关心。

package main

import "fmt"

func main() {
	f := getFruit("apple")
	fmt.Println(f.Fruit())
}

type FruitFactory interface {
	Fruit() string
}

func getFruit(t string) FruitFactory {
	switch t {
	case "apple":
		return &apple{}
	case "banana":
		return &banana{}
	}

	return nil
}

type apple struct{}

func (*apple) Fruit() string {
	return "我是苹果，我很好吃"
}

type banana struct{}

func (*banana) Fruit() string {
	return "我是香蕉，我最好吃了"
}

工厂方法模式

定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。
将复杂的创建逻辑拆分到多个工厂类中，让每个工厂类都不至于过于复杂。

package main

import "fmt"

func main() {
	apple := appleFactory{}
	fmt.Println(apple.Fruit())

	banana := bananaFactory{}
	fmt.Println(banana.Fruit())
}

type Fruit interface {
	Fruit() string
}

type appleFactory struct{}

func (*appleFactory) Fruit() string {
	return "我是苹果，我很好吃"
}

type bananaFactory struct{}

func (*bananaFactory) Fruit() string {
	return "我是香蕉，我最好吃了"
}

抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类
当产品非常多的时候，产品之间关系又非常复杂，但却又可以进行抽象的时候，就是使用抽象工厂模式最好的时候了。

package main

import "fmt"

func main() {
	f := WuhanFruitFactory{}
	b := f.ChooseApple()
	b.Fruit()
}

type FruitInterface interface {
	ChooseApple() ProductInterface
	ChooseBanana() ProductInterface
}

type ProductInterface interface {
	Fruit()
}

type HainanApple struct {
}

func (h HainanApple) Fruit() {
	fmt.Println("我是苹果，来自海南")
}

type HainanBanana struct {
}

func (h HainanBanana) Fruit() {
	fmt.Println("我是香蕉，来自海南")
}

type WuhanApple struct {
}

func (w WuhanApple) Fruit() {
	fmt.Println("我是苹果，来自武汉")
}

type WuhanBanana struct {
}

func (w WuhanBanana) Fruit() {
	fmt.Println("我是香蕉，来自武汉")
}

type WuhanFruitFactory struct {
}

func (w WuhanFruitFactory) ChooseApple() ProductInterface {
	return WuhanApple{}
}

func (w WuhanFruitFactory) ChooseBanana() ProductInterface {
	return WuhanBanana{}
}

type HainanFruitFactory struct {
}

func (gd HainanFruitFactory) ChooseApple() ProductInterface {
	return HainanApple{}
}

func (gd HainanFruitFactory) ChooseBanana() ProductInterface {
	return HainanBanana{}
}