Go常用设计模式简记-行为型模式

package main

import "fmt"

// 

type Seller interface {
	sell(name string)
}

// 火车站
type Station struct {
	stock int // 库存
}

func (s *Station) sell(name string)  {
	if s.stock>0 {
		s.stock--
		fmt.Printf("火车站中：%s买了一张票，余票：%d\n",name,s.stock)
	} else {
		fmt.Println("票已售空")
	}
}

// 火车代理点
type StationProxy struct {
	station *Station // 持有一个火车站对象
}

func (prox *StationProxy) sell(name string) {
	if prox.station.stock >0 {
		 prox.station.stock--
		 fmt.Printf("代理点中：%s买了一张票，余票：%d\n",name, prox.station.stock)
	} else {
		fmt.Println("票已售空")
	}
}

func main()  {
	s :=&Station{
		stock: 10,
	}
	s.sell("张三")
	fmt.Println("Other>>>>>")
	prox := &StationProxy{s}
	prox.sell("李四")
}

package main

import "time" 
const (
	defaultTimeout = 10
	defaultCaching = false
)

type Connection struct {
	addr string
	cache bool
	timeout time.Duration
}

func NewConnect(add string)(*Connection,error) {
	return &Connection{
		addr: add,
		cache: defaultCaching,
		timeout: defaultTimeout,
	},nil
}

func NewConnectWithOpt(add string,cache bool, timeout time.Duration)(*Connection,error) {
	return &Connection{
		addr: add,
		cache: cache,
		timeout: timeout,
	},nil
}

package main

import "time"


const (
	defaultTimeoutb = 10
	defaultCachingb = false
)

type Connectionb struct {
	addr string
	cache bool
	timeout time.Duration
}


type ConnectionOptions struct {
	Caching bool
	Timeout time.Duration
}

func NewDefaultOptions() *ConnectionOptions  {
	return &ConnectionOptions{
		Caching: defaultCachingb,
		Timeout: defaultTimeoutb,
	}
}

func NewConnectWithOps(addr string,opts *ConnectionOptions) (*Connectionb,error)  {
	return &Connectionb{
		addr: addr,
		cache: opts.Caching,
		timeout: opts.Timeout,
	},nil
}

package main

import (
	"fmt"
	"time"
)
//  默认值
const (
	defaultTimeoutc = 10
	defaultCachingc = false
)
// Connection 结构体，实际需要创建的对象
type Connectionc struct {
	addr string
	cache bool
	timeout time.Duration
}

// options 选项结构体，用于保存变量值
type options struct {
	caching bool
	timeout time.Duration
}

type Option interface {
	apply(*options)
}
// 定义配置选项函数（关键）
type optionFunc func(*options)
// Option 类型的选项参数需要实现apply(*options)函数
func (f optionFunc) apply(o *options)  {
	f(o)
}
// 通过 WithXXX 方法来创建 Option 类型的选项参数
func WithTimeout(t time.Duration) Option {
	return optionFunc(func(o *options) {
		o.timeout = t
	})
}

func WithCaching(cache bool) Option {
	return optionFunc(func(o *options) {
		o.caching = cache
	})
}
// 创建 Connect 对象
func NewConnectc(addr string,opts ...Option)(*Connectionc,error)  {
	// 默认值的options
	options := options{
		timeout: defaultTimeoutc,
		caching: defaultCachingc,
	}
	// 修改属性值
	for _,o := range opts{
		// o.apply(&options)其实就是通过闭包把 WithTimeout、WithCaching 传入的参数赋值给 options 结构体变量，以此动态地设置 options 结构体变量的属性
		o.apply(&options)
	}
	return &Connectionc{
		addr: addr,
		cache: options.caching,
		timeout: options.timeout,
	},nil
}

func main()  {
	connection,_ :=NewConnectc(
		"https://twst",
		WithCaching(true),
	)
	fmt.Println("Connection fild: ", connection)
}