Golang on ttz.pw

Go读取通达信历史日线数据

Mon, 03 Jun 2024 14:08:28 +0800

突然间想使用Go从通达信读取A股历史行情信息，其实也蛮简单的。从通达信获取数据难点在于分析数据结构，而读取则各类语言分分钟搞定。

1. 准备工作

下载安装通达信,通达信官网下载历史行情数据下载操作路径：系统->盘后数据下载

下载后数据按股票市场分别存放：

1上海交易所：{通达信安装目录}\vipdoc\sh\lday\*.day
2深圳交易所：{通达信安装目录}\vipdoc\sz\lday\*.day

2. 通达信历史日线数据文件格式

每只股票一个day文件，如：sh000001.day。文件中每一天数据总共32字节。其中每32字节数据格式如下：

数据含义	数据类型	数据长度	举例	单位
日期	Integer	4	20170703
开盘价	Integer	4	2476	当前值/100,元
最高价	Integer	4	2520	当前值 /100,元
最低价	Integer	4	2436	当前值 / 100,元
收盘价	Integer	4	2457	当前值 / 100,元
成交金额	single	4	1317335898	元
成交量	Integer	4	45293799	股
保留	Integer	4

注意，因为价格均是两位小数，故文件中的价格放大100倍，以便按数字存储。

3. Go读取日线数据文件

文件每32字节存储一天数据，在Go中只需读取指定长度的字节，再转换为int即可。

第一步：读取文件以万科股票为例，打开该day文件，获得 reader。

1f, err := os.Open(`D:\new_tdx\vipdoc\sz\lday\sz000002.day`)
2if err != nil {
3	log.Fatal(err)
4}
5defer f.Close()

第二步：获取32字节数据

从文件流中填充32个字节的数据到oneDay中，如果无错误则可以按照数据格式读取单独一天的日行情数据。

注意取价格时需再除以100，已显示正确的金额。

 1oneDay := make([]byte, 32)
 2_, err = f.Read(oneDay)
 3if err != nil {
 4	log.Fatal(err)
 5}
 6fmt.Println("日期:\t", binary.LittleEndian.Uint32(oneDay[0:4]))
 7fmt.Println("开盘价(元):\t", (float64)(binary.LittleEndian.Uint32(oneDay[4:8]))/100)
 8fmt.Println("最高价(元):\t", (float64)(binary.LittleEndian.Uint32(oneDay[8:12]))/100)
 9fmt.Println("最低价(元):\t", (float64)(binary.LittleEndian.Uint32(oneDay[12:16]))/100)
10fmt.Println("收盘价(元):\t", (float64)(binary.LittleEndian.Uint32(oneDay[16:20]))/100)
11fmt.Println("成交金额(元):\t", (float64)(binary.LittleEndian.Uint32(oneDay[20:24]))/100)
12fmt.Println("成交量:\t", binary.LittleEndian.Uint32(oneDay[24:28]))
13fmt.Println("Other:\t", binary.LittleEndian.Uint32(oneDay[28:32]))
14//output:
15/*
16日期:    20170703
17开盘价(元):      24.76
18最高价(元):      25.2
19最低价(元):      24.36
20收盘价(元):      24.57
21成交金额(元):    1.317335898e+07
22成交量:  45293799
23Other:   65536
24*/

第三步：遍历获取所有日线数据

 1oneDay := make([]byte, 32)
 2for {
 3	l, err := f.Read(oneDay)
 4	if err == io.EOF {
 5		break
 6	} else if err != nil {
 7		log.Fatal(err)
 8	} else if l != 32 {
 9		log.Fatal("数据不完整，终止")
10	}
11    //Date
12	fmt.Printf("%d,", binary.LittleEndian.Uint32(oneDay[0:4]))
13	//other
14}

历史数据可在其他网站上查看，下图来自搜狐数据

完整代码：

 1package main
 2import (
 3	"bytes"
 4	"encoding/binary"
 5	"fmt"
 6	"io"
 7	"log"
 8	"os" 
 9)
10func main() {
11	f, err := os.Open(`D:\new_tdx\vipdoc\sz\lday\sz000002.day`)
12	if err != nil {
13		log.Fatal(err)
14	}
15	defer f.Close()
16	oneDay := make([]byte, 32)
17	fmt.Println("日期\t\t开盘价(元)\t最高价(元)\t最低价(元)\t收盘价(元)\t成交金额(元)\t成交量\tOther")
18	for {
19		l, err := f.Read(oneDay)
20		if err == io.EOF {
21			break
22		} else if err != nil {
23			log.Fatal(err)
24		} else if l != 32 {
25			log.Fatal("数据不完整，终止")
26		}
27		fmt.Printf("%d\t%f\t%f\t%f\t%f\t%f\t%d\t%d\t\n",
28			binary.LittleEndian.Uint32(oneDay[0:4]),
29			(float64)(binary.LittleEndian.Uint32(oneDay[4:8]))/100,
30			(float64)(binary.LittleEndian.Uint32(oneDay[8:12]))/100,
31			(float64)(binary.LittleEndian.Uint32(oneDay[12:16]))/100,
32			(float64)(binary.LittleEndian.Uint32(oneDay[16:20]))/100,
33			(float64)(binary.LittleEndian.Uint32(oneDay[20:24]))/100,
34			binary.LittleEndian.Uint32(oneDay[24:28]),
35			binary.LittleEndian.Uint32(oneDay[28:32]),
36		)
37	}
38}

4. 进价

有没有更好的办法来进行数据转换？如下格式处理，过于麻烦，幸好该格式数据不多。但容易弄错，或者调整麻烦。

1fmt.Println("日期:\t", binary.LittleEndian.Uint32(oneDay[0:4]))
2fmt.Println("开盘价(元):\t", (float64)(binary.LittleEndian.Uint32(oneDay[4:8]))/100)
3fmt.Println("最高价(元):\t", (float64)(binary.LittleEndian.Uint32(oneDay[8:12]))/100)
4fmt.Println("最低价(元):\t", (float64)(binary.LittleEndian.Uint32(oneDay[12:16]))/100)
5fmt.Println("收盘价(元):\t", (float64)(binary.LittleEndian.Uint32(oneDay[16:20]))/100)
6fmt.Println("成交金额(元):\t", (float64)(binary.LittleEndian.Uint32(oneDay[20:24]))/100)
7fmt.Println("成交量:\t", binary.LittleEndian.Uint32(oneDay[24:28]))
8fmt.Println("Other:\t", binary.LittleEndian.Uint32(oneDay[28:32])) `

可以利用Go的encoding/binary包从reader中读取二元数据到指针对象中:

 1// Read reads structured binary data from r into data.
 2// Data must be a pointer to a fixed-size value or a slice
 3// of fixed-size values.
 4// Bytes read from r are decoded using the specified byte order
 5// and written to successive fields of the data.
 6// When decoding boolean values, a zero byte is decoded as false, and
 7// any other non-zero byte is decoded as true.
 8// When reading into structs, the field data for fields with
 9// blank (_) field names is skipped; i.e., blank field names
10// may be used for padding.
11// When reading into a struct, all non-blank fields must be exported.
12//
13// The error is EOF only if no bytes were read.
14// If an EOF happens after reading some but not all the bytes,
15// Read returns ErrUnexpectedEOF.
16func binary.Read(r io.Reader, order ByteOrder, data interface{}) error{}

这样便可以方便的将byte读取到对象中，下面我们定义data结构：

 1type DayData struct {
 2	Date                   int32
 3	Open, High, Low, Close int32
 4	Amount, Qty            int32
 5	Other                  int32
 6}
 7var d DataData
 8buf := bytes.NewBuffer(oneDay)
 9binary.Read(buf, binary.LittleEndian, &d)
10fmt.Printf("%v\n", d)

注意，在binary读取buf到对象时，是依次遍历对象的内存结构赋值的，因为文件中各数据均是4位长度。故在定义字段类型时，选择int32,占4个字节。字段定义顺序便是内存结构顺序，同文件数据定义顺序保持一致。

但因为数据中均存放的是int32，而收盘价等需要进行转换，故对外时提供另一个结构体，已方便正常访问各数据。在解析时，进行一次解析即可。

 1//DayQuotaion 日线行情
 2type DayQuotaion struct {
 3	Marker    string  //股票市场
 4	StockCode string  //股票代码
 5	Date      int     //日期
 6	Open      float32 //开盘价
 7	High      float32 //最高价
 8	Low       float32 //最低价
 9	Close     float32 //收盘价
10	Amount    float32 //总成交金额
11	Qty       float32 //  总成交量
12}

5. 完整代码

 1package main
 2import (
 3	"bytes"
 4	"encoding/binary"
 5	"errors"
 6	"fmt"
 7	"io"
 8	"log"
 9	"os"
10	"path/filepath"
11	"strings"
12)
13const historyDailyQuotationPath = `D:\new_tdx\vipdoc`
14type dayData struct {
15	Date                   int32
16	Open, High, Low, Close int32
17	Amount, Qty            int32
18	Other                  int32
19}
20// To 转换为日线行情数据
21func (d *dayData) To() *DayQuotation {
22	return &DayQuotation{
23		Date:   d.Date,
24		Open:   float32(d.Open) / 100,
25		High:   float32(d.High) / 100,
26		Low:    float32(d.Low) / 100,
27		Close:  float32(d.Close) / 100,
28		Amount: float32(d.Amount),
29		Qty:    d.Qty,
30	}
31}
32// DayQuotation 日线行情
33type DayQuotation struct {
34	Date   int32   //日期
35	Open   float32 //开盘价
36	High   float32 //最高价
37	Low    float32 //最低价
38	Close  float32 //收盘价
39	Amount float32 //总成交金额
40	Qty    int32   //  总成交量
41}
42//GetStockQuoation 获取股票历史行情
43func GetStockQuoation(marker, stockCode string) ([]*DayQuotation, error) {
44	marker = strings.ToLower(strings.TrimSpace(marker))
45	stockCode = strings.ToLower(strings.TrimSpace(stockCode))
46	if marker == "" || stockCode == "" {
47		return nil, errors.New("marker和stockCode不能为空")
48	}
49	//文件路径，e.g. D:\new_tdx\vipdoc\sz\lday\sz000002.day
50	name := filepath.Join(historyDailyQuotationPath, marker, "lday", fmt.Sprintf("%s%s.day", marker, stockCode))
51	f, err := os.Open(name)
52	if err != nil {
53		return nil, err
54	}
55	defer f.Close()
56	quos := []*DayQuotation{}
57	oneDay := make([]byte, 32)
58	data := &dayData{}
59	for {
60		l, err := f.Read(oneDay)
61		if err == io.EOF {
62			break
63		} else if err != nil {
64			return quos, err
65		} else if l != 32 {
66			return quos, errors.New("数据不完整")
67		}
68		buf := bytes.NewBuffer(oneDay)
69		err = binary.Read(buf, binary.LittleEndian, data)
70		if err != nil {
71			return quos, err
72		}
73		quos = append(quos, data.To())
74	}
75	return quos, nil
76}
77func main() {
78	quos, err := GetStockQuoation("sz", "000002")
79	if err != nil {
80		log.Fatal(err)
81	}
82	for _, v := range quos {
83		fmt.Printf("%v\n", v)
84	}
85}

Golang常用库之UUID

Wed, 21 Feb 2024 14:24:16 +0800

1. 什么是UUID？

通用唯一标识符 (UUID) 是一种特定形式的标识符，在大多数实际用途中可以安全地认为是唯一的。两个正确生成的 UUID 相同的可能性几乎可以忽略不计，即使它们是由不同的各方在两个不同的环境中创建的。这就是为什么说 UUID 是普遍唯一的。

UUID 是唯一的(出于实用目的)：它重复的概率非常接近零。
UUID 不依赖中央机构的注册和分配。

UUID 的字符串表示形式由 32 个十六进制数字组成，以 5 个组显示，由连字符 - 分隔。例如：123e4567-e89b-12d3-a456-426655440000

UUID 的生成有两种

第一种是根据Rand 随机数来生成UUID
第二种是直接调用UUID库

但其实第二种的底层源码中也是调用了Rand库来实现的可以理解成不是单一的随机数封装

2. 根据Rand 随机数来生成UUID

 1// blog: https://www.cnblogs.com/zichliang
 2package main
 3 
 4import (
 5	"crypto/rand"
 6	"fmt"
 7	"log"
 8)
 9 
10func getUUID() (uuid string) {
11	b := make([]byte, 16)
12	fmt.Println(b)
13	_, err := rand.Read(b)
14	if err != nil {
15		log.Fatal(err)
16	}
17	uuid = fmt.Sprintf("%x-%x-%x-%x-%x",
18		b[0:4], b[4:6], b[6:8], b[8:10], b[10:])
19	return
20}
21 
22func main() {
23	uuid := getUUID()
24	fmt.Println(uuid)
25}

3. 调用UUID 库

安装UUID库

1go get -u github.com/satori/go.uuid

3.1. UUID 库基本上分为六种分别是v1 v2，v3，v4,v5,v6

3.1.1. uuid.NewV1

返回基于当前时间戳和MAC地址的UUID。

1u1 := uuid.NewV1()
2fmt.Println("u1 >>>", u1)

3.1.2. uuid.NewV2

返回基于POSIX UID/GID的DCE安全UUID。

1u2 := uuid.NewV2(0)
2fmt.Println("u2 >>>", u2)

3.1.3. uuid.NewV3

返回基于命名空间UUID和名称的MD5哈希的UUID。

1u3 := uuid.NewV3(u2, "abc")
2fmt.Println("u3 >>>", u3)

3.1.4. uuid.NewV4

返回随机生成的UUID。

1u4 := uuid.NewV4()
2fmt.Println("u4 >>>", u4)

3.1.5. uuid.NewV5

返回基于命名空间UUID和名称的SHA-1哈希的UUID。

1u5 := uuid.NewV5(u2, "abc")
2fmt.Println("u5 >>>", u5)

3.1.6. uuid.NewV6

本质上没有差距不过更新版本之前某些方法是有两个返回值的，Must是基于前者进行的一个包装

1u6 := uuid.Must(u5, nil)
2fmt.Println("u6 >>>", u6)

有时候我们需要把一个 uuid的字符串转成UUID可以用到以下方法

1s := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
2uuidObject, err := uuid.FromString(s)
3if err != nil {
4  log.Fatalf("failed to parse UUID %q: %v", s, err)
5}
6fmt.Println("successfully parsed UUID Version", uuidObject)

4. 完整代码

 1// blog: https://www.cnblogs.com/zichliang
 2package main
 3 
 4import (
 5	"fmt"
 6	uuid "github.com/satori/go.uuid"
 7)
 8 
 9func main() {
10 
11	//返回基于当前时间戳和MAC地址的UUID。
12	u1 := uuid.NewV1()
13	fmt.Println("u1 >>>", u1)
14 
15	//返回基于POSIX UID/GID的DCE安全UUID。
16	u2 := uuid.NewV2(0)
17	fmt.Println("u2 >>>", u2)
18 
19	//返回基于命名空间UUID和名称的MD5哈希的UUID。
20	u3 := uuid.NewV3(u2, "abc")
21	fmt.Println("u3 >>>", u3)
22 
23	//返回随机生成的UUID。
24	u4 := uuid.NewV4()
25	fmt.Println("u4 >>>", u4)
26 
27	//返回基于命名空间UUID和名称的SHA-1哈希的UUID。
28	u5 := uuid.NewV5(u2, "abc")
29	fmt.Println("u5 >>>", u5)
30 
31	//本质上  没有差距 不过更新版本之前 某些方法 是有两个返回值的，Must是基于前者 进行的一个包装
32	u6 := uuid.Must(u5, nil)
33	fmt.Println("u6 >>>", u6)
34 
35	//如果 u5 和 u6 相等，则返回true，否则返回false。
36	u7 := uuid.Equal(u5, u6)
37	fmt.Println("u7 >>>", u7)
38 
39	// 将字符串转换成UUID
40	s := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
41	uuidObject, err := uuid.FromString(s)
42	if err != nil {
43		log.Fatalf("failed to parse UUID %q: %v", s, err)
44	}
45	fmt.Println("successfully parsed UUID Version", uuidObject)
46}

通过实例理解Web应用用户密码存储方案

Wed, 21 Feb 2024 11:18:07 +0800

1. Web应用用户密码存储的重要性

用户密码是访问Web应用的关键，它直接关乎到用户账号和应用数据的安全。

如果用户密码被泄露或破解，将导致严重后果。后果最轻的算是某个用户或某少数用户的账号被盗用了，用户将失去对账号的控制。盗用账号后，攻击者可以获取该用户的私密信息，或进行额外的攻击；如果用户在多个应用重复使用同一密码，那么后果将进一步严重，用户的一系列账号都将受到安全威胁；更为严重的是Web应用存储用户账号信息的数据库被攻破(俗称“脱库”)，攻击者会拿到存储的全部用户账号信息等，如果用户密码存储不当，攻击者可以很容易破译所有用户的密码，并基于这些密码信息做进一步的攻击。

由此可见，Web应用必须非常重视用户密码的存储安全。在当前弱密码和频繁密码泄露成为常态的背景下，Web应用开发者有责任使用安全的密码存储方案，尽力保护用户信息安全，即便在被脱库的最糟糕情况下，也不让攻击者轻易破解出用户的密码，这也关系到应用和企业的信誉。

2. 密码存储方案的演进：魔高一尺，道高一丈

Web应用用户密码存储方案的演进历史可以分为以下几个阶段，如图所示：

下面我们按图中的演进顺序，对各阶段的密码存储方案逐一说明一下。

2.1. 起始阶段 – 明文存储

早期的Web应用为了实现简单，采用了最简单“粗暴”的用户密码存储方式：明文存储，即直接把用户的密码以纯文本形式存储在数据库中。

显然这种方式的最大优点就是实现简单，验证登录时直接比对明文密码。但这种方式最大的缺点就是极其不安全，密码一旦泄露就失去了全部保密性。但当时人们的安全意识较弱，该方案被广泛使用。

2.2. 弱哈希算法阶段 – MD5和SHA1

随着时间的推移，CPU和GPU性能的提升使得字典破解和穷举攻击更加可行有效，大量密码被泄露的事件引起人们对密码安全的重视，人们更多地认识到明文存储密码的危险性。同时，Web应用的发展也从追求功能和便利，转变为在易用性与安全性之间求平衡。政府和行业协会也开始指定密码存储的最新安全要求的规范和政策，密码学等相关技术的快速发展也为更安全的密码存储提供了前提和支持。

于是人们开始使用MD5、SHA1等单向哈希算法对密码进行处理，只存储密码的哈希值。虽然增加了一定的密码存储的复杂性，但其最大的优点就是在一定程度上放置了明文存储的密码泄露问题。

不过，随着大量使用MD5和SHA-1的应用遭到破解，这些哈希算法的脆弱性暴露无遗。同时彩虹表攻击的出现，让破解者只需要预计算密码哈希表就可以快速破解以弱哈希存储的密码。

于是技术社区以及安全规范都开始提倡和推荐采用更安全的密码存储方案，即采用加盐方案。

2.3. 加盐哈希阶段 – 增加随机盐值

加盐哈希就是在计算密码的哈希值时，在密码字符串前/后面添加一个称为“盐(salt)”的随机字符串，这个随机字符串称为盐值，它的作用是增加哈希后密码的随机性。

加盐哈希的步骤大致如下图：

在用户注册阶段，系统根据用户输入的密码生成在数据库中的哈希密码值：

系统首先随机生成一个足够长的随机字符串作为盐值，可以使用密码学安全的随机数生成算法；
将盐值与用户输入的原始密码字符串拼接在一起(盐值放在密码的前后均可)；
对连接后的字符串计算哈希值，可以使用MD5、SHA-1、SHA256、SHA-512等哈希算法；由于也被证实MD5、SHA-1存在弱点，可以被碰撞攻击，建议至少使用SHA256算法；
将盐值和哈希值一起存储在数据库中(可以向图中那样将hashed_password和salt通过:分隔符组合为一个字段后再存储在数据库中)。

验证登录时，系统根据用户名取出盐值，然后将用户输入的密码与盐值组合计算哈希值，与存储的原始哈希值比较，相同则验证成功。

在密码哈希前加入随机字符串(即“盐(salt)”)可以大幅增加了破解难度，同时不同用户如采用相同密码，也可以通过不同的盐在哈希后得到不同的哈希值，这可以有效地防止预计算表的攻击。

不过随着硬件算力的飞速提高，比如GPU、专用ASIC芯片以及云计算资源等，密码破解效率进一步提高，甚至普通人也可利用现成的破解工具和云资源进行密码破解，攻击者门槛大幅降低，简单加盐也已出现不能有效对抗硬件加速破解的情况。

于是人们开始考虑使用一些新哈希算法，这些算法可以大幅提高攻击者付出的时间和资源消耗成本，增加密码破解难度，这就是下面我们要说的慢哈希算法。

2.4. 慢哈希算法阶段 – Argon2、Bcrypt、Scrypt和PBKDF2

Argon2、Bcrypt、Scrypt和PBKDF2是目前主流的慢哈希算法，它们与SHA256等快速哈希算法的主要差异点如下:

计算速度更慢，需要消耗更多CPU和内存资源，从而对抗硬件加速攻击；
使用更复杂的算法，组合密码学原语，增加破解难度；
可以配置资源消耗参数，调整安全强度；
特定优化使并行计算困难；
经过长时间的密码学分析，仍然安全可靠。

从这些特点可以知道：这些慢哈希算法更适合密码哈希的原因是可以大幅增加攻击者密码破解的成本，如果这么说大家印象还不够深刻，我们就来量化对比一下，下面是以SHA256和Scrypt两个算法为例做的一个简单的benchmark测试：

 1// web-app-password-storage/benchmark/benchmark_test.go
 2
 3package main
 4
 5import (
 6    "crypto/sha256"
 7    "testing"
 8
 9    "golang.org/x/crypto/scrypt"
10)
11
12func BenchmarkSHA256(b *testing.B) {
13    b.ReportAllocs()
14    data := []byte("hello world")
15    b.ResetTimer()
16
17    for i := 0; i < b.N; i++ {
18        sha256.Sum256(data)
19    }
20}
21
22func BenchmarkScrypt(b *testing.B) {
23    b.ReportAllocs()
24    const keyLen = 32
25    data := []byte("hello world")
26    b.ResetTimer()
27
28    for i := 0; i < b.N; i++ {
29        scrypt.Key(data, data, 16384, 8, 1, keyLen)
30    }
31}

我们看看输出的benchmark结果是什么样的：

1$go test -bench .
2goos: darwin
3goarch: amd64
4pkg: demo
5... ...
6BenchmarkSHA256-8        6097324           195.3 ns/op         0 B/op          0 allocs/op
7BenchmarkScrypt-8             26      41812138 ns/op    16781836 B/op         22 allocs/op
8PASS
9ok      demo    2.533s

我们看到无论是cpu消耗还是内存开销，Scrypt算法都是SHA256的几个数量级的倍数。

加盐的慢哈希也是目前的主流的用户密码存储方案，那有读者会问：这四个算法选择哪个更佳呢？说实话要想对这个四个算法做个全面的对比，需要很强的密码学专业知识，这里直接给结论(当然也是来自网络资料)：建议使用Scrypt或Argon2系列的算法，它们俩可提供更高的抗ASIC和并行计算能力，Bcrypt由于简单高效和成熟，目前也仍十分流行。

不过，慢哈希算法在给攻击者带来时间和资源成本等困难的同时，也给服务端正常的身份认证带来一定的性能开销，不过大多数开发者认为这种设计取舍是值得的。

下面我们就基于慢哈希算法结合加盐，用实例说明一下一个Web应用的用户注册与登录过程中，密码是如何被存储和用来验证用户身份的。

3. 加盐哈希存储方案的示例

在这个示例中，我们建立两个html文件：一个是signup.html，用于模拟用户注册；一个是login.html，用于模拟用户登录：

 1// web-app-password-storage/signup.html
 2
 3<!DOCTYPE html>
 4<html>
 5<head>
 6  <title>注册</title>
 7</head>
 8<body>
 9
10<form action="http://localhost:8080/signup" method="post">
11
12  <label>用户名:</label>
13  <input type="text" name="username"/>
14
15  <label>密码:</label>
16  <input type="password" name="password"/>
17
18  <label>确认密码:</label>
19  <input type="password" name="confirm-password"/>
20
21  <button type="submit">注册</button>
22
23</form>
24
25</body>
26</html>
27
28// web-app-password-storage/login.html
29
30<!DOCTYPE html>
31<html>
32<head>
33  <title>登录</title>
34</head>
35<body>
36
37<form action="http://localhost:8080/login" method="post">
38
39  <label>用户名:</label>
40  <input type="text" name="username"/>
41
42  <label>密码:</label>
43  <input type="password" name="password"/>
44
45  <button type="submit">登录</button>
46
47</form>
48
49</body>
50</html>

接下来，我们来写这个web应用的后端：一个http server：

  1// web-app-password-storage/server/main.go
  2
  3package main
  4
  5import (
  6    "database/sql"
  7    "encoding/base64"
  8    "math/rand"
  9    "net/http"
 10    "strings"
 11    "time"
 12
 13    "golang.org/x/crypto/scrypt"
 14    _ "modernc.org/sqlite"
 15)
 16
 17var db *sql.DB
 18
 19func main() {
 20    // 连接SQLite数据库
 21    var err error
 22    db, err = sql.Open("sqlite", "./users.db")
 23    if err != nil {
 24        panic(err)
 25    }
 26    defer db.Close()
 27
 28    // 创建用户表
 29    sqltable := `
 30        CREATE TABLE IF NOT EXISTS users (
 31            id INTEGER PRIMARY KEY AUTOINCREMENT,
 32            username TEXT,
 33            hashedpass TEXT
 34        );
 35    `
 36    _, err = db.Exec(sqltable)
 37    if err != nil {
 38        panic(err)
 39    }
 40
 41    http.HandleFunc("/login", login)
 42    http.HandleFunc("/signup", signup)
 43    http.ListenAndServe(":8080", nil)
 44}
 45
 46func signup(w http.ResponseWriter, r *http.Request) {
 47    username := r.FormValue("username")
 48    password := r.FormValue("password")
 49    cpassword := r.FormValue("confirm-password")
 50
 51    if password != cpassword {
 52        http.Error(w, "password and confirmation password do not match", http.StatusBadRequest)
 53        return
 54    }
 55
 56    // 注册新用户
 57    salt := generateSalt(16)
 58    hashedPassword := hashPassword(password, salt)
 59    stmt, err := db.Prepare("INSERT INTO users(username, hashedpass) values(?, ?)")
 60    if err != nil {
 61        panic(err)
 62    }
 63    _, err = stmt.Exec(username, hashedPassword+":"+salt)
 64    if err != nil {
 65        panic(err)
 66    }
 67    w.Write([]byte("signup ok!"))
 68}
 69
 70func login(w http.ResponseWriter, r *http.Request) {
 71    username := r.FormValue("username")
 72    password := r.FormValue("password")
 73
 74    // 验证登录
 75    storedHashedPassword, salt := getHashedPasswordForUser(db, username)
 76    hashedLoginPassword := hashPassword(password, salt)
 77    if hashedLoginPassword == storedHashedPassword {
 78        w.Write([]byte("Welcome!"))
 79    } else {
 80        http.Error(w, "Invalid username or password", http.StatusUnauthorized) // 401
 81    }
 82}
 83
 84// 生成随机字符串作为盐值
 85func generateSalt(n int) string {
 86    rand.Seed(time.Now().UnixNano())
 87    letters := []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
 88    b := make([]rune, n)
 89    for i := range b {
 90        b[i] = letters[rand.Intn(len(letters))]
 91    }
 92    return string(b)
 93}
 94
 95// 对密码进行bcrypt哈希并返回哈希值与随机盐值
 96func hashPassword(password, salt string) string {
 97    dk, err := scrypt.Key([]byte(password), []byte(salt), 1<<15, 8, 1, 32)
 98    if err != nil {
 99        panic(err)
100    }
101    return base64.StdEncoding.EncodeToString(dk)
102}
103
104// 从数据库获取用户哈希后的密码和盐值
105func getHashedPasswordForUser(db *sql.DB, username string) (string, string) {
106    var hashedPass string
107    row := db.QueryRow("SELECT hashedpass FROM users WHERE username=?", username)
108    if err := row.Scan(&hashedPass); err != nil {
109        panic(err)
110    }
111    split := strings.Split(hashedPass, ":")
112    return split[0], split[1]
113}

示例的结构比较清晰，这里提供了两个http handler，一个是signup用于接收用户注册请求，一个是login，用于接收处理用户登录请求。在注册请求时，我们生成用户密码的带盐慢哈希值，与salt一起存入数据库，这里用sqlite代替通用关系型数据库；在login handler中，我们根据username读取数据库中的salt和hashed_password，然后基于请求中的password与salt重新做一遍hash，将得到的结果与数据库中读取的hashed_password比较，相同则说明用户输入的密码正确。

Go官方维护的golang.org/x/crypto为我们提供了高质量的scrypt包，当然crypto下也有bcrypt、argon2和pbkdf2的实现，感兴趣的童鞋可以自行研究。

4. 小结

用户密码的安全存储是保障Web应用与用户数据安全的基石。简单的密码存储实践如明文和弱哈希算法存在巨大隐患，而随着计算能力提升，任何weak password都可被轻松破解。为有效保护用户，Web应用必须采取更可靠的密码存储方案。

本文详细介绍了从简单明文、单向哈希到先进的加盐慢哈希的演进历程。我们看到，这是一场与不断增强的攻击手段进行的应对之争。随着硬件计算能力、并行与云计算等技术进步，必须加强密码存储机制的强度。当前，结合随机盐、迭代计算的慢哈希可大幅提高破解难度，是推荐的密码存储安全实践。

当然，密码安全需要持续关注新兴攻击手段，并及时采纳更强大的算法。这不仅是技术问题，也需要整个社区的共同努力，通过提高意识和最佳实践来保护用户。

本文示例所涉及的Go源码可以在这里下载。

5. 参考资料

《API安全实战》 – https://book.douban.com/subject/36039150/

《API安全技术与实战》 – https://book.douban.com/subject/35429043/

保密：系统如何保证敏感数据无法被内外部人员窃取滥用？ – https://time.geekbang.org/column/article/334293

Gin框架入门

Tue, 26 Sep 2023 14:31:52 +0800

环境

vscode,go1.14.3,gin1.4.0

1[root@go ~]# cat /etc/profile|tail -5
2# go enviroment
3export GOROOT=/usr/local/go
4export GOPATH=~/golib:~/goproject
5export GOBIN=~/gobin
6export PATH=$PATH:$GOROOT/bin:$GOBIN

1. Gin 是什么

一个用 Go (Golang) 编写的 HTTP Web 框架。

1.1. 安装

1go get -u github.com/gin-gonic/gin

1.2. hello word

 1package main
 2
 3import "github.com/gin-gonic/gin"
 4
 5func main() {
 6    r := gin.Default()  // 实例化一个 gin 的 server 实例（结构体变量）。
 7    r.GET("/ping", func(c *gin.Context) {  // 路由 + 方法
 8        c.JSON(200, gin.H{
 9            "message": "pong",
10        })
11    })
12    r.Run(":8099") // 监听并在 0.0.0.0:8099 上启动服务
13}

r.GET第一个参数是路由地址，第二个参数是处理函数。

1// GET is a shortcut for router.Handle("GET", path, handlers).
2func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {
3    return group.handle(http.MethodGet, relativePath, handlers)
4}

gin.H 实际上就是键值对 map。

1// H is a shortcut for map[string]interface{}
2type H map[string]any

1.3. Default 和 New 初始化路由器的区别

1router := gin.New()
2
3router := gin.Default()

使用 Default 方法，会在 New 的基础上，增加两个中间件：Logger、Recovery。

1// Default returns an Engine instance with the Logger and Recovery middleware already attached.
2func Default() *Engine {
3    debugPrintWARNINGDefault()
4    engine := New()
5    engine.Use(Logger(), Recovery())   // 增加两个中间件：Logger、Recovery。
6    return engine
7}

Logger、Recovery 作用分别为：

Logger：打印访问日志。

1[GIN] 2022/06/17 - 18:03:53 | 404 |         646ns |       127.0.0.1 | GET      "/"
2[GIN] 2022/06/17 - 18:04:02 | 200 |    1.556255ms |       127.0.0.1 | GET      "/ping"

2. 路由

2.1. 路由分组

对于 URL 中的重复部分，可以使用 Group 进行路由分组。

例如：商品的增删改查，可以使用 “/goods” 进行分组。

 1func router() {
 2    r := gin.Default()
 3    r.GET("/goods/list", goodsList)   // 每个 URL 都要添加 goods，繁杂。
 4    r.POST("/goods/add", createGoods)
 5    r.GET("/goods/3", goodsDetail)
 6    r.Run()
 7}
 8
 9
10func routerWithGroup() {
11    r := gin.Default()
12    routerGroup := r.Group("/goods")   // 路由分组
13    {  // 将路由分组下的代码用括号括在一起，只是为了代码的易读性，可不加{}。
14        routerGroup.GET("/list", goodsList)  // 访问：ip:8080/goods/list
15        routerGroup.POST("/add", createGoods)
16        routerGroup.GET("/3", goodsDetail)
17    }
18    r.Run()
19}
20
21func goodsDetail(context *gin.Context) {}
22func createGoods(context *gin.Context) {}
23func goodsList(context *gin.Context) {}

例如：不同版本的 API，使用 “/v1” 和 “v2” 进行分组。

 1func routerWithGroup() {
 2    r := gin.Default()
 3    v1 := r.Group("/v1")  // v1 版本 API
 4    {
 5        v1.GET("/login", login)  // 访问：ip:8080/v1/login
 6        v1.POST("/submit", submit)
 7        v1.GET("/read", read)
 8    }
 9
10    v2 := r.Group("/v2")   // v2 版本 API
11    {
12        v2.GET("/login", login2)
13        v2.POST("/submit", submit2)
14        v2.GET("/read", read2)
15    }
16
17    r.Run()
18}

2.2. 获取 URL 参数

路由中使用 :id 来匹配参数，使用 *path 来匹配路径。

 1func main() {
 2    r:= gin.Default()
 3    goodsGroup := r.Group("/goods")
 4    {
 5        /*
 6           URL:  http://127.0.0.1:8080/goods/3
 7           返回:  {id":"3"}
 8        */
 9        goodsGroup.GET("/:id", goodsDetail)  // 加一个参数 id
10
11        /*
12           URL:  http://127.0.0.1:8080/goods/3/Add
13           返回:  {"action":"Add","id":"3"}
14        */
15        goodsGroup.GET("/:id/:action", goodsAction)  // 加两个参数 id 和 action
16
17        /*
18           URL:  http://127.0.0.1:8080/goods/file/net/aimtao/www/home/goods/file/
19           返回:  {"path":"/net/aimtao/www/home/goods/file/"}
20        */
21        goodsGroup.GET("/file/*path", goodsFilePath)  // : 只匹配到下一个 / 结束，* 直接匹配到最后
22    }
23    r.Run()
24}
25
26func goodsDetail(context *gin.Context) {
27    id := context.Param("id")
28    context.JSON(http.StatusOK, gin.H{
29        "id": id,
30    })
31}
32
33func goodsAction(context *gin.Context) {
34    id := context.Param("id")
35    action := context.Param("action")
36    context.JSON(http.StatusOK, gin.H{
37        "id": id,
38        "action": action,
39    })
40}
41
42func goodsFilePath(context *gin.Context) {
43    path := context.Param("path")
44    context.JSON(http.StatusOK, gin.H{
45        "path": path,
46    })
47}

注意匹配冲突，举个例子：

1// 两个路由会冲突，输入 `http://127.0.0.1:8080/goods/list`，程序无法确认选择路由。
2goodsGroup.GET("/list", goodsList)
3goodsGroup.GET("/:id", goodsDetail)

2.3. URL 参数的表单验证

先对结构体变量用 tag 标记，形成约束条件。将 URL 中获取的参数，用 context.ShouldBindUri 进行验证该约束条件。

 1type Person struct{
 2    // uri:"id" 表示 Id 从 URL 参数 id 中取，参数 id 必须为 int 类型。
 3    // binding 表示该参数的约束，required 为必选参数。
 4    Id int `uri:"id" binding:"required"`
 5  
 6    // uri:"name" 表示 Name 从 URL 参数 name 中取，参数 name 必须为 string 类型。
 7    // binding 表示该参数的约束，required 为必选参数。
 8    Name string `uri:"name" binding:"required"`
 9}
10
11func main() {
12    r:= gin.Default()
13    r.GET("/:id/:name", func(context *gin.Context) {
14
15        var p Person
16        if err := context.ShouldBindUri(&p); err != nil {  // 从 context 中获取参数，进行验证后，赋值给 p。
17            context.Status(http.StatusBadRequest)
18            return
19        }
20        fmt.Println(p)
21        context.JSON(http.StatusOK, gin.H{
22            "id": p.Id,
23            "name": p.Name,
24        })
25    })
26    r.Run()
27}

context.ShouldBindUri 的函数实现：从 context 中获取参数，进行验证后，赋值给 obj。

1// ShouldBindUri binds the passed struct pointer using the specified binding engine.
2func (c *Context) ShouldBindUri(obj any) error {
3    m := make(map[string][]string)
4    for _, v := range c.Params {
5        m[v.Key] = []string{v.Value}
6    }
7    return binding.Uri.BindUri(m, obj)
8}

2.4. 获取 GET/POST 参数

GET 参数。

 1func main() {
 2    r:= gin.Default()
 3    r.GET("/person", person)
 4    r.Run()
 5}
 6
 7func person(context *gin.Context) {
 8    id := context.Query("id")  // 获取 GET 参数 id
 9    name := context.DefaultQuery("name", "anonymous")  // 获取 GET 参数 name，如果不存在，则使用默认值 anonymous。
10    context.JSON(http.StatusOK, gin.H{
11        "id": id,
12        "name": name,
13    })
14}
15
16/*
17    curl http://127.0.0.1:8080/person?id=1&name=hh
18    {"id":"1","name":"hh"}
19*/

POST 参数。

 1func main() {
 2    r:= gin.Default()
 3    r.POST("/person", person)
 4    r.Run()
 5}
 6
 7func person(context *gin.Context) {
 8    id := context.PostForm("id")  // 获取 POST 参数 id
 9    name := context.DefaultPostForm("name", "anonymous")  // 获取 POST 参数 name，如果不存在，则使用默认值 anonymous。
10    context.JSON(http.StatusOK, gin.H{
11        "id": id,
12        "name": name,
13    })
14}
15
16/*
17    curl -X POST -d "id=1&name=hh" http://127.0.0.1:8080/person
18    {"id":"1","name":"hh"}
19*/

GET 和 POST 混合参数。

 1func main() {
 2    r:= gin.Default()
 3    r.POST("/person", person)
 4    r.Run()
 5}
 6
 7func person(context *gin.Context) {
 8    id := context.Query("id")  // 获取 GET 参数
 9    name := context.DefaultPostForm("name", "anonymous")  // 获取 POST 参数
10    context.JSON(http.StatusOK, gin.H{
11        "id": id,
12        "name": name,
13    })
14}
15/*
16    curl -X POST -d "name=hh" http://127.0.0.1:8080/person?id=1
17    {"id":"1","name":"hh"}
18*/

2.5. 返回 JSON 和 ProtoBuf

除了使用 gin.H 返回 JSON，还可以返回整个 struct 作为 JSON。

 1func main() {
 2    r:= gin.Default()
 3    r.GET("/JSON", returnJSON)
 4    r.Run()
 5}
 6
 7func returnJSON(context *gin.Context) {
 8    var person struct{
 9        Name string `json:"name"`
10        Age int `json:"age"`
11    }
12    person.Name = "h"
13    person.Age  = 10
14    context.JSON(http.StatusOK, person)  // 返回整个 struct
15}
16
17/*
18    curl http://127.0.0.1:8080/JSON
19    {"name":"h","age":10}
20*/

先定义 proto 文件，在生成处理 protobuf 的 bg.go 文件，其中包含 struct 的定义。初始化该 struct，并使用 context.ProtoBuf 返回即可。

注意：此处需传递实例化的 struct 地址。

为什么 context.ProtoBuf 需要传地址，而 context.JSON 不需要？

context.JSON 需要接收一个结构体，并将其处理为字符串即可。
context.ProtoBuf 需要接收一个结构体指针，用这个指针去调用 protoreflect.ProtoMessage 方法。（bp.go 中，该结构体实现了 ProtoMessage 接口。）最终转化为 protobuf 格式。

 1func main() {
 2    r:= gin.Default()
 3    r.GET("/Protobuf", returnProtobuf)
 4    r.Run()
 5}
 6
 7func returnProtobuf(context *gin.Context) {
 8    course := []string{"go","rpc", "gin"}
 9    p := proto.Person{
10        Name: "hh",
11        Course: course,
12    }
13    context.ProtoBuf(http.StatusOK, &p)  // 注意：此处需传递实例化的 struct 地址
14}

2.6. 使用 validator 进行表单验证

gin 使用 go-playground/validator 验证参数。gin 将其封装成两套绑定方法。

Must bind
- Methods：Bind、BindJSON、BindXML、BindQuery、BindYAML
- Behavior：这些方法底层使用 MustBindWith，如果验证错误，请求会被 c.AbortWithError(http.StatusBadRequest, err).SetType(ErrorTypeBind) 中止请求，响应状态码会设置为 400。（如果想自定义处理错误和请求响应，应使用 ShouldBind）

 1// MustBindWith binds the passed struct pointer using the specified binding engine.
 2// It will abort the request with HTTP 400 if any error occurs.
 3// See the binding package.
 4func (c *Context) MustBindWith(obj any, b binding.Binding) error {
 5    if err := c.ShouldBindWith(obj, b); err != nil {
 6        c.AbortWithError(http.StatusBadRequest, err).SetType(ErrorTypeBind) //nolint: errcheck
 7        return err
 8    }
 9    return nil
10}

Should bind
- Methods：ShouldBind、ShouldBindJSON、ShouldBindXML、ShouldBindQuery、ShouldBindYAML
- Behavior：这些方法底层使用 ShouldBindWith，如果验证错误，则返回错误，由开发人员自定义处理错误和请求响应。

当调用 Bind、ShouldBind两种方法时，Gin 会根据求的 Method 和 Content-Type 推断使用哪种绑定器，然后使用 ShouldBindWith(obj any, b binding.Binding) 或 BindWith(obj any, b binding.Binding)。具体如何调用及推断的逻辑如下：

 1// ShouldBind checks the Method and Content-Type to select a binding engine automatically,
 2// Depending on the "Content-Type" header different bindings are used, for example:
 3//
 4//    "application/json" --> JSON binding
 5//    "application/xml"  --> XML binding
 6//
 7// It parses the request's body as JSON if Content-Type == "application/json" using JSON or XML as a JSON input.
 8// It decodes the json payload into the struct specified as a pointer.
 9// Like c.Bind() but this method does not set the response status code to 400 or abort if input is not valid.
10func (c *Context) ShouldBind(obj any) error {
11    b := binding.Default(c.Request.Method, c.ContentType())   // 推断使用哪种绑定器
12    return c.ShouldBindWith(obj, b)
13}

 1// Content-Type MIME of the most common data formats.
 2const (
 3    MIMEJSON              = "application/json"
 4    //...
 5
 6// Default returns the appropriate Binding instance based on the HTTP method
 7// and the content type.
 8func Default(method, contentType string) Binding {
 9   if method == http.MethodGet {  // GET 方法使用 ShouldBindForm 方法
10        return Form
11    }
12
13    switch contentType {   // 根据 contentType 判断使用哪种绑定器
14    case MIMEJSON:
15        return JSON
16    case MIMEXML, MIMEXML2:
17        //...

举个例子： 对注册的表单进行验证。

SignUpForm 使用 tag 配置约束条件。
使用 context.ShouldBind(&signUpForm) 进行表单验证。

 1import (
 2    "fmt"
 3    "net/http"
 4  
 5    "github.com/gin-gonic/gin"
 6)
 7
 8type SignUpForm struct {
 9    Username string `json:"username" form:"username" binding:"required,max=10"`  // 约束条件:必填、最大长度10
10    Password string `json:"password" form:"password" binding:"required,min=6"`  // 约束条件:必填、最小长度6
11    RePassword string `json:"repassword" form:"repassword" binding:"required,eqfield=Password"` // 约束条件:必填、等于 Password 字段
12    Age int `json:"age" form:"age" binding:"required"`  // 约束条件:必填
13    Email string `json:"email" form:"email" binding:"required,email"` // 约束条件:必填、检查是否是邮箱
14}
15
16func main() {
17    engine := gin.Default()
18    engine.POST("SignUp", Login)
19    engine.Run(":8083")
20}
21
22func Login(context *gin.Context) {
23    var signUpForm SignUpForm
24
25    // 表单验证，验证不通过，ShouldBind 会返回 error。
26    // ShouldBind 会根据请求的 Method 和 Content-Type，自动选择 JSON、XML、Query 等等，此处会调用 ShouldBindJSON
27    if err := context.ShouldBind(&signUpForm); err != nil {
28        context.JSON(http.StatusBadRequest, gin.H{
29            "error": err.Error(),
30        })
31        return  // 验证错误记得 return，否则会在继续往下执行。
32    }
33
34    context.JSON(http.StatusOK, gin.H{
35        "msg": "signup success",
36        "user": signUpForm.Username,
37    })
38}

当有不符合条件的访问时，会返回 400 及错误原因。

 1## Request
 2curl -X "POST" "http://127.0.0.1:8083/SignUp" \
 3     -H 'Content-Type: application/json; charset=utf-8' \
 4     -d $'{
 5  "username": "Tom",
 6  "password": "123456",
 7   "repassword": "12345",   # 重复密码不一致
 8  "age": 18,
 9  "email": "123@123.com"
10
11}'
12
13
14# 返回错误
15HTTP/1.1 400 Bad Request
16Content-Length: 108
17Content-Type: text/plain; charset=utf-8
18Connection: close
19
20{"error":"Key: 'SignUpForm.RePassword' Error:Field validation for 'RePassword' failed on the 'eqfield' tag"}

2.7. 为 validator 配置翻译器

初始化语言环境
传入语言环境，初始化通用翻译器
从通用翻译器中拿出中文翻译器
绑定中文验证器和翻译器
将验证器返回的 Error 转换为 validator.ValidationErrors，这样 Error 就有了 Translate 方法
使用 Translate 方法

具体流程参照代码阅读。

 1import (
 2    "fmt"
 3    "net/http"
 4  
 5    "github.com/gin-gonic/gin"
 6    "github.com/gin-gonic/gin/binding"
 7    "github.com/go-playground/locales/en"
 8    "github.com/go-playground/locales/zh"
 9    ut "github.com/go-playground/universal-translator"
10    "github.com/go-playground/validator/v10"
11    en2 "github.com/go-playground/validator/v10/translations/en"
12    zh2 "github.com/go-playground/validator/v10/translations/zh"
13)
14
15type SignUpForm struct {
16    Username string `json:"username" form:"username" binding:"required,max=10"`  // 约束条件:必填、最大长度10
17    Password string `json:"password" form:"password" binding:"required,min=6"`  // 约束条件:必填、最小长度6
18    RePassword string `json:"repassword" form:"repassword" binding:"required,eqfield=Password"` // 约束条件:必填、等于 Password 字段
19    Age int `json:"age" form:"age" binding:"required"`  // 约束条件:必填
20    Email string `json:"email" form:"email" binding:"required,email"` // 约束条件:必填、检查是否是邮箱
21}
22
23var translator ut.Translator  // 定义全局的翻译器
24
25func main() {
26    engine := gin.Default()
27    err := InitTrans("zh")  // 初始化中文翻译器
28    if err != nil {
29        panic(err)
30    }
31    engine.POST("SignUp", Login)
32    engine.Run(":8083")
33}
34
35
36func InitTrans(locale string) (err error) {
37    translatorZh := zh.New()  // 中文环境   //【1.初始化中文翻译器】
38    translatorEn := en.New()  // 英文环境
39    uni := ut.New(translatorZh, translatorEn, translatorZh)  // 【2.传入语言环境，初始化通用翻译器】  // 通用翻译器保存所有的语言环境和翻译数据。第一个参数是备用的语言环境，后面是应支持的语言环境
40    var found bool
41    translator, found = uni.GetTranslator(locale)  // 【3.根据 locale 拿到最终的翻译器】
42    if !found {
43        return fmt.Errorf("uni.GetTranslator(%s)", locale)
44    }
45
46    // 拿到 gin 的验证器
47    validate := binding.Validator.Engine().(*validator.Validate)
48
49    // 【4.根据 locale，绑定验证器和翻译器】
50    switch locale {
51    case "en":
52        err = en2.RegisterDefaultTranslations(validate, translator)
53    case "zh":
54        err = zh2.RegisterDefaultTranslations(validate, translator)
55    default:
56        err = en2.RegisterDefaultTranslations(validate, translator)
57    }
58
59    return err
60}
61
62func Login(context *gin.Context) {
63    var signUpForm SignUpForm
64
65    // 表单验证，验证不通过，ShouldBind 会返回 error。
66    // ShouldBind 会根据请求的 Method 和 Content-Type，自动选择 JSON、XML、Query 等等，此处会调用 ShouldBindJSON
67    if err := context.Bind(&signUpForm); err != nil {
68        errors := err.(validator.ValidationErrors)  // 【5.类型转换为 validator.ValidationErrors】
69        context.JSON(http.StatusOK, gin.H{
70            "error": errors.Translate(translator),  // 【6.使用 Translate 方法】
71        })
72        return
73    }
74
75    context.JSON(http.StatusOK, gin.H{
76        "msg": "signup success",
77        "user": signUpForm.Username,
78    })
79}

当有不符合条件的访问时，错误原因被翻译成中文。

 1## Request
 2curl -X "POST" "http://127.0.0.1:8083/SignUp" \
 3     -H 'Content-Type: application/json; charset=utf-8' \
 4     -d $'{
 5  "username": "Tom",
 6  "password": "123456",
 7   "repassword": "12345",   # 重复密码不一致
 8  "age": 18,
 9  "email": "123.com"  # 邮箱格式错误 
10
11}'
12
13
14# 返回错误
15HTTP/1.1 400 Bad Request
16Content-Length: 108
17Content-Type: text/plain; charset=utf-8
18Connection: close
19
20{
21    "error":{
22        "SignUpForm.Email":"Email必须是一个有效的邮箱",
23        "SignUpForm.RePassword":"RePassword必须等于Password"
24     }
25 }

2.8. 更改验证错误字段格式

上述错误原因虽然是中文的，但是字段格式不是 json 格式的。期望返回的是这样的格式：

1{
2    "error":{
3        "email":"email必须是一个有效的邮箱",
4        "repassword":"repassword必须等于password"
5     }
6 }

主要需要做两件事：

验证时，字段使用 tag 配置中的 json 格式。
在拿到 gin 的验证器时，注册一个获取 Tag Name 的方法

1// 拿到 gin 的验证器
2validate := binding.Validator.Engine().(*validator.Validate)
3validate.RegisterTagNameFunc(func(field reflect.StructField) string {  // 注册一个获取 Tag Name 的方法
4    name := strings.SplitN(field.Tag.Get("json"), ",", 2)[0]  // 获取 tag 中的 json 配置。
5    if name == "-" {  // 如果 tag 中的 json 配置为 - 时，说明配置为 空字符串。
6        return " "
7    }
8    return name
9})

去掉 struct 名称。

errors.Translate(translator) 返回的是 ValidationErrorsTranslations 类型，其实就是 map[string]string 类型。我们要进行字符串操作的就是这个 map 的 key。

1// 在验证请求时
2if err := context.Bind(&signUpForm); err != nil {
3    errors := err.(validator.ValidationErrors) 
4    context.JSON(http.StatusOK, gin.H{
5        "error": removeTopStruct(errors.Translate(translator)),  // 处理 map 的 key。
6    })
7    return
8}

如何处理？找到点的位置，进行切片操作。

1func removeTopStruct(fields map[string]string) map[string]string {
2    rsp := map[string]string{}
3    for field, err := range fields {
4        rsp[field[strings.Index(field, ".")+1:]] = err  // 只要点后面的字符串：找到点的位置，进行切片操作
5    }
6    return rsp
7}

3. 中间件

3.1. 自定义中间件

中间件可以避免代码的侵入性。gin 的中间件使用很简便，只需提供一个 gin.HandlerFunc 类型的函数即可。

 1// 用于计时的中间件
 2func timing() gin.HandlerFunc {
 3    return func(c *gin.Context) {
 4        t := time.Now()
 5        c.Set("number", "1233")
 6
 7        c.Next() // 执行真正的请求处理函数
 8
 9        end := time.Since(t)
10        fmt.Println("Duration: ", end)
11        fmt.Println("Writer status: ", c.Writer.Status())
12    }
13}
14
15func main() {
16    engine := gin.New() // gin.Default() 默认使用 Logger、Recovery 两个中间件
17    engine.Use(gin.Logger(), gin.Recovery(), timing()) // 使用计时的中间件
18    engine.GET("/index", index)
19    engine.Run(":8083")
20}
21
22func index(c *gin.Context) {
23    if value, exists := c.Get("number"); exists {
24        time.Sleep(time.Second)
25        c.JSON(http.StatusOK, gin.H{
26            "number": value,
27        })
28    }
29}

3.2. 中间件队列原理

如图，RouterGroup 中维护了一个队列 Handlers，并将中间件及请求处理函数依次加入其中。处理请求时，依次执行队列中的函数，并使用 index 指向正在执行的函数。

c.Next()：表示 index ++，开始执行队列中后面的函数。
c.Abort()：表示中止队列函数的执行。所以在中间件中，使用 return 并不能中止队列函数的执行，只能结束当前函数，index 还是会向后移动，并执行后面的函数。 我们来具体看下源码。

RouterGroup 中，维护一个函数数组 Handlers。这里的 HandlersChain 类型就是 func(*Context)。

1// routergroup.go
2type RouterGroup struct {
3    Handlers HandlersChain
4    basePath string
5    engine   *Engine
6    root     bool
7}

1// gin.go
2type HandlerFunc func(*Context)
3type HandlersChain []HandlerFunc

当需要加入中间件时，gin.Use -> RouterGroup.Use，将中间件加入队列。

1// routergroup.go
2func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
3    group.Handlers = append(group.Handlers, middleware...)
4    return group.returnObj()
5}

当需要加入请求处理函数时，gin.GET -> RouterGroup.handle -> RouterGroup.combineHandlers，创建一个新的队列，将原有的中间件和请求处理函数拷贝到其中。

 1func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain {
 2  
 3    finalSize := len(group.Handlers) + len(handlers) // 计算新的队列长度
 4    assert1(finalSize < int(abortIndex), "too many handlers")
 5  
 6    mergedHandlers := make(HandlersChain, finalSize) // 创建新队列
 7  
 8    copy(mergedHandlers, group.Handlers)  // 向新队列中增加原来的中间件
 9    copy(mergedHandlers[len(group.Handlers):], handlers)  // 向新队列的尾部，增加请求处理函数
10    return mergedHandlers
11}

4. 其他

4.1. 模版功能

https://pkg.go.dev/html/template

处理请求时，gin 返回模版文件+变量数据。

（1）最小实践

1.
2├── main.go
3└── templates
4    └── index.html

 1// main.go
 2
 3func main() {
 4    router := gin.Default()
 5    router.LoadHTMLFiles("templates/index.html") // 相对路径加载 HTML 文件。
 6  
 7    router.GET("/index", func(context *gin.Context) {
 8        context.HTML(http.StatusOK, "index.html", gin.H{ // 将 title 传给 index.html
 9            "title": "haha",
10        })
11    })
12  
13    router.Run(":8080")
14}

 1<!--templates/index.html-->
 2
 3<!DOCTYPE html>
 4<html lang="en">
 5<head>
 6    <meta charset="utf-8">
 7    <title>Hello World</title>
 8</head>
 9<body>
10    <h1>{{ .title }}</h1>  <!-- 使用 gin 传递过来的 title。注意格式 {{.变量名}} -->
11</body>
12</html>

注意相对路径问题：

上述代码中，使用 “templates/index.html” 相对路径，直接在 IDE 中使用 go run 无法获取到相当路径，需要在当前路径下 go build 出可执行文件，再执行。
原因：go run 执行时，所在的目录是临时目录。

1dir, _ := filepath.Abs(filepath.Dir(os.Args[0]))
2fmt.Println("dir: ", dir)
3
4// output：
5// dir:  /private/var/folders/hr/2w_2q41n7mvb9jv1vrjsrzmh0000gn/T/GoLand  // 临时目录

（2）同时加载多个 HTML

文件过多，可以使用 LoadHTMLGlob 加载整个目录。

1.
2├── main.go
3└── templates
4    ├── goods.html
5    └── index.html

 1func main() {
 2    router := gin.Default()
 3    router.LoadHTMLGlob("templates/*") // 加载整个目录下所有文件
 4    // router.LoadHTMLFiles("templates/index.html", "templates/goods.html") // 可变参数列表，一个一个加载
 5
 6    router.GET("/index", func(context *gin.Context) {
 7        context.HTML(http.StatusOK, "index.html", gin.H{ // 将 title 传给 index.html
 8            "title": "haha",
 9        })
10    })
11
12    router.GET("/goods", func(context *gin.Context) {
13        context.HTML(http.StatusOK, "goods.html", gin.H{ // 将 title 传给 goods.html
14            "title": "goods",
15        })
16    })
17
18    router.Run(":8080")
19}

（3）处理文件名冲突问题

1.
2├── main.go
3└── templates
4    ├── goods
5    │   └── list.html
6    ├── index
7    │   └── index.html
8    └── user
9        └── list.html

 1// main.go
 2
 3func main() {
 4    router := gin.Default()
 5    router.LoadHTMLGlob("templates/**/*") // 加载 templates 下的所有二级目录（只加载二级目录）
 6
 7    router.GET("/index", func(context *gin.Context) {
 8        context.HTML(http.StatusOK, "index/index.html", gin.H{ // 使用 /templates/index/index.html 中 define 的值
 9            "title": "haha",
10        })
11    })
12
13    router.GET("/user/list", func(context *gin.Context) {
14        context.HTML(http.StatusOK, "user/list.html", gin.H{ // 使用 /templates/user/list.html 中 define 的值
15            "title": "users",
16        })
17    })
18
19    router.GET("/goods/list", func(context *gin.Context) {
20        context.HTML(http.StatusOK, "goods/list.html", gin.H{ // 使用 /templates/goods/list.html 中 define 的值
21            "title": "goods",
22        })
23    })
24
25    router.Run(":8080")
26}

goods/list.html

 1{{define "goods/list.html" }}   <!--定义文件名称-->
 2<!DOCTYPE html>
 3<html lang="en">
 4<head>
 5    <meta charset="UTF-8">
 6    <title>goods</title>
 7</head>
 8<body>
 9    <h1>{{ .title }}</h1>
10</body>
11</html>
12{{end}}

index/index.html

 1{{define "index/index.html" }}
 2<!--定义文件名称-->
 3<!DOCTYPE html>
 4<html lang="en">
 5<head>
 6    <meta charset="utf-8">
 7    <title>Hello World</title>
 8</head>
 9<body>
10<h1>{{ .title }}</h1>   
11    <!-- 使用 gin 传递过来的 title。注意格式 {{.变量名}} -->
12</body>
13</html>
14{{end}}

user/list.html

 1{{define "user/list.html" }}   <!--定义文件名称-->
 2<!DOCTYPE html>
 3<html lang="en">
 4<head>
 5    <meta charset="utf-8">
 6    <title>Hello World</title>
 7</head>
 8<body>
 9    <h1>{{ .title }}</h1>   <!-- 使用 gin 传递过来的 title。注意格式 {{.变量名}} -->
10</body>
11</html>
12{{end}}

其中有几个问题需要说明一下：

router.LoadHTMLGlob("templates/**/*") 表示只能加载 templates 下的二级目录的所有内容，此时 templates 目录下的 html 文件是无法被加载的。
- 解决：index.html 文件，也放在二级目录 index 目录下。
goods/list.html 和 user/list.html 的文件重名，在使用 context.HTML 时，均传入的 list.html，会导致其中一个会失效。
- 解决：在 html 文件中，使用 define 定义文件名称。gin 中使用时，使用 define 的名称。
- 优先找 define 的名称，没有 define 定义，使用默认的 LoadHTMLGlob 来找文件。

4.2. 静态文件处理

html 中需要引用大量的静态文件，使用 router.Static("/static", "./static") 指明以 /static 开头的链接，均在 ./static 目录下找。

1.
2├── main.go
3├── static
4│   └── css
5│       └── index.css
6└── templates
7    └── index.html

 1// main.go
 2func main() {
 3    router := gin.Default()
 4    router.LoadHTMLGlob("templates/*")
 5    router.Static("/static", "./static") // 以 /static 开头的链接，均在 ./static 目录下找
 6    router.GET("/index", func(context *gin.Context) {
 7        context.HTML(http.StatusOK, "index.html", gin.H{
 8            "title": "haha",
 9        })
10    })
11
12    router.Run(":8080")
13}

 1<!-- /templates/index.html --> 
 2<!DOCTYPE html>
 3<link rel="stylesheet" href="/static/css/index.css">  <!-- 引用静态文件-->
 4<html lang="en">
 5<head>
 6    <meta charset="utf-8">
 7    <title>Hello World</title>
 8</head>
 9<body>
10<h1>{{ .title }}</h1>   <!-- 使用 gin 传递过来的 title。注意格式 {{.变量名}} -->
11</body>
12</html>

1/*template/static/css/index.css*/
2*{
3    background-color: burlywood;
4}

4.3. gin 的优雅退出

https://gin-gonic.com/docs/examples/graceful-restart-or-stop/

优雅退出的作用：当关闭程序时，应该做一些后续处理。比如：将没保存的数据做保存、保存日志、向注册中心告知当前服务已下线等等。

 1import (
 2    "fmt"
 3    "net/http"
 4    "os"
 5    "os/signal"
 6    "syscall"
 7
 8    "github.com/gin-gonic/gin"
 9)
10
11func main() {
12    router := gin.Default()
13    router.GET("/", func(c *gin.Context) {
14        c.JSON(http.StatusOK, gin.H{
15            "message": "Hello World!",
16        })
17    })
18
19    go func() {
20        router.Run(":8080") // 在 goroutine 中监听，让主进程等待 channel 信号。
21    }()
22
23    quit := make(chan os.Signal)
24    // SIGINT 是 Crtl+C; SIGTERM 是 kill 命令不加参数。（kill -9 是 SIGKILL 无法捕获）
25    // 当收到 SIGINT、SIGTERM 信号时，像 channel 中写数据。
26    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
27
28    <-quit // channel 收到数据，说明收到结束进程的信号。
29
30    // 处理退出逻辑，此处使用 print 模拟。
31    fmt.Println("Closing server...")
32    fmt.Println("Unregistering service...")
33}

4.4. 自动证书配置

指无需配置任何证书，即可自动下载证书，过期自动续约的功能

 1package mainimport "github.com/gin-gonic/gin"/*
 2    * 废弃
 3    engine := gin.Default()
 4    //证书位置使用的是相对路径
 5    _ = http.ListenAndServeTLS(":443", "cert/www.domain.cn.crt","cert/www.domain.cn.key", engine)
 6    */
 7func main() {
 8    r := gin.Default()
 9    r.GET("/test", func(c *gin.Context) {
10        c.String(200, "golang")
11        }
12    )
13    autotls.Run(r, "xzeu.com")
14}

使用casbin做基于RBAC的权限验证

Thu, 23 Mar 2023 00:26:20 +0800

1. 概述

Casbin是一个强大的、高效的开源访问控制框架，其权限管理机制支持多种访问控制模型。

Casbin可以

支持自定义请求的格式，默认的请求格式为{subject, object, action}。
具有访问控制模型model和策略policy两个核心概念。
支持RBAC中的多层角色继承，不止主体可以有角色，资源也可以具有角色。
支持内置的超级用户例如：root或administrator。超级用户可以执行任何操作而无需显式的权限声明。
支持多种内置的操作符，如 keyMatch，方便对路径式的资源进行管理，如 /foo/bar可以映射到/foo*

Casbin不能

身份认证 authentication（即验证用户的用户名、密码），casbin只负责访问控制。应该有其他专门的组件负责身份认证，然后由casbin进行访问控制，二者是相互配合的关系。
管理用户列表或角色列表。 Casbin 认为由项目自身来管理用户、角色列表更为合适，用户通常有他们的密码，但是 Casbin 的设计思想并不是把它作为一个存储密码的容器。而是存储RBAC方案中用户和角色之间的映射关系。

2. 快速入门

2.1. 安装

1go get github.com/casbin/casbin/v2

2.2. 创建模型文件

model.conf

 1[request_definition]
 2r = sub, obj, act
 3
 4[policy_definition]
 5p = sub, obj, act
 6
 7[role_definition]
 8g = _, _
 9
10[policy_effect]
11e = some(where (p.eft == allow))
12
13[matchers]
14m = g(r.sub, p.sub) && r.obj == p.obj && r.act == p.act

2.3. 创建策略文件

policy.csv

p代表了具体的策略信息，比如alice访问/users的GET访问权限 g代表角色的策略信息，比如alice属于admin组，具有访问/users下的GET和POST权限

1p, alice, /users, GET
2p, bob, /users, POST
3p, admin, /users, GET
4p, admin, /users, POST
5p, admin, /users, DELETE
6g, alice, admin

2.4. 初始化enfocer

 1var (
 2  e   *casbin.Enforcer
 3  err error
 4)
 5
 6func init() {
 7  e, err = casbin.NewEnforcer("model.conf", "policy.csv")
 8  if err != nil {
 9    logrus.Fatal("load file failed, %v", err.Error())
10  }
11}

2.5. 定义一个检测权限的函数

 1func checkPermission(ctx *gin.Context, sub, obj, act string) {
 2  logrus.Infof("sub = %s obj = %s act = %s", sub, obj, act)
 3  ok, err := e.Enforce(sub, obj, act)
 4  if err != nil {
 5    logrus.Print("enforce failed %s", err.Error())
 6    ctx.String(http.StatusInternalServerError, "内部服务器错误")
 7    return
 8  }
 9  if !ok {
10    logrus.Println("权限验证不通过")
11    ctx.String(http.StatusOK, "权限验证不通过")
12    return
13  }
14  logrus.Println("权限验证通过")
15  ctx.String(http.StatusOK, "权限验证通过")
16}

2.6. 定义/users下的2个接口

 1func main() {
 2  r := gin.Default()
 3
 4  r.GET("/users", func(ctx *gin.Context) {
 5    sub := ctx.Query("username")
 6    obj := ctx.Request.URL.Path
 7    act := ctx.Request.Method
 8    checkPermission(ctx, sub, obj, act)
 9  })
10  r.POST("/users", func(ctx *gin.Context) {
11    sub := ctx.Query("username")
12    obj := ctx.Request.URL.Path
13    act := ctx.Request.Method
14    checkPermission(ctx, sub, obj, act)
15  })
16
17  r.Run()
18}

2.7. 运行测试

1go run main.go

请求截图

终端输出

3. API操作

这里使用RBAC中的删除用户操作做演示，更多操作请查看文档API概览

3.1. 创建结构体

1type PermissionObj struct {
2  User string `json:"user" form:"user"`
3  Sub  string `json:"sub" form:"sub"`
4}

3.2. 增加删除接口

 1  r.DELETE("/users", func(ctx *gin.Context) {
 2    // 先验证用户权限 
 3    var p PermissionObj
 4    ctx.ShouldBind(&p)
 5    obj := ctx.Request.URL.Path
 6    act := ctx.Request.Method
 7    logrus.Infof("sub = %s obj = %s act = %s", p.User, obj, act)
 8    ok, err := e.Enforce(p.User, obj, act)
 9    if err != nil {
10      ctx.String(http.StatusInternalServerError, "内部服务器错误")
11      return
12    }
13    if !ok {
14      ctx.String(http.StatusOK, "您没有权限")
15      return
16    }
17    logrus.Println("权限验证通过")
18    // 删除指定用户
19    ok, err = e.DeleteUser(p.Sub)
20    if err != nil {
21      logrus.Info(err.Error())
22      ctx.String(http.StatusInternalServerError, "内部服务器错误")
23      return
24    }
25    if !ok {
26      ctx.String(http.StatusOK, "删除用户失败")
27      return
28    }
29    ctx.String(http.StatusOK, "删除用户成功")
30    e.SavePolicy()
31  })

3.3. 运行

1go run main.go

3.4. 删除用户

3.5. policy文件

看到bob已经从policy文件中删除了。

4. 更多

想了解更多更详细的用法，可以参考casbin官网

Go语言中使用gopsutil进行系统信息采集

Thu, 23 Mar 2023 00:01:23 +0800

1. gopsutil包介绍

psutil是一个跨平台进程和系统监控的Python库，而gopsutil是其Go语言版本的实现。

安装go get github.com/shirou/gopsutil

2. gopsutil包的使用

2.1. 采集CPU相关信息

 1package main
 2
 3import (
 4    "fmt"
 5    "github.com/shirou/gopsutil/cpu"
 6)
 7
 8func main() {
 9    c, _ := cpu.Info()
10    fmt.Println("cpu信息:",c)
11    /*用户CPU时间/系统CPU时间/空闲时间。。。等等
12    用户CPU时间：就是用户的进程获得了CPU资源以后，在用户态执行的时间。
13    系统CPU时间：用户进程获得了CPU资源以后，在内核态的执行时间。
14    */
15    c1,_ := cpu.Times(false)
16    fmt.Println("cpu1:",c1)
17    
18    // CPU使用率，每秒刷新一次
19    for{
20     c2, _ := cpu.Percent(time.Duration(time.Second), false)
21     fmt.Println(c2)
22    }
23}

运行后输出结果如下

1cpu信息: [{"cpu":0,"vendorId":"GenuineIntel","family":"6","model":"78","stepping":3,"physicalId":"","coreId":"","cores":2,"modelName":"Intel(R) Core(TM) i5-6360U CPU @ 2.00GHz","mhz":2000,"cacheSize":256,"flags":["fpu","vme","de","pse","tsc","msr","pae","mce","cx8","apic","sep","mtrr","pge","mca","cmov","pat","pse36","clfsh","ds","acpi","mmx","fxsr","sse","sse2","ss","htt","tm","pbe","sse3","pclmulqdq","dtes64","mon","dscpl","vmx","smx","est","tm2","ssse3","fma","cx16","tpr","pdcm","sse4.1","sse4.2","x2apic","movbe","popcnt","aes","pcid","xsave","osxsave","seglim64","tsctmr","avx1.0","rdrand","f16c","rdwrfsgs","tsc_thread_offset","sgx","bmi1","hle","avx2","smep","bmi2","erms","invpcid","rtm","fpu_csds","mpx","rdseed","adx","smap","clfsopt","ipt","mdclear","tsxfa","ibrs","stibp","l1df","acapmsr","ssbd","syscall","xd","1gbpage","em64t","lahf","lzcnt","prefetchw","rdtscp","tsci"],"microcode":""}]
2cpu1: [{"cpu":"cpu-total","user":28155.8,"system":12587.9,"idle":18629.5,"nice":0.0,"iowait":0.0,"irq":0.0,"softirq":0.0,"steal":0.0,"guest":0.0,"guestNice":0.0}]
3[14.640198511110253]
4[24.371859296492058]
5[36.06965174136557]
6[25.249999999869033]
7[9.750000000003183]
8[10.723192019951934]
9[7.231920199519346]

2.2. 采集内存信息

 1package main
 2
 3import (
 4	"fmt"
 5	"github.com/shirou/gopsutil/mem"
 6)
 7
 8func main() {
 9	//获取物理内存和交换区内存信息
10	m1, _ := mem.VirtualMemory()
11	fmt.Println("m1:", m1)
12	m2, _ := mem.SwapMemory()
13	fmt.Println("m2:", m2)
14}

运行后输出结果如下

1m1: {"total":8589934592,"available":2471567360,"used":6118367232,"usedPercent":71.22716903686523,"free":287182848,"active":2450747392,"inactive":2184384512,"wired":2206617600,"laundry":0,"buffers":0,"cached":0,"writeback":0,"dirty":0,"writebacktmp":0,"shared":0,"slab":0,"sreclaimable":0,"sunreclaim":0,"pagetables":0,"swapcached":0,"commitlimit":0,"committedas":0,"hightotal":0,"highfree":0,"lowtotal":0,"lowfree":0,"swaptotal":0,"swapfree":0,"mapped":0,"vmalloctotal":0,"vmallocused":0,"vmallocchunk":0,"hugepagestotal":0,"hugepagesfree":0,"hugepagesize":0}
2m2: {"total":2147483648,"used":1139802112,"free":1007681536,"usedPercent":53.076171875,"sin":0,"sout":0,"pgin":0,"pgout":0,"pgfault":0,"pgmajfault":0}

2.3. 采集主机信息

 1package main
 2
 3import (
 4    "fmt"
 5    "github.com/shirou/gopsutil/host"
 6)
 7
 8func main() {
 9  h,_ := host.Info()
10  fmt.Println("本机信息：",h)
11}

运行结果如下

1本机信息： {"hostname":"bogon","uptime":123107,"bootTime":1679378749,"procs":529,"os":"darwin","platform":"darwin","platformFamily":"Standalone Workstation","platformVersion":"12.6.3","kernelVersion":"21.6.0","kernelArch":"x86_64","virtualizationSystem":"","virtualizationRole":"","hostid":"7eaf5a50-bd77-5161-807f-c0e6b43c525d"}

2.4. 采集磁盘信息

 1package main
 2
 3import(
 4	"fmt"
 5	"github.com/shirou/gopsutil/disk"
 6)
 7
 8func main(){
 9	 //可以通过psutil获取磁盘分区、磁盘使用率和磁盘IO信息
10	 d1, _ := disk.Partitions(true)  //所有分区
11	 fmt.Println("d1:",d1)
12	 d2, _ := disk.Usage("E:")  //指定某路径的硬盘使用情况
13	 fmt.Println("d2:",d2)
14	 d3, _ := disk.IOCounters()  //所有硬盘的io信息
15	 fmt.Println("d3:",d3)
16}

运行结果输出如下

1d1: [{"device":"/dev/disk1s7s1","mountpoint":"/","fstype":"apfs","opts":"ro,journaled,multilabel"} {"device":"devfs","mountpoint":"/dev","fstype":"devfs","opts":"rw,nobrowse,multilabel"} {"device":"/dev/disk1s4","mountpoint":"/System/Volumes/VM","fstype":"apfs","opts":"rw,noexec,nobrowse,journaled,multilabel,noatime"} {"device":"/dev/disk1s2","mountpoint":"/System/Volumes/Preboot","fstype":"apfs","opts":"rw,nobrowse,journaled,multilabel"} {"device":"/dev/disk1s6","mountpoint":"/System/Volumes/Update","fstype":"apfs","opts":"rw,nobrowse,journaled,multilabel"} {"device":"/dev/disk1s1","mountpoint":"/System/Volumes/Data","fstype":"apfs","opts":"rw,nobrowse,journaled,multilabel"} {"device":"/dev/disk1s5","mountpoint":"/Volumes/Macintosh HD","fstype":"apfs","opts":"ro,journaled,multilabel"} {"device":"map auto_home","mountpoint":"/System/Volumes/Data/home","fstype":"autofs","opts":"rw,nobrowse,automounted,multilabel"}]
2d2: <nil>
3d3: map[disk0:{"readCount":4415145,"mergedReadCount":0,"writeCount":1979881,"mergedWriteCount":0,"readBytes":101074788352,"writeBytes":70279589888,"readTime":3035356,"writeTime":1168835,"iopsInProgress":0,"ioTime":4204191,"weightedIO":0,"name":"disk0","serialNumber":"","label":""}]

2.5. 采集网络信息

 1package main
 2
 3import (
 4	"fmt"
 5
 6	"github.com/shirou/gopsutil/net"
 7)
 8
 9func main() {
10	//获取当前网络连接信息
11	n1, _ := net.Connections("all") //可填入tcp、udp、tcp4、udp4等等
12	fmt.Println("n1:", n1)
13
14	//获取网络读写字节／包的个数
15	n2, _ := net.IOCounters(false)
16	fmt.Println("n2:", n2)
17}

输出结果如下

1n1: [{"fd":8,"family":2,"type":1,"localaddr":{"ip":"10.10.10.7","port":53069},"remoteaddr":{"ip":"76.223.31.44","port":443},"status":"ESTABLISHED","uids":null,"pid":458} {"fd":6,"family":2,"type":1,"localaddr":{"ip":"*","port":80},"remoteaddr":{"ip":"","port":0},"status":"LISTEN","uids":null,"pid":462} 
2...
3n2: [{"name":"all","bytesSent":477026803,"bytesRecv":655952405,"packetsSent":538975,"packetsRecv":656382,"errin":0,"errout":0,"dropin":0,"dropout":67,"fifoin":0,"fifoout":0}]

2.6. 采集进程相关信息

 1package main
 2
 3import (
 4	"fmt"
 5
 6	"github.com/shirou/gopsutil/process"
 7)
 8
 9func main() {
10	//获取到所有进程的详细信息
11	p1, _ := process.Pids() //获取当前所有进程的pid
12	fmt.Println("p1:", p1)
13	ifExists, _ := process.PidExists(10086) // 判断进程是否存在
14	fmt.Println("ifExists:", ifExists)
15
16}

输出结果

1p1: [1 88 89 92 93 94 97 99 101 105 107 108 110 114 115 116 117 120 124 125 126 127 128 129 130 131 136 137 138 140 141 144 145 146 149 150 151 152 153 154 155 156 157 158 161 162 163 165 169 170 178 183 210 211 214 215 216 217 225 226 227 228 229 230 231 233 234 236 238 240 242 244 247 249 250 252 256 257 259 260 261 263 264 265 266 269 284 315 317 319 324 325 326 327 329 333 334 340 341 343 346 347 348 349 354 359 360 362 363 364 368 370 371 374 376 378 379 380 382 389 390 391 392 393 396 397 398 399 400 401 402 405 406 407 408 411 412 413 414 415 416 417 418 419 420 421 422 423 424 426 427 428 429 430 431 432 433 434 436 437 438 439 441 442 443 445 446 447 449 450 451 452 453 454 455 456 458 459 462 463 465 466 467 469 471 472 473 474 475 477 479 481 482 483 484 485 486 487 488 489 490 491 492 493 496 499 500 501 502 503 504 505 506 507 508 509 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 528 529 530 531 532 533 534 535 536 537 539 540 543 544 545 546 547 548 551 552 553 554 555 556 557 558 559 560 562 563 565 566 567 568 569 570 571 572 575 576 577 578 579 580 581 582 583 584 585 641 644 645 646 648 651 653 654 655 656 658 659 660 661 662 663 664 665 666 667 668 671 672 674 680 684 685 686 689 691 694 697 698 699 700 701 703 707 709 710 711 712 719 723 731 733 747 759 760 761 762 763 771 791 809 810 849 871 884 885 933 947 1028 1291 1363 1379 1380 1381 1382 1383 1463 1488 1489 1490 1667 1760 1761 2007 2080 2082 2270 2271 2272 2295 2298 2988 3001 3113 3874 3909 3925 4334 4338 4340 4341 4342 4343 4344 4385 4387 4389 4568 4569 5280 5283 5284 5294 5295 5296 5297 5298 5299 5301 5302 5304 5580 5684 5725 5726 5841 7509 7698 7739 8109 8111 8377 9009 9016 9077 9139 9140 9250 9366 9368 9370 9373 9380 9415 9714 10047 10109 10232 10278 10308 10503 10511 10512 10513 10610 10767 10783 11008 21605 21739 21740 21741 21750 21768 21848 21872 21873 21881 21908 21935 21939 21940 22098 22100 22106 22108 22109 22114 22115 22116 22117 22118 22119 22120 22121 22125 22126 22127 22195 22940 22942 23332 23334 23335 23635 23781 23825 23832 23882 23886 23887 23888 23891 23892 23951 23953 23954 23955 23957 23958 23959 23960 23961 24139 24140 24141 24142 26215 26216 26219 26988 26989 27028 28757 28758 28759 28760 28769 29834 29847 29848 29873 29874 29889 29943 29958 29970 30020 30921 30925 30926 30933 30934 30950 30952 30981 30982 31562 32280 32283 32284 32285 32286 32315 32459 32460 32505 32561 32596 32703 32734 32735 32738]
2ifExists: false

3. 应用领域

3.1. 服务器性能监控

写一个程序，周期性的获取服务器的各项指标数据，存入数据库中，然后通过界面进行查询，方便排查故障。

Go语言实现发送短信验证码并登录

Fri, 17 Mar 2023 13:20:05 +0800

现在大多数app或wap都实现了通过手机号获取验证码进行验证登录，下面来看下用go来实现手机号发送短信验证码登录的过程，基于的框架是gin 。

首先是短信服务商的申请，比如腾讯云、阿里云、网易易盾等，腾讯云自己申请个微信公众号就行，然后申请相关的短信签名、和短信模板，腾讯有100条试用喔。

具体的代码实现

配置腾讯云短信服务的发送短信相关配置，具体可以参考腾讯云短信服务的api 文档，进行配置

1sms:
2  secret-key:  #秘钥，可在控制台查询
3  secret-id:  #秘钥id ,可在控制台查询
4  sms-sdk-app-id:  #应用id
5  Sign-name:  #申请的签名
6  template-id:  #模板id

go 这里采用的是viper进行加载配置，相关的加载配置代码如下

定义相关的配置结构体，并加载到整个项目的总的options 配置结构体中

 1// sms 发送短信的配置options
 2type SmsOptions struct {
 3 SecretKey   string `json:"secret-key,omitempty" mapstructure:"secret-key"`
 4 SecretId    string `json:"secret-id,omitempty" mapstructure:"secret-id"`
 5 SmsSdkAppId string `json:"sms-sdk-app-id,omitempty" mapstructure:"sms-sdk-app-id"`
 6 SignName    string `json:"sign-name,omitempty" mapstructure:"sign-name"`
 7 TemplateId  string `json:"template-id,omitempty" mapstructure:"template-id"`
 8}
 9
10func NewSmsOptions() *SmsOptions {
11 return &SmsOptions{
12  SecretKey:   "",
13  SecretId:    "",
14  SmsSdkAppId: "",
15  SignName:    "",
16  TemplateId:  "",
17 }
18}
19
20// 这为项目总的一个options配置，项目启动的时候会将yaml中的加载到option中
21type Options struct {
22 GenericServerRunOptions *genericoptions.ServerRunOptions `json:"server" mapstructure:"server"`
23 MySQLOptions *genericoptions.MySQLOptions `json:"mysql" mapstructure:"mysql"`
24 InsecuresServing *genericoptions.InsecureServerOptions `json:"insecure" mapstructure:"insecure"`
25 Log *logger.Options `json:"log" mapstructure:"log"`
26 RedisOptions *genericoptions.RedisOptions `json:"redis" mapstructure:"redis"`
27 SmsOptions *genericoptions.SmsOptions `json:"sms" mapstructure:"sms"`
28} 
29 
30func NewOptions() *Options  {
31 o:=Options{
32  GenericServerRunOptions: genericoptions.NewServerRunOptions(),
33  MySQLOptions: genericoptions.NewMySQLOptions(),
34  InsecuresServing: genericoptions.NewInsecureServerOptions(),
35  RedisOptions: genericoptions.NewRedisOptions(),
36  Log: logger.NewOptions(),
37  SmsOptions: genericoptions.NewSmsOptions(),
38 }
39 return &o
40}

viper加载配置的代码如下

 1func AddConfigToOptions(options *options.Options) error {
 2    viper.SetConfigName("config")
 3    viper.AddConfigPath("config/")
 4    viper.SetConfigType("yaml")
 5    err := viper.ReadInConfig()
 6    if err != nil {
 7        return err
 8    }
 9
10
11    optDecode := viper.DecodeHook(mapstructure.ComposeDecodeHookFunc(mapstructure.StringToTimeDurationHookFunc(), StringToByteSizeHookFunc()))
12
13
14    err = viper.Unmarshal(options, optDecode)
15    fmt.Println(options)
16    if err != nil {
17        return err
18    }
19    return nil
20}
21
22
23func StringToByteSizeHookFunc() mapstructure.DecodeHookFunc {
24    return func(f reflect.Type,
25    t reflect.Type, data interface{}) (interface{}, error) {
26        if f.Kind() != reflect.String {
27            return data, nil
28        }
29        if t != reflect.TypeOf(datasize.ByteSize(5)) {
30            return data, nil
31        }
32        raw := data.(string)
33        result := new(datasize.ByteSize)
34        result.UnmarshalText([]byte(raw))
35        return result.Bytes(), nil
36    }
37}

下面是发送验证码的实现

 1type SmsClient struct {
 2    Credential *common.Credential
 3    Region     string
 4    Cpf        *profile.ClientProfile
 5    Request    SmsRequest
 6}
 7
 8type Option func(*SmsClient)
 9
10func NewSmsClient(options ...func(client *SmsClient)) *SmsClient {
11    client := &SmsClient{
12        Region: "ap-guangzhou",
13        Cpf:    profile.NewClientProfile(),
14    }
15    for _, option := range options {
16        option(client)
17    }
18    return client
19
20}
21
22func WithRequest(request SmsRequest) Option {
23    return func(smsClient *SmsClient) {
24        smsClient.Request = request
25    }
26}
27
28func WithCredential(options options.SmsOptions) Option {
29    return func(smsClient *SmsClient) {
30        smsClient.Credential = common.NewCredential(options.SecretId, options.SecretKey)
31    }
32}
33func WithCpfReqMethod(method string) Option {
34    return func(smsClient *SmsClient) {
35        smsClient.Cpf.HttpProfile.ReqMethod = method
36    }
37}
38func WithCpfReqTimeout(timeout int) Option {
39    return func(smsClient *SmsClient) {
40        smsClient.Cpf.HttpProfile.ReqTimeout = timeout
41    }
42}
43func WithCpfSignMethod(method string) Option {
44    return func(smsClient *SmsClient) {
45        smsClient.Cpf.SignMethod = method
46    }
47}
48
49func (s *SmsClient) Send() bool {
50    sendClient, _ := sms.NewClient(s.Credential, s.Region, s.Cpf)
51    _, err := sendClient.SendSms(s.Request.request)
52    if _, ok := err.(*errors.TencentCloudSDKError); ok {
53        logger.Warnf("An API error has returned: %s", err)
54        return false
55    }
56
57    if err != nil {
58        logger.Warnf("发送短信失败:%s,requestId:%s", err)
59        return false
60    }
61    logger.Info("发送短信验证码成功")
62    return true
63}

定义发送的client,这里采用function option 的编程模式来初始化发送的client.和发送的request,request的代码如下

 1type SmsRequest struct {
 2    request *sms.SendSmsRequest
 3}
 4
 5func NewSmsRequest(options *options.SmsOptions, withOptions ...func(smsRequest *SmsRequest)) *SmsRequest {
 6    request := sms.NewSendSmsRequest()
 7
 8    request.SmsSdkAppId = &options.SmsSdkAppId
 9    request.SignName = &options.SignName
10    request.TemplateId = &options.TemplateId
11    smsRequest := &SmsRequest{request: request}
12    for _, option := range withOptions {
13        option(smsRequest)
14    }
15    return smsRequest
16
17}
18
19type RequestOption func(*SmsRequest)
20
21func WithPhoneNumberSet(phoneSet []string) RequestOption {
22    return func(smsRequest *SmsRequest) {
23        smsRequest.request.PhoneNumberSet = common.StringPtrs(phoneSet)
24    }
25}
26
27func WithTemplateParamSet(templateSet []string) RequestOption {
28    return func(smsRequest *SmsRequest) {
29        smsRequest.request.TemplateParamSet = common.StringPtrs(templateSet)
30    }
31}

创建发送验证码的控制层，发送成功，并将此处的电话号码和验证码保存到redis缓存中，用来登录时候的验证码有效性的校验

 1func (u *userService) SendPhoneCode(ctx context.Context, phone string) bool {
 2    // 获取配置参数
 3    smsSetting := global.TencenSmsSetting
 4    phoneSet := []string{phone}
 5    // 随机生成6位的验证码
 6    var randCode string = fmt.Sprintf("%06v", rand.New(rand.NewSource(time.Now().UnixNano())).Int31n(1000000))
 7    templateSet := []string{randCode, "60"}
 8    smsRequest := tencenSms.NewSmsRequest(smsSetting, tencenSms.WithPhoneNumberSet(phoneSet), tencenSms.WithTemplateParamSet(templateSet))
 9    smsClient := tencenSms.NewSmsClient(tencenSms.WithRequest(*smsRequest), tencenSms.WithCredential(*smsSetting))
10    go smsClient.Send()
11    // 将验证码和手机号保存到redis中
12    _ = u.cache.UserCaches().SetSendPhoneCodeCache(ctx, phone, randCode)
13    return true
14
15}

后面是通过手机验证码进行登录的流程

 1func (u *userService) LoginByPhoneCode(ctx context.Context, phone string, phoneCode string) (*model.User,error) {
 2    // 从缓存中获取该手机号对应的验证码是否匹配
 3    cacheCode, err :=u.cache.UserCaches().GetSendPhoneCodeFromCache(ctx,phone)
 4    if err != nil {
 5        return nil, errors.WithCode(code.ErrUserPhoneCodeExpire,err.Error())
 6    }
 7    if cacheCode!=phoneCode {
 8        return nil,errors.WithCode(code.ErrUserPhoneCodeMiss,"")
 9    }
10    return &model.User{
11        Nickname: "lala",
12    }, nil
13}

使用 channel 控制并发数量

Fri, 17 Mar 2023 12:37:57 +0800

1. 协程

goroutine 是轻量级线程，调度由 Go 运行时进行管理的。Go 语言的并发控制主要使用关键字 go 开启协程 goroutine。Go 协程（Goroutine）之间通过信道（channel）进行通信，简单的说就是多个协程之间通信的管道。信道可以防止多个协程访问共享内存时发生资源争抢的问题。语法格式：

1// 普通函数创建 goroutine
2go 函数名(参数列表)
3
4//匿名函数创建 goroutine
5go func(参数列表){
6    //函数体
7}(调用参数列表)

协程可以开启多少个？是否有限制呢？

 1func testRoutine() {
 2    var wg sync.WaitGroup
 3    for i := 0; i < math.MaxInt32; i++ {
 4        wg.Add(1)
 5        go func(i int) {
 6            defer wg.Done()
 7            fmt.Printf("并发数量：%d/n", i)
 8            time.Sleep(time.Second)
 9        }(i)
10    }
11    wg.Wait()
12}

以上代码开启了 math.MaxInt32个协程的并发，执行后可以看到结果直接 panic：“panic: too many concurrent operations on a single file or socket (max 1048575)”。整个并发操作超出了系统最大值。

2. 控制协程数量

sync 同步机制

使用 sync.WaitGroup 启动指定数量的协程 goroutine。

 1func testRoutine() {
 2    var wg = sync.WaitGroup{}
 3
 4    taskCount := 5 // 指定并发数量
 5    for i := 0; i < taskCount; i++ {
 6        wg.Add(1)
 7        go func(i int) {
 8            fmt.Println("go func ", i)
 9            wg.Done()
10        }(i)
11    }
12    wg.Wait()
13}

如果 taskcount 设置的很大超出了限制的，则其还是没有控制到并发数量。可以优化下设计，类似池的设计思想，通过允许最大连接数控制量，当超出了数量就需要等待释放，有空闲的连接的时候才可以继续执行。

 1func testRoutine() {
 2    task_chan := make(chan bool, 3) //100 为 channel长度
 3    wg := sync.WaitGroup{}
 4    defer close(task_chan)
 5    for i := 0; i < math.MaxInt; i++ {
 6        wg.Add(1)
 7        fmt.Println("go func ", i)
 8        task_chan <- true
 9        go func() {
10                <-task_chan
11                defer wg.Done()
12        }()
13    }
14
15    wg.Wait()
16}

创建缓冲区大小为 3 的 channel，在没有被接收的情况下，至多发送 3 个消息则被阻塞。通过 channel 控制每次并发的数量。
开启协程前，设置 task_chan <- true，若缓存区满了则阻塞
协程任务执行完成后就释放缓冲区
等待所有的并发都处理结束后则函数结束。其实可以不使用 sync.WaitGroup。因使用 channel 控制并发处理的任务数量可以不用使用等待并发处理结束。

3. 参考资料：

boilingfrog.github.io/2021/04/14/控制goroutine的数量/

GoCSV包：一个能将结构体和csv文件直接互转的工具

Fri, 17 Mar 2023 11:44:44 +0800

1. gocsv小档案

大家在开发中一定遇到过将数据导出成csv格式文件的需求。go标准库中的csv包是只能写入字符串类型的切片。而在go中一般都是以结构体为操作对象，若使用标准的csv包，就需要将结构体先转换成对应的字符串类型，再写入文件。那可不可以将结构体对象直接输出成csv格式内容呢？

今天给大家推荐的就是一个能将结构体和csv内容进行快速互转的工具包：gocsv

1. gocsv小档案

gocsv 小档案
star	1.5 k
used by	1.6k
contributors	80
作者	gocarina
功能简介	提供一个简单、高效地将csv内容和结构体进行互转的功能
项目地址	https://github.com/gocarina/gocsv
相关知识	reflect、结构体tag

1.1. gocsv的基本功能

gocsv包的最基本的作用就是能够方便的将csv内容转换到对应的结构体上，或者将结构体的内容快速的转换成csv格式（包括写入文件）。

1.2. gocsv.UnmarshalFile函数：csv内容转成结构体

假设文件中的内容如下：

1client_id,client_name,client_age
21,Jose,42
32,Daniel,26
43,Vincent,32

然后从文件中读取出内容，并直接转换到结构体Client上，如下：

 1package main
 2
 3import (
 4 "fmt"
 5 "os"
 6
 7 "github.com/gocarina/gocsv"
 8)
 9
10type NotUsed struct {
11 Name string
12}
13
14type Client struct { // Our example struct, you can use "-" to ignore a field
15 Id            string `csv:"client_id"`
16 Name          string `csv:"client_name"`
17 Age           string `csv:"client_age"`
18 NotUsedString string `csv:"-"`
19 NotUsedStruct NotUsed `csv:"-"` 
20}
21
22func main() {
23 clientsFile, err := os.OpenFile("clients.csv", os.O_RDWR|os.O_CREATE, os.ModePerm)
24 if err != nil {
25  panic(err)
26 }
27 defer clientsFile.Close()
28
29 clients := []*Client{}
30
31 if err := gocsv.UnmarshalFile(clientsFile, &clients); err != nil { // Load clients from file
32  panic(err)
33 }
34 for _, client := range clients {
35  fmt.Println("Hello", client.Name)
36 }
37}

1.3. gocsv.MarshalFile函数：结构体转成csv文件

 1package main
 2
 3import (
 4 "fmt"
 5 "os"
 6
 7 "github.com/gocarina/gocsv"
 8)
 9
10type NotUsed struct {
11 Name string
12}
13
14type Client struct { // Our example struct, you can use "-" to ignore a field
15 Id            string `csv:"client_id"`
16 Name          string `csv:"client_name"`
17 Age           string `csv:"client_age"`
18 NotUsedString string `csv:"-"`
19 NotUsedStruct NotUsed `csv:"-"` 
20}
21
22func main() {
23 clientsFile, err := os.OpenFile("clients.csv", os.O_RDWR|os.O_CREATE, os.ModePerm)
24 if err != nil {
25  panic(err)
26 }
27 defer clientsFile.Close()
28
29 clients := []*Client{}
30
31 clients = append(clients, &Client{Id: "12", Name: "John", Age: "21"}) // Add clients
32 clients = append(clients, &Client{Id: "13", Name: "Fred"})
33 clients = append(clients, &Client{Id: "14", Name: "James", Age: "32"})
34 clients = append(clients, &Client{Id: "15", Name: "Danny"})
35 
36 err = gocsv.MarshalFile(&clients, clientsFile) // Use this to save the CSV back to the file
37 if err != nil {
38  panic(err)
39 }
40
41}

1.4. 自定义类型转换器

gocsv包还可以给自定义的结构体类型定义csv和结构体的互转函数。只要自定义的类型实现如下接口即可：

1type TypeMarshaller interface {
2 MarshalCSV() (string, error)
3}
4
5// TypeUnmarshaller is implemented by any value that has an UnmarshalCSV method
6// This converter is used to convert a string to your value representation of that string
7type TypeUnmarshaller interface {
8 UnmarshalCSV(string) error
9}

或者将结构体转换成csv字符串时，需要实现如下接口：

1// MarshalText encodes the receiver into UTF-8-encoded text and returns the result.
2type TextMarshaler interface {
3 MarshalText() (text []byte, err error)
4}
5
6type TextUnmarshaler interface {
7 UnmarshalText(text []byte) error
8}

例如，我们定义了一个结构体DateTime，里面有一个time.Time类型的属性。并且DateTime类型实现了TypeMarshaller接口的MarshalCSV函数和TypeUnmarshaller接口的UnmarshalCSV函数。如下：

 1type DateTime struct {
 2 time.Time
 3}
 4
 5// Convert the internal date as CSV string
 6func (date *DateTime) MarshalCSV() (string, error) {
 7 return date.Time.Format("20060201"), nil
 8}
 9
10// You could also use the standard Stringer interface 
11func (date *DateTime) String() (string) {
12 return date.String() // Redundant, just for example
13}
14
15// Convert the CSV string as internal date
16func (date *DateTime) UnmarshalCSV(csv string) (err error) {
17 date.Time, err = time.Parse("20060201", csv)
18 return err
19}
20
21type Client struct { // Our example struct with a custom type (DateTime)
22 Id       string   `csv:"id"`
23 Name     string   `csv:"name"`
24 Employed DateTime `csv:"employed"`
25}
26
27func main() {
28
29 client := []Client{
30  {
31   Id: "001",
32   Name: "Go学堂",
33   Employed: DateTime{time.Now()},
34  },
35 }
36
37 csvContent, _ := gocsv.MarshalString(client)
38 fmt.Println("csv:", csvContent) //输出内容是 001,Go学堂,20231003
39}

当我们运行上述代码，最终的输出内容是：

1001,xzeu,20231003

最后的日期就是按DateTime的MarshalCSV函数格式输出的。

1.5. 自定义CSV的Reader/Writer

在开头处我们提到，csv文件中的分隔符默认是逗号。但也可以是其他字符。这就要求我们在读取或写入之前指定好内容的分隔号。那么就可以通过自定义的Reader/Writer来覆盖默认的Reader/Writer的选项。如下：

指定读取内容的分割符是 “|”

1gocsv.SetCSVReader(func(in io.Reader) gocsv.CSVReader {
2    r := csv.NewReader(in)
3 r.Comma = '|'
4    return r // Allows use pipe as delimiter
5})

指定写入的内容是用分割符 “|” 进行分割的

1gocsv.SetCSVWriter(func(out io.Writer) *gocsv.SafeCSVWriter {
2 writer := csv.NewWriter(out)
3    writer.Comma = '|'
4    return gocsv.NewSafeCSVWriter(writer)
5})

1.6. gocsv包的特点总结

结构体切片和csv内容互转。能够将结构体切片（或数组）直接输出成csv内容或输出到文件。反之亦然。
csv标签。其转换过程是通过结构体上的“csv”标签进行关联的。
csv标签对应csv内容表头。当结构体和csv格式互转时，结构体中的csv标签对应的就是csv表格的表头，结构体中的字段顺序对应的就是csv文件列的顺序。
底层依然是使用标准库中的csv。在写入csv文件时，底层实际上用的还是go标准库中的encoding/csv/Writer结构体的Write(row []string)方法。
自动将结构体字段的类型转换成字符串：大家看到标准csv包中的Write方法的入参是string类型的切片，而在要转换的结构体上的字段可以是各种类型。这里就是gocsv包中的一个特点：可以将字段中的非string类型转换成string类型，最终写入到csv文件中。
可自定义类型转换器。可以通过实现TypeMarshaller接口或TypeUnMarshaller接口对自定义类型的内容按对应的格式输出成csv内容。
可自定义CSV的Reader/Writer来覆盖默认参数。比如csv格式的内容默认使用逗号分隔内容。通过该功能我们可以指定使用其他分隔符的csv内容。比如使用"|“或”;“等。这里需要注意的是将csv文件的内容一定是解析到结构体类型的切片或数组中。同样，也只有是结构体类型的切片或数组才能直接写入到csv文件中。

Golang Gjson

Sat, 03 Dec 2022 23:35:17 +0800

1. 基本概述

相信使用过动态语言的人，都觉得解析JSON是很简单的，只需要简单的几行代码就可以拿到解析好的JSON对象。例如Python解析JSON如下所示

1import json
2jsonStr = '{"name": "Bob", "age": 18}'
3result = json.loads(jsonStr)
4print(result["name"])  "Bob"

而Golang语言中简单的数据结构可使用map[string]interface{}，但如果JSON嵌套格式太复杂，用这种方式特别容易绕晕，而如果预先定义struct结构体，用json.Unmarshal把数据解析到结构体中，取出对应的数据，代码量编写会增加许多。如下所示

 1type Student struct {
 2 Name    string  `json:"name"`
 3 Age     int `json:"age"`
 4}
 5
 6jsonData := []byte(`
 7{
 8    "name": "Bob",
 9    "age": 18
10}`)
11
12var student Student
13err := json.Unmarshal(jsonData, &student)
14if err != nil {
15 fmt.Println(err)
16}
17fmt.Println(student.Name)

经过对比，发现GoLang解析JSON有没有相对简单的方法呢，作为受众这么广的语言，肯定是有解决方法的，这里就介绍一下今天要隆重介绍的第三方包GJSON。

GJSON是一个Go包，它提供了一种快速，简单的方法来从JSON文档中获取值。它具有诸如单行检索，点符号路径，迭代和解析JSON行之类的功能。项目地址: https://github.com/tidwall/gjson

GJSON 获得JSON的值，比较简单，操作如下

 1package main
 2
 3import "github.com/tidwall/gjson"
 4
 5const json = `{"name":{"first":"Janet","last":"Prichard"},"age":47}`
 6
 7func main() {
 8 value := gjson.Get(json, "name.last")
 9 println(value.String())   Prichard
10}

经过对比，发现GJSON获得值的方式，相对简单许多。GJSON还支持简单的路径语法去获得值，具体使用方式下面会详细介绍

2. 安装

要使用GSON，首先需要安装Go然后执行如下go get命令

1go get -u github.com/tidwall/gjson

3. 使用方式

3.1. 路径语法

以下是路径语法的快速概述，有关更多完整信息，请查看GJSON语法。路径是一系列由点分隔的键。键可能包含特殊的通配符'*'和'？'。要访问数组值，请使用索引作为键。要获取数组中的元素数或访问子路径，请使用“＃”字符。点和通配符可以用'\'进行转义。

 1package main
 2
 3
 4import (
 5 "fmt"
 6 "github.com/tidwall/gjson"
 7)
 8
 9const json = `
10{
11  "name": {"first": "Tom", "last": "Anderson"},
12  "age":37,
13  "children": ["Sara","Alex","Jack"],
14  "fav.movie": "Deer Hunter",
15  "friends": [
16    {"first": "Dale", "last": "Murphy", "age": 44, "nets": ["ig", "fb", "tw"]},
17    {"first": "Roger", "last": "Craig", "age": 68, "nets": ["fb", "tw"]},
18    {"first": "Jane", "last": "Murphy", "age": 47, "nets": ["ig", "tw"]}
19  ]
20}
21`
22
23func main() {
24 // 得到一个值
25 value1 := gjson.Get(json, "age")
26 fmt.Println(value1) // 37
27 
28 value2 := gjson.Get(json, "name.last")
29 fmt.Println(value2) // Anderson
30
31 value3 := gjson.Get(json, "name.first")
32 fmt.Println(value3) // Tom
33
34 value4 := gjson.Get(json, "children")
35 fmt.Println(value4) // ["Sara","Alex","Jack"]
36
37 // children数组的总数(元素个数)
38 value5 := gjson.Get(json, "children.#")
39 fmt.Println(value5) // 3
40
41 // children数组的第二个元素
42 value6 := gjson.Get(json, "children.1")
43 fmt.Println(value6) // Alex
44
45 // *表示任意个字符（包括0个）
46 value7 := gjson.Get(json, "child*.2")
47 fmt.Println(value7) // Jack
48
49 // ?表示0个或1个字符
50 value8 := gjson.Get(json, "c?ildren.0")
51 fmt.Println(value8) // Sara
52
53 // \ 表示转义
54 value9 := gjson.Get(json, "fav\\.movie")
55 fmt.Println(value9) // Deer Hunter
56
57 value10 := gjson.Get(json, "friends.#.first")
58 fmt.Println(value10) // ["Dale","Roger","Jane"]
59
60 value11 := gjson.Get(json, "friends.1.last")
61 fmt.Println(value11) // Craig
62
63 /*
64 也可以使用#(...)查询数组中的第一个匹配项，或使用#(...)# 查找所有匹配项。
65 查询支持==，！=，<，<=，>，>= 比较运算符，以及支持％(类似)和!%(不类似)的简单模式匹配。
66 */
67
68 // 查找数组中的第一个匹配项
69 value12 := gjson.Get(json, `friends.#(last=="Murphy").first`)
70 fmt.Println(value12) // Dale
71
72 // 查找数组中的所有匹配项
73 value13 := gjson.Get(json, `friends.#(last=="Murphy")#.first`)
74 fmt.Println(value13) // ["Dale","Jane"]
75
76 // 查找friends数组中所有age大于45的last值
77 value14 := gjson.Get(json, `friends.#(age>45)#.last`)
78 fmt.Println(value14) // ["Craig","Murphy"]
79
80 // 查找friends数组中第一个first对应的值是以D开头的 last值
81 value15 := gjson.Get(json, `friends.#(first%"D*").last`)
82 fmt.Println(value15) // Murphy
83
84 // 查找friends数组中第一个first对应的值是不以D开头的 last值
85 value16 := gjson.Get(json, `friends.#(first!%"D*").last`)
86 fmt.Println(value16) // Craig
87
88 // 查找friends数组中nets数组值包含fb
89 value17 := gjson.Get(json, `friends.#(nets.#(=="fb"))#.first`)
90 fmt.Println(value17) // ["Dale","Roger"]
91
92}

3.2. 获取嵌套数组值

 1package main
 2
 3import (
 4 "fmt"
 5 "github.com/tidwall/gjson"
 6)
 7
 8const json  = `
 9{
10  "programmers": [
11    {
12      "firstName": "Janet",
13      "lastName": "McLaughlin",
14    }, {
15      "firstName": "Elliotte",
16      "lastName": "Hunter",
17    }, {
18      "firstName": "Jason",
19      "lastName": "Harold",
20    }
21  ]
22}
23`
24
25func main(){
26 // 获取嵌套数组值
27 result := gjson.Get(json, "programmers.#.lastName")
28 for _, name := range result.Array() {
29  println(name.String())   prints McLaughlin  Hunter  Harold
30 }
31 
32 // 查询数组中对象
33 name := gjson.Get(json, `programmers.#(lastName="Hunter").firstName`)
34 println(name.String())   prints "Elliotte"
35 
36 // 遍历对象或数组
37 result.ForEach(func(key, value gjson.Result) bool {
38  println(value.String())
39  return true  keep iterating
40 })

3.3. 简单的Parse和Get使用

以下三种写法会得到相同的结果

 1package main
 2
 3import (
 4 "fmt"
 5 "github.com/tidwall/gjson"
 6)
 7
 8const json = `{"name":{"first":"Janet","last":"Prichard"},"age":47}`
 9
10func main(){
11    value1 := gjson.Parse(json).Get("name").Get("last")
12 fmt.Println(value1)  Prichard
13 value2 := gjson.Get(json, "name").Get("last")
14 fmt.Println(value2)  Prichard
15 value3 := gjson.Get(json, "name.last")
16 fmt.Println(value3)   Prichard
17
18 // 检测值是否已经存在
19 value := gjson.Get(json, "name.last")
20 if !value.Exists() {
21  println("no last name")
22 } else {
23  println(value.String())   Prichard
24 }
25
26 // Or as one step
27 if gjson.Get(json, "name.last").Exists() {
28  println("has a last name")  has a last name
29 }
30 
31 // 验证是否为json
32 if !gjson.Valid(json) {
33  fmt.Println("invalid json")
34  return
35 }
36 value4 := gjson.Get(json, "name.last")
37 fmt.Println(value4)
38
39 // 将json字符串解码到map中
40 m, ok := gjson.Parse(json).Value().(map[string]interface{})
41 if !ok {
42  // not a map
43  fmt.Println("not map")
44 }
45 fmt.Println(m)  map[programmers:[map[firstName:Janet lastName:McLaughlin] map[firstName:Elliotte lastName:Hunter] map[firstName:Jason lastName:Harold]]]
46
47 // 一次获取多个值
48 results := gjson.GetMany(json, "name.first", "name.last", "age")
49 fmt.Println(results)  [Janet Prichard 47]
50}

3.4. 以字节方式工作

如果您的JSON包含在[]byte切片中，则存在GetBytes函数。这比Get(string(data)，path)更好

1var json []byte = ...
2result := gjson.GetBytes(json, path)

如果您使用的是gjson.GetBytes(json，path)函数，并且想要避免将result.Raw转换为[]byte，则可以使用以下模式：

1var json []byte = ...
2result := gjson.GetBytes(json, path)
3var raw []byte
4if result.Index > 0 {
5raw = json[result.Index:result.Index+len(result.Raw)]
6} else {
7raw = []byte(result.Raw)
8}

4. 性能

GJSON 和encoding/json,ffjson,EasyJSON, jsonparser和json-iterator 的性能测试

1BenchmarkGJSONGet-8                  3000000        372 ns/op          0 B/op         0 allocs/op
2BenchmarkGJSONUnmarshalMap-8          900000       4154 ns/op       1920 B/op        26 allocs/op
3BenchmarkJSONUnmarshalMap-8           600000       9019 ns/op       3048 B/op        69 allocs/op
4BenchmarkJSONDecoder-8                300000      14120 ns/op       4224 B/op       184 allocs/op
5BenchmarkFFJSONLexer-8               1500000       3111 ns/op        896 B/op         8 allocs/op
6BenchmarkEasyJSONLexer-8             3000000        887 ns/op        613 B/op         6 allocs/op
7BenchmarkJSONParserGet-8             3000000        499 ns/op         21 B/op         0 allocs/op
8BenchmarkJSONIterator-8              3000000        812 ns/op        544 B/op

JSON 数据使用如下

 1{
 2  "widget": {
 3    "debug": "on",
 4    "window": {
 5      "title": "Sample Konfabulator Widget",
 6      "name": "main_window",
 7      "width": 500,
 8      "height": 500
 9    },
10    "image": {
11      "src": "Images/Sun.png",
12      "hOffset": 250,
13      "vOffset": 250,
14      "alignment": "center"
15    },
16    "text": {
17      "data": "Click Here",
18      "size": 36,
19      "style": "bold",
20      "vOffset": 100,
21      "alignment": "center",
22      "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
23    }
24  }
25}

每个操作都通过以下搜索路径之一进行轮换：

widget.window.name
widget.image.hOffset
widget.text.onMouseUp

这些基准测试是基于MacBook Pro 15" 2.8 GHz Intel Core i7 和Go 1.8版本

本文翻译自GJSON的Readme文档，每个Demo都经过测试，有疑问可以反馈联系，另外GJSON通过对路径进行匹配，有兴趣的可以看一下JSONPATH相关文章：https://goessner.net/articles/JsonPath/

GO 语言实现设计模式

Tue, 22 Nov 2022 23:36:13 +0800

1. 前言

设计模式是针对软件设计中常见问题的工具箱，其中的工具就是各种经过实践验证的解决方案。即使你从未遇到过这些问题，了解模式仍然非常有用，因为它能指导你如何使用面向对象的设计原则来解决各种问题，提高开发效率，降低开发成本；本文囊括了GO语言实现的全部23种经典设计模式示例，每个示例都精心设计，力求符合模式结构，可作为日常编码参考，同时一些常用的设计模式融入了开发实践经验总结，帮助大家在平时工作中灵活运用。

本文共收录了 23 种设计模式，这些设计模式被分为三大类：创建型、结构型和行为型，分别包括内容如下：

创建型模式5个：

单例模式（Singleton）
抽象工厂模式（Abstract Factory）
建造者模式（Builder）
工厂模式（Factory）
原型模式（Prototype）

结构型模式7个：

适配器模式（Adapter）
桥接模式（Bridge）
装饰模式（Decorator）
组合模式（Composite）
外观模式（Facade）
享元模式（Flyweight）
代理模式（Proxy）。

行为型模式11个：

模版方法模式（Template Method）
命令模式（Command）
迭代器模式（Iterator）
观察者模式（Observer）
中介者模式（Mediator）
备忘录模式（Memento）
解释器模式（Interpreter）
状态模式（State）
策略模式（Strategy）
责任链模式（Chain of Responsibility）
访问者模式（Visitor）。

事实上，除了 GoF 的 23 个著名设计模式之外，还有很多别的设计模式，Wrapper 模式、DAO（Data Access Object）模式、MVC（Model-View-Control）模式等。设计模式的学习是一个艰苦漫长的过程，需要大量的实践、思考和总结，即便如此，我们首先要有这个学习的意识。

2. 责任链模式

2.1. 概念

责任链模式是一种行为设计模式，允许你将请求沿着处理者链进行发送。收到请求后，每个处理者均可对请求进行处理，或将其传递给链上的下个处理者。

该模式允许多个对象来对请求进行处理，而无需让发送者类与具体接收者类相耦合。链可在运行时由遵循标准处理者接口的任意处理者动态生成。

一般意义上的责任链模式是说，请求在链上流转时任何一个满足条件的节点处理完请求后就会停止流转并返回，不过还可以根据不同的业务情况做一些改进：

请求可以流经处理链的所有节点，不同节点会对请求做不同职责的处理；可以通过上下文参数保存请求对象及上游节点的处理结果，供下游节点依赖，并进一步处理；处理链可支持节点的异步处理，通过实现特定接口判断，是否需要异步处理；责任链对于请求处理节点可以设置停止标志位，不是异常，是一种满足业务流转的中断；责任链的拼接方式存在两种，一种是节点遍历，一个节点一个节点顺序执行；另一种是节点嵌套，内层节点嵌入在外层节点执行逻辑中，类似递归，或者“回”行结构；责任链的节点嵌套拼接方式多被称为拦截器链或者过滤器链，更易于实现业务流程的切面，比如监控业务执行时长，日志输出，权限校验等；

2.2. 示例

本示例模拟实现机场登记过程，第一步办理登机牌，第二步如果有行李，就办理托运，第三步核实身份，第四步安全检查，第五步完成登机；其中行李托运是可选的，其他步骤必选，必选步骤有任何不满足就终止登机；旅客对象作为请求参数上下文，每个步骤会根据旅客对象状态判断是否处理或流转下一个节点；

2.2.1. 登机过程

  1package chainofresponsibility
  2
  3import "fmt"
  4
  5// BoardingProcessor 登机过程中，各节点统一处理接口
  6type BoardingProcessor interface {
  7 SetNextProcessor(processor BoardingProcessor)
  8 ProcessFor(passenger *Passenger)
  9}
 10
 11// Passenger 旅客
 12type Passenger struct {
 13 name                  string // 姓名
 14 hasBoardingPass       bool   // 是否办理登机牌
 15 hasLuggage            bool   // 是否有行李需要托运
 16 isPassIdentityCheck   bool   // 是否通过身份校验
 17 isPassSecurityCheck   bool   // 是否通过安检
 18 isCompleteForBoarding bool   // 是否完成登机
 19}
 20
 21// baseBoardingProcessor 登机流程处理器基类
 22type baseBoardingProcessor struct {
 23 // nextProcessor 下一个登机处理流程
 24 nextProcessor BoardingProcessor
 25}
 26
 27// SetNextProcessor 基类中统一实现设置下一个处理器方法
 28func (b *baseBoardingProcessor) SetNextProcessor(processor BoardingProcessor) {
 29 b.nextProcessor = processor
 30}
 31
 32// ProcessFor 基类中统一实现下一个处理器流转
 33func (b *baseBoardingProcessor) ProcessFor(passenger *Passenger) {
 34 if b.nextProcessor != nil {
 35  b.nextProcessor.ProcessFor(passenger)
 36 }
 37}
 38
 39// boardingPassProcessor 办理登机牌处理器
 40type boardingPassProcessor struct {
 41 baseBoardingProcessor // 引用基类
 42}
 43
 44func (b *boardingPassProcessor) ProcessFor(passenger *Passenger) {
 45 if !passenger.hasBoardingPass {
 46  fmt.Printf("为旅客%s办理登机牌;\n", passenger.name)
 47  passenger.hasBoardingPass = true
 48 }
 49 // 成功办理登机牌后，进入下一个流程处理
 50 b.baseBoardingProcessor.ProcessFor(passenger)
 51}
 52
 53// luggageCheckInProcessor 托运行李处理器
 54type luggageCheckInProcessor struct {
 55 baseBoardingProcessor
 56}
 57
 58func (l *luggageCheckInProcessor) ProcessFor(passenger *Passenger) {
 59 if !passenger.hasBoardingPass {
 60  fmt.Printf("旅客%s未办理登机牌，不能托运行李;\n", passenger.name)
 61  return
 62 }
 63 if passenger.hasLuggage {
 64  fmt.Printf("为旅客%s办理行李托运;\n", passenger.name)
 65 }
 66 l.baseBoardingProcessor.ProcessFor(passenger)
 67}
 68
 69// identityCheckProcessor 校验身份处理器
 70type identityCheckProcessor struct {
 71 baseBoardingProcessor
 72}
 73
 74func (i *identityCheckProcessor) ProcessFor(passenger *Passenger) {
 75 if !passenger.hasBoardingPass {
 76  fmt.Printf("旅客%s未办理登机牌，不能办理身份校验;\n", passenger.name)
 77  return
 78 }
 79 if !passenger.isPassIdentityCheck {
 80  fmt.Printf("为旅客%s核实身份信息;\n", passenger.name)
 81  passenger.isPassIdentityCheck = true
 82 }
 83 i.baseBoardingProcessor.ProcessFor(passenger)
 84}
 85
 86// securityCheckProcessor 安检处理器
 87type securityCheckProcessor struct {
 88 baseBoardingProcessor
 89}
 90
 91func (s *securityCheckProcessor) ProcessFor(passenger *Passenger) {
 92 if !passenger.hasBoardingPass {
 93  fmt.Printf("旅客%s未办理登机牌，不能进行安检;\n", passenger.name)
 94  return
 95 }
 96 if !passenger.isPassSecurityCheck {
 97  fmt.Printf("为旅客%s进行安检;\n", passenger.name)
 98  passenger.isPassSecurityCheck = true
 99 }
100 s.baseBoardingProcessor.ProcessFor(passenger)
101}
102
103// completeBoardingProcessor 完成登机处理器
104type completeBoardingProcessor struct {
105 baseBoardingProcessor
106}
107
108func (c *completeBoardingProcessor) ProcessFor(passenger *Passenger) {
109 if !passenger.hasBoardingPass ||
110  !passenger.isPassIdentityCheck ||
111  !passenger.isPassSecurityCheck {
112  fmt.Printf("旅客%s登机检查过程未完成，不能登机;\n", passenger.name)
113  return
114 }
115 passenger.isCompleteForBoarding = true
116 fmt.Printf("旅客%s成功登机;\n", passenger.name)
117}

2.2.2. 测试程序

 1package chainofresponsibility
 2
 3import "testing"
 4
 5func TestChainOfResponsibility(t *testing.T) {
 6 boardingProcessor := BuildBoardingProcessorChain()
 7 passenger := &Passenger{
 8  name:                  "李四",
 9  hasBoardingPass:       false,
10  hasLuggage:            true,
11  isPassIdentityCheck:   false,
12  isPassSecurityCheck:   false,
13  isCompleteForBoarding: false,
14 }
15 boardingProcessor.ProcessFor(passenger)
16}
17
18// BuildBoardingProcessorChain 构建登机流程处理链
19func BuildBoardingProcessorChain() BoardingProcessor {
20 completeBoardingNode := &completeBoardingProcessor{}
21
22 securityCheckNode := &securityCheckProcessor{}
23 securityCheckNode.SetNextProcessor(completeBoardingNode)
24
25 identityCheckNode := &identityCheckProcessor{}
26 identityCheckNode.SetNextProcessor(securityCheckNode)
27
28 luggageCheckInNode := &luggageCheckInProcessor{}
29 luggageCheckInNode.SetNextProcessor(identityCheckNode)
30
31 boardingPassNode := &boardingPassProcessor{}
32 boardingPassNode.SetNextProcessor(luggageCheckInNode)
33 return boardingPassNode
34}

2.2.3. 运行结果

1=== RUN   TestChainOfResponsibility
2为旅客李四办理登机牌;
3为旅客李四办理行李托运;
4为旅客李四核实身份信息;
5为旅客李四进行安检;
6旅客李四成功登机;
7--- PASS: TestChainOfResponsibility (0.00s)
8PASS

3. 命令模式

3.1. 概念

命令模式是一种行为设计模式，它可将请求转换为一个包含与请求相关的所有信息的独立对象。该转换让你能根据不同的请求将方法参数化、延迟请求执行或将其放入队列中，且能实现可撤销操作。

方法参数化是指将每个请求参数传入具体命令的工厂方法（go语言没有构造函数）创建命令，同时具体命令会默认设置好接受对象，这样做的好处是不管请求参数个数及类型，还是接受对象有几个，都会被封装到具体命令对象的成员字段上，并通过统一的Execute接口方法进行调用，屏蔽各个请求的差异，便于命令扩展，多命令组装，回滚等；

3.2. 示例

控制电饭煲做饭是一个典型的命令模式的场景，电饭煲的控制面板会提供设置煮粥、蒸饭模式，及开始和停止按钮，电饭煲控制系统会根据模式的不同设置相应的火力，压强及时间等参数；煮粥，蒸饭就相当于不同的命令，开始按钮就相当命令触发器，设置好做饭模式，点击开始按钮电饭煲就开始运行，同时还支持停止命令；

3.2.1. 电饭煲接收器

 1package command
 2
 3import "fmt"
 4
 5// ElectricCooker 电饭煲
 6type ElectricCooker struct {
 7 fire     string // 火力
 8 pressure string // 压力
 9}
10
11// SetFire 设置火力
12func (e *ElectricCooker) SetFire(fire string) {
13 e.fire = fire
14}
15
16// SetPressure 设置压力
17func (e *ElectricCooker) SetPressure(pressure string) {
18 e.pressure = pressure
19}
20
21// Run 持续运行指定时间
22func (e *ElectricCooker) Run(duration string) string {
23 return fmt.Sprintf("电饭煲设置火力为%s,压力为%s,持续运行%s;", e.fire, e.pressure, duration)
24}
25
26// Shutdown 停止
27func (e *ElectricCooker) Shutdown() string {
28 return "电饭煲停止运行。"
29}

3.2.2. 电饭煲命令

 1package command
 2
 3// CookCommand 做饭指令接口
 4type CookCommand interface {
 5 Execute() string // 指令执行方法
 6}
 7
 8// steamRiceCommand 蒸饭指令
 9type steamRiceCommand struct {
10 electricCooker *ElectricCooker // 电饭煲
11}
12
13func NewSteamRiceCommand(electricCooker *ElectricCooker) *steamRiceCommand {
14 return &steamRiceCommand{
15  electricCooker: electricCooker,
16 }
17}
18
19func (s *steamRiceCommand) Execute() string {
20 s.electricCooker.SetFire("中")
21 s.electricCooker.SetPressure("正常")
22 return "蒸饭:" + s.electricCooker.Run("30分钟")
23}
24
25// cookCongeeCommand 煮粥指令
26type cookCongeeCommand struct {
27 electricCooker *ElectricCooker
28}
29
30func NewCookCongeeCommand(electricCooker *ElectricCooker) *cookCongeeCommand {
31 return &cookCongeeCommand{
32  electricCooker: electricCooker,
33 }
34}
35
36func (c *cookCongeeCommand) Execute() string {
37 c.electricCooker.SetFire("大")
38 c.electricCooker.SetPressure("强")
39 return "煮粥:" + c.electricCooker.Run("45分钟")
40}
41
42// shutdownCommand 停止指令
43type shutdownCommand struct {
44 electricCooker *ElectricCooker
45}
46
47func NewShutdownCommand(electricCooker *ElectricCooker) *shutdownCommand {
48 return &shutdownCommand{
49  electricCooker: electricCooker,
50 }
51}
52
53func (s *shutdownCommand) Execute() string {
54 return s.electricCooker.Shutdown()
55}
56
57// ElectricCookerInvoker 电饭煲指令触发器
58type ElectricCookerInvoker struct {
59 cookCommand CookCommand
60}
61
62// SetCookCommand 设置指令
63func (e *ElectricCookerInvoker) SetCookCommand(cookCommand CookCommand) {
64 e.cookCommand = cookCommand
65}
66
67// ExecuteCookCommand 执行指令
68func (e *ElectricCookerInvoker) ExecuteCookCommand() string {
69 return e.cookCommand.Execute()
70}

3.2.3. 测试程序

 1package command
 2
 3import (
 4 "fmt"
 5 "testing"
 6)
 7
 8func TestCommand(t *testing.T) {
 9 // 创建电饭煲，命令接受者
10 electricCooker := new(ElectricCooker)
11 // 创建电饭煲指令触发器
12 electricCookerInvoker := new(ElectricCookerInvoker)
13
14 // 蒸饭
15 steamRiceCommand := NewSteamRiceCommand(electricCooker)
16 electricCookerInvoker.SetCookCommand(steamRiceCommand)
17 fmt.Println(electricCookerInvoker.ExecuteCookCommand())
18
19 // 煮粥
20 cookCongeeCommand := NewCookCongeeCommand(electricCooker)
21 electricCookerInvoker.SetCookCommand(cookCongeeCommand)
22 fmt.Println(electricCookerInvoker.ExecuteCookCommand())
23
24 // 停止
25 shutdownCommand := NewShutdownCommand(electricCooker)
26 electricCookerInvoker.SetCookCommand(shutdownCommand)
27 fmt.Println(electricCookerInvoker.ExecuteCookCommand())
28}

3.2.4. 运行结果

1=== RUN   TestCommand
2蒸饭:电饭煲设置火力为中,压力为正常,持续运行30分钟;
3煮粥:电饭煲设置火力为大,压力为强,持续运行45分钟;
4电饭煲停止运行。
5--- PASS: TestCommand (0.00s)
6PASS

4. 迭代器模式

4.1. 概念

迭代器模式是一种行为设计模式，让你能在不暴露集合底层表现形式（列表、栈和树等）的情况下遍历集合中所有的元素。

在迭代器的帮助下，客户端可以用一个迭代器接口以相似的方式遍历不同集合中的元素。

这里需要注意的是有两个典型的迭代器接口需要分清楚；一个是集合类实现的可以创建迭代器的工厂方法接口一般命名为Iterable，包含的方法类似CreateIterator；另一个是迭代器本身的接口，命名为Iterator，有Next及hasMore两个主要方法；

4.2. 示例

一个班级类中包括一个老师和若干个学生，我们要对班级所有成员进行遍历，班级中老师存储在单独的结构字段中，学生存储在另外一个slice字段中，通过迭代器，我们实现统一遍历处理；

4.2.1. 班级成员

  1package iterator
  2
  3import "fmt"
  4
  5// Member 成员接口
  6type Member interface {
  7 Desc() string // 输出成员描述信息
  8}
  9
 10// Teacher 老师
 11type Teacher struct {
 12 name    string // 名称
 13 subject string // 所教课程
 14}
 15
 16// NewTeacher 根据姓名、课程创建老师对象
 17func NewTeacher(name, subject string) *Teacher {
 18 return &Teacher{
 19  name:    name,
 20  subject: subject,
 21 }
 22}
 23
 24func (t *Teacher) Desc() string {
 25 return fmt.Sprintf("%s班主任老师负责教%s", t.name, t.subject)
 26}
 27
 28// Student 学生
 29type Student struct {
 30 name     string // 姓名
 31 sumScore int    // 考试总分数
 32}
 33
 34// NewStudent 创建学生对象
 35func NewStudent(name string, sumScore int) *Student {
 36 return &Student{
 37  name:     name,
 38  sumScore: sumScore,
 39 }
 40}
 41
 42func (t *Student) Desc() string {
 43 return fmt.Sprintf("%s同学考试总分为%d", t.name, t.sumScore)
 44}
 45班级成员迭代器
 46package iterator
 47
 48// Iterator 迭代器接口
 49type Iterator interface {
 50 Next() Member  // 迭代下一个成员
 51 HasMore() bool // 是否还有
 52}
 53
 54// memberIterator 班级成员迭代器实现
 55type memberIterator struct {
 56 class *Class // 需迭代的班级
 57 index int    // 迭代索引
 58}
 59
 60func (m *memberIterator) Next() Member {
 61 // 迭代索引为-1时，返回老师成员，否则遍历学生slice
 62 if m.index == -1 {
 63  m.index++
 64  return m.class.teacher
 65 }
 66 student := m.class.students[m.index]
 67 m.index++
 68 return student
 69}
 70
 71func (m *memberIterator) HasMore() bool {
 72 return m.index < len(m.class.students)
 73}
 74
 75// Iterable 可迭代集合接口，实现此接口返回迭代器
 76type Iterable interface {
 77 CreateIterator() Iterator
 78}
 79
 80// Class 班级，包括老师和同学
 81type Class struct {
 82 name     string
 83 teacher  *Teacher
 84 students []*Student
 85}
 86
 87// NewClass 根据班主任老师名称，授课创建班级
 88func NewClass(name, teacherName, teacherSubject string) *Class {
 89 return &Class{
 90  name:    name,
 91  teacher: NewTeacher(teacherName, teacherSubject),
 92 }
 93}
 94
 95// CreateIterator 创建班级迭代器
 96func (c *Class) CreateIterator() Iterator {
 97 return &memberIterator{
 98  class: c,
 99  index: -1, // 迭代索引初始化为-1，从老师开始迭代
100 }
101}
102
103func (c *Class) Name() string {
104 return c.name
105}
106
107// AddStudent 班级添加同学
108func (c *Class) AddStudent(students ...*Student) {
109 c.students = append(c.students, students...)
110}
111### 测试程序
112package iterator
113
114import (
115 "fmt"
116 "testing"
117)
118
119func TestIterator(t *testing.T) {
120 class := NewClass("三年级一班", "王明", "数学课")
121 class.AddStudent(NewStudent("张三", 389),
122  NewStudent("李四", 378),
123  NewStudent("王五", 347))
124
125 fmt.Printf("%s成员如下:\n", class.Name())
126 classIterator := class.CreateIterator()
127 for classIterator.HasMore() {
128  member := classIterator.Next()
129  fmt.Println(member.Desc())
130 }
131}

4.2.2. 运行结果

1=== RUN   TestIterator
2三年级一班成员如下:
3王明班主任老师负责教数学课
4张三同学考试总分为389
5李四同学考试总分为378
6王五同学考试总分为347
7--- PASS: TestIterator (0.00s)
8PASS

5. 中介者模式

5.1. 概念

中介者模式是一种行为设计模式，能让你减少对象之间混乱无序的依赖关系。该模式会限制对象之间的直接交互，迫使它们通过一个中介者对象进行合作，将网状依赖变为星状依赖。

中介者能使得程序更易于修改和扩展，而且能更方便地对独立的组件进行复用，因为它们不再依赖于很多其他的类。

中介者模式与观察者模式之间的区别是，中介者模式解决的是同类或者不同类的多个对象之间多对多的依赖关系，观察者模式解决的是多个对象与一个对象之间的多对一的依赖关系。

5.2. 示例

机场塔台调度系统是一个体现中介者模式的典型示例，假设是一个小机场，每次只能同时允许一架飞机起降，每架靠近机场的飞机需要先与塔台沟通是否可以降落，如果没有空闲的跑道，需要在天空盘旋等待，如果有飞机离港，等待的飞机会收到塔台的通知，按先后顺序降落；这种方式，免去多架飞机同时到达机场需要相互沟通降落顺序的复杂性，减少多个飞机间的依赖关系，简化业务逻辑，从而降低系统出问题的风险。

5.2.1. 飞机对象

 1package mediator
 2
 3import "fmt"
 4
 5// Aircraft 飞机接口
 6type Aircraft interface {
 7 ApproachAirport() // 抵达机场空域
 8 DepartAirport()   // 飞离机场
 9}
10
11// airliner 客机
12type airliner struct {
13 name            string          // 客机型号
14 airportMediator AirportMediator // 机场调度
15}
16
17// NewAirliner 根据指定型号及机场调度创建客机
18func NewAirliner(name string, mediator AirportMediator) *airliner {
19 return &airliner{
20  name:            name,
21  airportMediator: mediator,
22 }
23}
24
25func (a *airliner) ApproachAirport() {
26 if !a.airportMediator.CanLandAirport(a) { // 请求塔台是否可以降落
27  fmt.Printf("机场繁忙，客机%s继续等待降落;\n", a.name)
28  return
29 }
30 fmt.Printf("客机%s成功滑翔降落机场;\n", a.name)
31}
32
33func (a *airliner) DepartAirport() {
34 fmt.Printf("客机%s成功滑翔起飞，离开机场;\n", a.name)
35 a.airportMediator.NotifyWaitingAircraft() // 通知等待的其他飞机
36}
37
38// helicopter 直升机
39type helicopter struct {
40 name            string
41 airportMediator AirportMediator
42}
43
44// NewHelicopter 根据指定型号及机场调度创建直升机
45func NewHelicopter(name string, mediator AirportMediator) *helicopter {
46 return &helicopter{
47  name:            name,
48  airportMediator: mediator,
49 }
50}
51
52func (h *helicopter) ApproachAirport() {
53 if !h.airportMediator.CanLandAirport(h) { // 请求塔台是否可以降落
54  fmt.Printf("机场繁忙，直升机%s继续等待降落;\n", h.name)
55  return
56 }
57 fmt.Printf("直升机%s成功垂直降落机场;\n", h.name)
58}
59
60func (h *helicopter) DepartAirport() {
61 fmt.Printf("直升机%s成功垂直起飞，离开机场;\n", h.name)
62 h.airportMediator.NotifyWaitingAircraft() // 通知其他等待降落的飞机
63}

5.2.2. 机场塔台

 1package mediator
 2
 3// AirportMediator 机场调度中介者
 4type AirportMediator interface {
 5 CanLandAirport(aircraft Aircraft) bool // 确认是否可以降落
 6 NotifyWaitingAircraft()                // 通知等待降落的其他飞机
 7}
 8
 9// ApproachTower 机场塔台
10type ApproachTower struct {
11 hasFreeAirstrip bool
12 waitingQueue    []Aircraft // 等待降落的飞机队列
13}
14
15func (a *ApproachTower) CanLandAirport(aircraft Aircraft) bool {
16 if a.hasFreeAirstrip {
17  a.hasFreeAirstrip = false
18  return true
19 }
20 // 没有空余的跑道，加入等待队列
21 a.waitingQueue = append(a.waitingQueue, aircraft)
22 return false
23}
24
25func (a *ApproachTower) NotifyWaitingAircraft() {
26 if !a.hasFreeAirstrip {
27  a.hasFreeAirstrip = true
28 }
29 if len(a.waitingQueue) > 0 {
30  // 如果存在等待降落的飞机，通知第一个降落
31  first := a.waitingQueue[0]
32  a.waitingQueue = a.waitingQueue[1:]
33  first.ApproachAirport()
34 }
35}

5.2.3. 测试程序

 1package mediator
 2
 3import "testing"
 4
 5func TestMediator(t *testing.T) {
 6 // 创建机场调度塔台
 7 airportMediator := &ApproachTower{hasFreeAirstrip: true}
 8 // 创建C919客机
 9 c919Airliner := NewAirliner("C919", airportMediator)
10 // 创建米-26重型运输直升机
11 m26Helicopter := NewHelicopter("米-26", airportMediator)
12
13 c919Airliner.ApproachAirport()  // c919进港降落
14 m26Helicopter.ApproachAirport() // 米-26进港等待
15
16 c919Airliner.DepartAirport()  // c919飞离，等待的米-26进港降落
17 m26Helicopter.DepartAirport() // 最后米-26飞离
18}

5.2.4. 运行结果

1=== RUN   TestMediator
2客机C919成功滑翔降落机场;
3机场繁忙，直升机米-26继续等待降落;
4客机C919成功滑翔起飞，离开机场;
5直升机米-26成功垂直降落机场;
6直升机米-26成功垂直起飞，离开机场;
7--- PASS: TestMediator (0.00s)
8PASS

6. 备忘录模式

6.1. 概念

备忘录模式是一种行为设计模式，允许在不暴露对象实现细节的情况下保存和恢复对象之前的状态。

备忘录不会影响它所处理的对象的内部结构，也不会影响快照中保存的数据。

一般情况由原发对象保存生成的备忘录对象的状态不能被除原发对象之外的对象访问，所以通过内部类定义具体的备忘录对象是比较安全的，但是go语言不支持内部类定义的方式，因此go语言实现备忘录对象时，首先将备忘录保存的状态设为非导出字段，避免外部对象访问，其次将原发对象的引用保存到备忘录对象中，当通过备忘录对象恢复时，直接操作备忘录的恢复方法，将备份数据状态设置到原发对象中，完成恢复。

6.2. 示例

大家平时玩的角色扮演闯关游戏的存档机制就可以通过备忘录模式实现，每到一个关键关卡，玩家经常会先保存游戏存档，用于闯关失败后重置，存档会把角色状态及场景状态保存到备忘录中，同时将需要恢复游戏的引用存入备忘录，用于关卡重置；

6.2.1. 闯关游戏

  1package memento
  2
  3import "fmt"
  4
  5// Originator 备忘录模式原发器接口
  6type Originator interface {
  7 Save(tag string) Memento // 当前状态保存备忘录
  8}
  9
 10// RolesPlayGame 支持存档的RPG游戏
 11type RolesPlayGame struct {
 12 name          string   // 游戏名称
 13 rolesState    []string // 游戏角色状态
 14 scenarioState string   // 游戏场景状态
 15}
 16
 17// NewRolesPlayGame 根据游戏名称和角色名，创建RPG游戏
 18func NewRolesPlayGame(name string, roleName string) *RolesPlayGame {
 19 return &RolesPlayGame{
 20  name:          name,
 21  rolesState:    []string{roleName, "血量100"}, // 默认满血
 22  scenarioState: "开始通过第一关",                   // 默认第一关开始
 23 }
 24}
 25
 26// Save 保存RPG游戏角色状态及场景状态到指定标签归档
 27func (r *RolesPlayGame) Save(tag string) Memento {
 28 return newRPGArchive(tag, r.rolesState, r.scenarioState, r)
 29}
 30
 31func (r *RolesPlayGame) SetRolesState(rolesState []string) {
 32 r.rolesState = rolesState
 33}
 34
 35func (r *RolesPlayGame) SetScenarioState(scenarioState string) {
 36 r.scenarioState = scenarioState
 37}
 38
 39// String 输出RPG游戏简要信息
 40func (r *RolesPlayGame) String() string {
 41 return fmt.Sprintf("在%s游戏中，玩家使用%s,%s,%s;", r.name, r.rolesState[0], r.rolesState[1], r.scenarioState)
 42}
 43游戏存档
 44package memento
 45
 46import "fmt"
 47
 48// Memento 备忘录接口
 49type Memento interface {
 50 Tag() string // 备忘录标签
 51 Restore()    // 根据备忘录存储数据状态恢复原对象
 52}
 53
 54// rpgArchive rpg游戏存档，
 55type rpgArchive struct {
 56 tag           string         // 存档标签
 57 rolesState    []string       // 存档的角色状态
 58 scenarioState string         // 存档游戏场景状态
 59 rpg           *RolesPlayGame // rpg游戏引用
 60}
 61
 62// newRPGArchive 根据标签，角色状态，场景状态，rpg游戏引用，创建游戏归档备忘录
 63func newRPGArchive(tag string, rolesState []string, scenarioState string, rpg *RolesPlayGame) *rpgArchive {
 64 return &rpgArchive{
 65  tag:           tag,
 66  rolesState:    rolesState,
 67  scenarioState: scenarioState,
 68  rpg:           rpg,
 69 }
 70}
 71
 72func (r *rpgArchive) Tag() string {
 73 return r.tag
 74}
 75
 76// Restore 根据归档数据恢复游戏状态
 77func (r *rpgArchive) Restore() {
 78 r.rpg.SetRolesState(r.rolesState)
 79 r.rpg.SetScenarioState(r.scenarioState)
 80}
 81
 82// RPGArchiveManager RPG游戏归档管理器
 83type RPGArchiveManager struct {
 84 archives map[string]Memento // 存储归档标签对应归档
 85}
 86
 87func NewRPGArchiveManager() *RPGArchiveManager {
 88 return &RPGArchiveManager{
 89  archives: make(map[string]Memento),
 90 }
 91}
 92
 93// Reload 根据标签重新加载归档数据
 94func (r *RPGArchiveManager) Reload(tag string) {
 95 if archive, ok := r.archives[tag]; ok {
 96  fmt.Printf("重新加载%s;\n", tag)
 97  archive.Restore()
 98 }
 99}
100
101// Put 保存归档数据
102func (r *RPGArchiveManager) Put(memento Memento) {
103 r.archives[memento.Tag()] = memento
104}

6.2.2. 测试程序

 1package memento
 2
 3import (
 4 "fmt"
 5 "testing"
 6)
 7
 8func TestMemento(t *testing.T) {
 9 // 创建RPG游戏存档管理器
10 rpgManager := NewRPGArchiveManager()
11 // 创建RPG游戏
12 rpg := NewRolesPlayGame("暗黑破坏神2", "野蛮人战士")
13 fmt.Println(rpg)                  // 输出游戏当前状态
14 rpgManager.Put(rpg.Save("第一关存档")) // 游戏存档
15
16 // 第一关闯关失败
17 rpg.SetRolesState([]string{"野蛮人战士", "死亡"})
18 rpg.SetScenarioState("第一关闯关失败")
19 fmt.Println(rpg)
20
21 // 恢复存档，重新闯关
22 rpgManager.Reload("第一关存档")
23 fmt.Println(rpg)
24}

6.2.3. 运行结果

1=== RUN   TestMemento
2在暗黑破坏神2游戏中，玩家使用野蛮人战士,血量100,开始通过第一关;
3在暗黑破坏神2游戏中，玩家使用野蛮人战士,死亡,第一关闯关失败;
4重新加载第一关存档;
5在暗黑破坏神2游戏中，玩家使用野蛮人战士,血量100,开始通过第一关;
6--- PASS: TestMemento (0.00s)
7PASS

7. 观察者模式

7.1. 概念

观察者模式是一种行为设计模式，允许你定义一种订阅机制，可在对象事件发生时通知多个 “观察” 该对象的其他对象。

观察者模式提供了一种作用于任何实现了订阅者接口的对象的机制，可对其事件进行订阅和取消订阅。

观察者模式是最常用的模式之一，是事件总线，分布式消息中间件等各种事件机制的原始理论基础，常用于解耦多对一的对象依赖关系；

增强的实现功能包括：

当被观察者通过异步实现通知多个观察者时就相当于单进程实例的消息总线；同时还可以根据业务需要，将被观察者所有数据状态变更进行分类为不同的主题，观察者通过不同主题进行订阅；同一个主题又可分为增加，删除，修改事件行为；每个主题可以实现一个线程池，多个主题通过不同的线程池进行处理隔离，线程池可以设置并发线程大小、缓冲区大小及调度策略，比如先进先出，优先级等策略；观察者处理事件时有可能出现异常，所以也可以注册异常处理函数，异常处理也可以通过异常类型进行分类；根据业务需求也可以实现通知异常重试，延迟通知等功能；

7.2. 示例

信用卡业务消息提醒可通过观察者模式实现，业务消息包括日常消费，出账单，账单逾期，消息提醒包括短信、邮件及电话，根据不同业务的场景会采用不同的消息提醒方式或者多种消息提醒方式，这里信用卡相当于被观察者，观察者相当于不同的通知方式；日常消费通过短信通知，出账单通过邮件通知，账单逾期三种方式都会进行通知；

7.2.1. 通知方式

 1package observer
 2
 3import "fmt"
 4
 5// Subscriber 订阅者接口
 6type Subscriber interface {
 7 Name() string          //订阅者名称
 8 Update(message string) //订阅更新方法
 9}
10
11// shortMessage 信用卡消息短信订阅者
12type shortMessage struct{}
13
14func (s *shortMessage) Name() string {
15 return "手机短息"
16}
17
18func (s *shortMessage) Update(message string) {
19 fmt.Printf("通过【%s】发送消息:%s\n", s.Name(), message)
20}
21
22// email 信用卡消息邮箱订阅者
23type email struct{}
24
25func (e *email) Name() string {
26 return "电子邮件"
27}
28
29func (e *email) Update(message string) {
30 fmt.Printf("通过【%s】发送消息:%s\n", e.Name(), message)
31}
32
33// telephone 信用卡消息电话订阅者
34type telephone struct{}
35
36func (t *telephone) Name() string {
37 return "电话"
38}
39
40func (t *telephone) Update(message string) {
41 fmt.Printf("通过【%s】告知:%s\n", t.Name(), message)
42}

7.2.2. 信用卡业务

 1package observer
 2
 3import "fmt"
 4
 5// MsgType 信用卡消息类型
 6type MsgType int
 7
 8const (
 9 ConsumeType MsgType = iota // 消费消息类型
10 BillType                   // 账单消息类型
11 ExpireType                 // 逾期消息类型
12)
13
14// CreditCard 信用卡
15type CreditCard struct {
16 holder          string                   // 持卡人
17 consumeSum      float32                  // 消费总金额
18 subscriberGroup map[MsgType][]Subscriber // 根据消息类型分组订阅者
19}
20
21// NewCreditCard 指定持卡人创建信用卡
22func NewCreditCard(holder string) *CreditCard {
23 return &CreditCard{
24  holder:          holder,
25  subscriberGroup: make(map[MsgType][]Subscriber),
26 }
27}
28
29// Subscribe 支持订阅多种消息类型
30func (c *CreditCard) Subscribe(subscriber Subscriber, msgTypes ...MsgType) {
31 for _, msgType := range msgTypes {
32  c.subscriberGroup[msgType] = append(c.subscriberGroup[msgType], subscriber)
33 }
34}
35
36// Unsubscribe 解除订阅多种消息类型
37func (c *CreditCard) Unsubscribe(subscriber Subscriber, msgTypes ...MsgType) {
38 for _, msgType := range msgTypes {
39  if subs, ok := c.subscriberGroup[msgType]; ok {
40   c.subscriberGroup[msgType] = removeSubscriber(subs, subscriber)
41  }
42 }
43}
44
45func removeSubscriber(subscribers []Subscriber, toRemove Subscriber) []Subscriber {
46 length := len(subscribers)
47 for i, subscriber := range subscribers {
48  if toRemove.Name() == subscriber.Name() {
49   subscribers[length-1], subscribers[i] = subscribers[i], subscribers[length-1]
50   return subscribers[:length-1]
51  }
52 }
53 return subscribers
54}
55
56// Consume 信用卡消费
57func (c *CreditCard) Consume(money float32) {
58 c.consumeSum += money
59 c.notify(ConsumeType, fmt.Sprintf("尊敬的持卡人%s,您当前消费%.2f元;", c.holder, money))
60}
61
62// SendBill 发送信用卡账单
63func (c *CreditCard) SendBill() {
64 c.notify(BillType, fmt.Sprintf("尊敬的持卡人%s,您本月账单已出，消费总额%.2f元;", c.holder, c.consumeSum))
65}
66
67// Expire 逾期通知
68func (c *CreditCard) Expire() {
69 c.notify(ExpireType, fmt.Sprintf("尊敬的持卡人%s,您本月账单已逾期，请及时还款，总额%.2f元;", c.holder, c.consumeSum))
70}
71
72// notify 根据消息类型通知订阅者
73func (c *CreditCard) notify(msgType MsgType, message string) {
74 if subs, ok := c.subscriberGroup[msgType]; ok {
75  for _, sub := range subs {
76   sub.Update(message)
77  }
78 }
79}

7.2.3. 测试程序

 1package observer
 2
 3import "testing"
 4
 5func TestObserver(t *testing.T) {
 6 // 创建张三的信用卡
 7 creditCard := NewCreditCard("张三")
 8 // 短信通知订阅信用卡消费及逾期消息
 9 creditCard.Subscribe(new(shortMessage), ConsumeType, ExpireType)
10 // 电子邮件通知订阅信用卡账单及逾期消息
11 creditCard.Subscribe(new(email), BillType, ExpireType)
12 // 电话通知订阅信用卡逾期消息，同时逾期消息通过三种方式通知
13 creditCard.Subscribe(new(telephone), ExpireType)
14
15 creditCard.Consume(500.00) // 信用卡消费
16 creditCard.Consume(800.00) // 信用卡消费
17 creditCard.SendBill()      // 信用卡发送账单
18 creditCard.Expire()        // 信用卡逾期
19
20 // 信用卡逾期消息取消电子邮件及短信通知订阅
21 creditCard.Unsubscribe(new(email), ExpireType)
22 creditCard.Unsubscribe(new(shortMessage), ExpireType)
23 creditCard.Consume(300.00) // 信用卡消费
24 creditCard.Expire()        // 信用卡逾期
25}

7.2.4. 运行结果

 1=== RUN   TestObserver
 2通过【手机短息】发送消息:尊敬的持卡人张三,您当前消费500.00元;
 3通过【手机短息】发送消息:尊敬的持卡人张三,您当前消费800.00元;
 4通过【电子邮件】发送消息:尊敬的持卡人张三,您本月账单已出，消费总额1300.00元;
 5通过【手机短息】发送消息:尊敬的持卡人张三,您本月账单已逾期，请及时还款，总额1300.00元;
 6通过【电子邮件】发送消息:尊敬的持卡人张三,您本月账单已逾期，请及时还款，总额1300.00元;
 7通过【电话】告知:尊敬的持卡人张三,您本月账单已逾期，请及时还款，总额1300.00元;
 8通过【手机短息】发送消息:尊敬的持卡人张三,您当前消费300.00元;
 9通过【电话】告知:尊敬的持卡人张三,您本月账单已逾期，请及时还款，总额1600.00元;
10--- PASS: TestObserver (0.00s)
11PASS

8. 状态模式

8.1. 概念

状态模式是一种行为设计模式，让你能在一个对象的内部状态变化时改变其行为，使其看上去就像改变了自身所属的类一样。

该模式将与状态相关的行为抽取到独立的状态类中，让原对象将工作委派给这些类的实例，而不是自行进行处理。

状态迁移有四个元素组成，起始状态、触发迁移的事件，终止状态以及要执行的动作，每个具体的状态包含触发状态迁移的执行方法，迁移方法的实现是执行持有状态对象的动作方法，同时设置状态为下一个流转状态；持有状态的业务对象包含有触发状态迁移方法，这些迁移方法将请求委托给当前具体状态对象的迁移方法。

8.2. 示例

IPhone手机充电就是一个手机电池状态的流转，一开始手机处于有电状态，插入充电插头后，继续充电到满电状态，并进入断电保护，拔出充电插头后使用手机，由满电逐渐变为没电，最终关机；

状态迁移表：

起始状态	触发事件	终止状态	执行动作
有电	插入充电线	满电	充电
有电	拔出充电线	没电	耗电
满电	插入充电线	满电	停止充电
满电	拔出充电线	有电	耗电
没电	插入充电线	有电	充电
没电	拔出充电线	没电	关机

8.2.1. 电池状态

 1package state
 2
 3import "fmt"
 4
 5// BatteryState 电池状态接口，支持手机充电线插拔事件
 6type BatteryState interface {
 7 ConnectPlug(iPhone *IPhone) string
 8 DisconnectPlug(iPhone *IPhone) string
 9}
10
11// fullBatteryState 满电状态
12type fullBatteryState struct{}
13
14func (s *fullBatteryState) String() string {
15 return "满电状态"
16}
17
18func (s *fullBatteryState) ConnectPlug(iPhone *IPhone) string {
19 return iPhone.pauseCharge()
20}
21
22func (s *fullBatteryState) DisconnectPlug(iPhone *IPhone) string {
23 iPhone.SetBatteryState(PartBatteryState)
24 return fmt.Sprintf("%s,%s转为%s", iPhone.consume(), s, PartBatteryState)
25}
26
27// emptyBatteryState 空电状态
28type emptyBatteryState struct{}
29
30func (s *emptyBatteryState) String() string {
31 return "没电状态"
32}
33
34func (s *emptyBatteryState) ConnectPlug(iPhone *IPhone) string {
35 iPhone.SetBatteryState(PartBatteryState)
36 return fmt.Sprintf("%s,%s转为%s", iPhone.charge(), s, PartBatteryState)
37}
38
39func (s *emptyBatteryState) DisconnectPlug(iPhone *IPhone) string {
40 return iPhone.shutdown()
41}
42
43// partBatteryState 部分电状态
44type partBatteryState struct{}
45
46func (s *partBatteryState) String() string {
47 return "有电状态"
48}
49
50func (s *partBatteryState) ConnectPlug(iPhone *IPhone) string {
51 iPhone.SetBatteryState(FullBatteryState)
52 return fmt.Sprintf("%s,%s转为%s", iPhone.charge(), s, FullBatteryState)
53}
54
55func (s *partBatteryState) DisconnectPlug(iPhone *IPhone) string {
56 iPhone.SetBatteryState(EmptyBatteryState)
57 return fmt.Sprintf("%s,%s转为%s", iPhone.consume(), s, EmptyBatteryState)
58}

8.2.2. IPhone手机

 1package state
 2
 3import "fmt"
 4
 5// 电池状态单例，全局统一使用三个状态的单例，不需要重复创建
 6var (
 7 FullBatteryState  = new(fullBatteryState)  // 满电
 8 EmptyBatteryState = new(emptyBatteryState) // 空电
 9 PartBatteryState  = new(partBatteryState)  // 部分电
10)
11
12// IPhone 已手机充电为例，实现状态模式
13type IPhone struct {
14 model        string       // 手机型号
15 batteryState BatteryState // 电池状态
16}
17
18// NewIPhone 创建指定型号手机
19func NewIPhone(model string) *IPhone {
20 return &IPhone{
21  model:        model,
22  batteryState: PartBatteryState,
23 }
24}
25
26// BatteryState 输出电池当前状态
27func (i *IPhone) BatteryState() string {
28 return fmt.Sprintf("iPhone %s 当前为%s", i.model, i.batteryState)
29}
30
31// ConnectPlug 连接充电线
32func (i *IPhone) ConnectPlug() string {
33 return fmt.Sprintf("iPhone %s 连接电源线,%s", i.model, i.batteryState.ConnectPlug(i))
34}
35
36// DisconnectPlug 断开充电线
37func (i *IPhone) DisconnectPlug() string {
38 return fmt.Sprintf("iPhone %s 断开电源线,%s", i.model, i.batteryState.DisconnectPlug(i))
39}
40
41// SetBatteryState 设置电池状态
42func (i *IPhone) SetBatteryState(state BatteryState) {
43 i.batteryState = state
44}
45
46func (i *IPhone) charge() string {
47 return "正在充电"
48}
49
50func (i *IPhone) pauseCharge() string {
51 return "电已满,暂停充电"
52}
53
54func (i *IPhone) shutdown() string {
55 return "手机关闭"
56}
57
58func (i *IPhone) consume() string {
59 return "使用中,消耗电量"
60}

8.2.3. 测试程序

 1package state
 2
 3import (
 4 "fmt"
 5 "testing"
 6)
 7
 8func TestState(t *testing.T) {
 9 iPhone13Pro := NewIPhone("13 pro") // 刚创建的手机有部分电
10
11 fmt.Println(iPhone13Pro.BatteryState()) // 打印部分电状态
12 fmt.Println(iPhone13Pro.ConnectPlug())  // 插上电源插头，继续充满电
13 fmt.Println(iPhone13Pro.ConnectPlug())  // 满电后再充电，会触发满电保护
14
15 fmt.Println(iPhone13Pro.DisconnectPlug()) // 拔掉电源，使用手机消耗电量，变为有部分电
16 fmt.Println(iPhone13Pro.DisconnectPlug()) // 一直使用手机，直到没电
17 fmt.Println(iPhone13Pro.DisconnectPlug()) // 没电后会关机
18
19 fmt.Println(iPhone13Pro.ConnectPlug()) // 再次插上电源一会，变为有电状态
20}

8.2.4. 运行结果

 1=== RUN   TestState
 2iPhone 13 pro 当前为有电状态
 3iPhone 13 pro 连接电源线,正在充电,有电状态转为满电状态
 4iPhone 13 pro 连接电源线,电已满,暂停充电
 5iPhone 13 pro 断开电源线,使用中,消耗电量,满电状态转为有电状态
 6iPhone 13 pro 断开电源线,使用中,消耗电量,有电状态转为没电状态
 7iPhone 13 pro 断开电源线,手机关闭
 8iPhone 13 pro 连接电源线,正在充电,没电状态转为有电状态
 9--- PASS: TestState (0.00s)
10PASS

9. 策略模式

9.1. 概念

策略模式是一种行为设计模式，它能让你定义一系列算法，并将每种算法分别放入独立的类中，以使算法的对象能够相互替换。

原始对象被称为上下文，它包含指向策略对象的引用并将执行行为的任务分派给策略对象。为了改变上下文完成其工作的方式，其他对象可以使用另一个对象来替换当前链接的策略对象。

策略模式是最常用的设计模式，也是比较简单的设计模式，是以多态替换条件表达式重构方法的具体实现，是面向接口编程原则的最直接体现。

9.2. 示例

北京是一个四季分明的城市，每个季节天气情况都有明显特点；我们定义一个显示天气情况的季节接口，具体的四季实现，都会保存一个城市和天气情况的映射表，城市对象会包含季节接口，随着四季的变化，天气情况也随之变化。

9.2.1. 四季天气

 1package strategy
 2
 3import "fmt"
 4
 5// Season 季节的策略接口，不同季节表现得天气不同
 6type Season interface {
 7 ShowWeather(city string) string // 显示指定城市的天气情况
 8}
 9
10type spring struct {
11 weathers map[string]string // 存储不同城市春天气候
12}
13
14func NewSpring() *spring {
15 return &spring{
16  weathers: map[string]string{"北京": "干燥多风", "昆明": "清凉舒适"},
17 }
18}
19
20func (s *spring) ShowWeather(city string) string {
21 return fmt.Sprintf("%s的春天，%s;", city, s.weathers[city])
22}
23
24type summer struct {
25 weathers map[string]string // 存储不同城市夏天气候
26}
27
28func NewSummer() *summer {
29 return &summer{
30  weathers: map[string]string{"北京": "高温多雨", "昆明": "清凉舒适"},
31 }
32}
33
34func (s *summer) ShowWeather(city string) string {
35 return fmt.Sprintf("%s的夏天，%s;", city, s.weathers[city])
36}
37
38type autumn struct {
39 weathers map[string]string // 存储不同城市秋天气候
40}
41
42func NewAutumn() *autumn {
43 return &autumn{
44  weathers: map[string]string{"北京": "凉爽舒适", "昆明": "清凉舒适"},
45 }
46}
47
48func (a *autumn) ShowWeather(city string) string {
49 return fmt.Sprintf("%s的秋天，%s;", city, a.weathers[city])
50}
51
52type winter struct {
53 weathers map[string]string // 存储不同城市冬天气候
54}
55
56func NewWinter() *winter {
57 return &winter{
58  weathers: map[string]string{"北京": "干燥寒冷", "昆明": "清凉舒适"},
59 }
60}
61
62func (w *winter) ShowWeather(city string) string {
63 return fmt.Sprintf("%s的冬天，%s;", city, w.weathers[city])
64}

9.2.2. 城市气候

 1package strategy
 2
 3import (
 4 "fmt"
 5)
 6
 7// City 城市
 8type City struct {
 9 name    string
10 feature string
11 season  Season
12}
13
14// NewCity 根据名称及季候特征创建城市
15func NewCity(name, feature string) *City {
16 return &City{
17  name:    name,
18  feature: feature,
19 }
20}
21
22// SetSeason 设置不同季节，类似天气在不同季节的不同策略
23func (c *City) SetSeason(season Season) {
24 c.season = season
25}
26
27// String 显示城市的气候信息
28func (c *City) String() string {
29 return fmt.Sprintf("%s%s，%s", c.name, c.feature, c.season.ShowWeather(c.name))
30}

9.2.3. 测试程序

 1package strategy
 2
 3import (
 4 "fmt"
 5 "testing"
 6)
 7
 8func TestStrategy(t *testing.T) {
 9 Beijing := NewCity("北京", "四季分明")
10
11 Beijing.SetSeason(NewSpring())
12 fmt.Println(Beijing)
13
14 Beijing.SetSeason(NewSummer())
15 fmt.Println(Beijing)
16
17 Beijing.SetSeason(NewAutumn())
18 fmt.Println(Beijing)
19
20 Beijing.SetSeason(NewWinter())
21 fmt.Println(Beijing)
22}

9.2.4. 运行结果

1=== RUN   TestStrategy
2北京四季分明，北京的春天，干燥多风;
3北京四季分明，北京的夏天，高温多雨;
4北京四季分明，北京的秋天，凉爽舒适;
5北京四季分明，北京的冬天，干燥寒冷;
6--- PASS: TestStrategy (0.00s)
7PASS

10. 模板方法模式

10.1. 概念

模板方法模式是一种行为设计模式，它在超类中定义了一个算法的框架，允许子类在不修改结构的情况下重写算法的特定步骤。

由于GO语言没有继承的语法，模板方法又是依赖继承实现的设计模式，因此GO语言实现模板方法比较困难， GO语言支持隐式内嵌字段“继承”其他结构体的字段与方法，但是这个并不是真正意义上的继承语法，外层结构重写隐式字段中的算法特定步骤后，无法动态绑定到“继承”过来的算法的框架方法调用中，因此不能实现模板方法模式的语义。

10.2. 示例

本示例给出一种间接实现模板方法的方式，也比较符合模板方法模式的定义：

将多个算法特定步骤组合成一个接口；
基类隐式内嵌算法步骤接口，同时调用算法步骤接口的各方法，实现算法的模板方法，此时基类内嵌的算法步骤接口并没有真正的处理行为；
子类隐式内嵌基类，并覆写算法步骤接口的方法；
通过工厂方法创建具体子类，并将自己的引用赋值给基类中算法步骤接口字段。以演员装扮为例，演员的装扮是分为化妆，穿衣，配饰三步骤，三个步骤又根据不同角色的演员有所差别，因此演员基类实现装扮的模板方法，对于化妆，穿衣，配饰的三个步骤，在子类演员中具体实现，子类具体演员分为，男演员、女演员和儿童演员；

10.2.1. 演员基类

 1package templatemethod
 2
 3import (
 4 "bytes"
 5 "fmt"
 6)
 7
 8// IActor 演员接口
 9type IActor interface {
10 DressUp() string // 装扮
11}
12
13// dressBehavior 装扮的多个行为，这里多个行为是私有的，通过DressUp模版方法调用
14type dressBehavior interface {
15 makeUp() string // 化妆
16 clothe() string // 穿衣
17 wear() string   // 配饰
18}
19
20// BaseActor 演员基类
21type BaseActor struct {
22 roleName      string // 扮演角色
23 dressBehavior        // 装扮行为
24}
25
26// DressUp 统一实现演员接口的DressUp模版方法，装扮过程通过不同装扮行为进行扩展
27func (b *BaseActor) DressUp() string {
28 buf := bytes.Buffer{}
29 buf.WriteString(fmt.Sprintf("扮演%s的", b.roleName))
30 buf.WriteString(b.makeUp())
31 buf.WriteString(b.clothe())
32 buf.WriteString(b.wear())
33 return buf.String()
34}

10.2.2. 具体演员

 1package templatemethod
 2
 3// womanActor 扩展装扮行为的女演员
 4type womanActor struct {
 5 BaseActor
 6}
 7
 8// NewWomanActor 指定角色创建女演员
 9func NewWomanActor(roleName string) *womanActor {
10 actor := new(womanActor)    // 创建女演员
11 actor.roleName = roleName   // 设置角色
12 actor.dressBehavior = actor // 将女演员实现的扩展装扮行为，设置给自己的装扮行为接口
13 return actor
14}
15
16// 化妆
17func (w *womanActor) makeUp() string {
18 return "女演员涂着口红，画着眉毛；"
19}
20
21// 穿衣
22func (w *womanActor) clothe() string {
23 return "穿着连衣裙；"
24}
25
26// 配饰
27func (w *womanActor) wear() string {
28 return "带着耳环，手拎着包；"
29}
30
31// manActor 扩展装扮行为的男演员
32type manActor struct {
33 BaseActor
34}
35
36func NewManActor(roleName string) *manActor {
37 actor := new(manActor)
38 actor.roleName = roleName
39 actor.dressBehavior = actor // 将男演员实现的扩展装扮行为，设置给自己的装扮行为接口
40 return actor
41}
42
43func (m *manActor) makeUp() string {
44 return "男演员刮净胡子，抹上发胶；"
45}
46
47func (m *manActor) clothe() string {
48 return "穿着一身西装；"
49}
50
51func (m *manActor) wear() string {
52 return "带上手表，抽着烟；"
53}
54
55// NewChildActor 扩展装扮行为的儿童演员
56type childActor struct {
57 BaseActor
58}
59
60func NewChildActor(roleName string) *childActor {
61 actor := new(childActor)
62 actor.roleName = roleName
63 actor.dressBehavior = actor // 将儿童演员实现的扩展装扮行为，设置给自己的装扮行为接口
64 return actor
65}
66
67func (c *childActor) makeUp() string {
68 return "儿童演员抹上红脸蛋；"
69}
70
71func (c *childActor) clothe() string {
72 return "穿着一身童装；"
73}
74
75func (c *childActor) wear() string {
76 return "手里拿着一串糖葫芦；"
77}

10.2.3. 测试程序

 1package templatemethod
 2
 3import (
 4 "fmt"
 5 "testing"
 6)
 7
 8func TestTemplateMethod(t *testing.T) {
 9 showActors(NewWomanActor("妈妈"), NewManActor("爸爸"), NewChildActor("儿子"))
10}
11
12// showActors 显示演员的装扮信息
13func showActors(actors ...IActor) {
14 for _, actor := range actors {
15  fmt.Println(actor.DressUp())
16 }
17}

10.2.4. 运行结果

1=== RUN   TestTemplateMethod
2扮演妈妈的女演员涂着口红，画着眉毛；穿着连衣裙；带着耳环，手拎着包；
3扮演爸爸的男演员刮净胡子，抹上发胶；穿着一身西装；带上手表，抽着烟；
4扮演儿子的儿童演员抹上红脸蛋；穿着一身童装；手里拿着一串糖葫芦；
5--- PASS: TestTemplateMethod (0.00s)
6PASS

11. 访问者模式

11.1. 概念

访问者模式是一种行为设计模式，它能将算法与其所作用的对象隔离开来。允许你在不修改已有代码的情况下向已有类层次结构中增加新的行为。

访问者接口需要根据被访问者具体类，定义多个相似的访问方法，每个具体类对应一个访问方法；每个被访问者需要实现一个接受访问者对象的方法，方法的实现就是去调用访问者接口对应该类的访问方法；这个接受方法可以传入不同目的访问者接口的具体实现，从而在不修改被访问对象的前提下，增加新的功能；

11.2. 示例

公司中存在多种类型的员工，包括产品经理、软件工程师、人力资源等，他们的KPI指标不尽相同，产品经理为上线产品数量及满意度，软件工程师为实现的需求数及修改bug数，人力资源为招聘员工的数量；公司要根据员工完成的KPI进行表彰公示，同时根据KPI完成情况定薪酬，这些功能都是员工类职责之外的，不能修改员工本身的类，我们通过访问者模式，实现KPI表彰排名及薪酬发放；

11.2.1. 员工结构

 1package visitor
 2
 3import "fmt"
 4
 5// Employee 员工接口
 6type Employee interface {
 7 KPI() string                    // 完成kpi信息
 8 Accept(visitor EmployeeVisitor) // 接受访问者对象
 9}
10
11// productManager 产品经理
12type productManager struct {
13 name         string // 名称
14 productNum   int    // 上线产品数
15 satisfaction int    // 平均满意度
16}
17
18func NewProductManager(name string, productNum int, satisfaction int) *productManager {
19 return &productManager{
20  name:         name,
21  productNum:   productNum,
22  satisfaction: satisfaction,
23 }
24}
25
26func (p *productManager) KPI() string {
27 return fmt.Sprintf("产品经理%s，上线%d个产品，平均满意度为%d", p.name, p.productNum, p.satisfaction)
28}
29
30func (p *productManager) Accept(visitor EmployeeVisitor) {
31 visitor.VisitProductManager(p)
32}
33
34// softwareEngineer 软件工程师
35type softwareEngineer struct {
36 name           string // 姓名
37 requirementNum int    // 完成需求数
38 bugNum         int    // 修复问题数
39}
40
41func NewSoftwareEngineer(name string, requirementNum int, bugNum int) *softwareEngineer {
42 return &softwareEngineer{
43  name:           name,
44  requirementNum: requirementNum,
45  bugNum:         bugNum,
46 }
47}
48
49func (s *softwareEngineer) KPI() string {
50 return fmt.Sprintf("软件工程师%s，完成%d个需求，修复%d个问题", s.name, s.requirementNum, s.bugNum)
51}
52
53func (s *softwareEngineer) Accept(visitor EmployeeVisitor) {
54 visitor.VisitSoftwareEngineer(s)
55}
56
57// hr 人力资源
58type hr struct {
59 name       string // 姓名
60 recruitNum int    // 招聘人数
61}
62
63func NewHR(name string, recruitNum int) *hr {
64 return &hr{
65  name:       name,
66  recruitNum: recruitNum,
67 }
68}
69
70func (h *hr) KPI() string {
71 return fmt.Sprintf("人力资源%s，招聘%d名员工", h.name, h.recruitNum)
72}
73
74func (h *hr) Accept(visitor EmployeeVisitor) {
75 visitor.VisitHR(h)
76}

11.2.2. 员工访问者

 1package visitor
 2
 3import (
 4 "fmt"
 5 "sort"
 6)
 7
 8// EmployeeVisitor 员工访问者接口
 9type EmployeeVisitor interface {
10 VisitProductManager(pm *productManager)     // 访问产品经理
11 VisitSoftwareEngineer(se *softwareEngineer) // 访问软件工程师
12 VisitHR(hr *hr)                             // 访问人力资源
13}
14
15// kpi kpi对象
16type kpi struct {
17 name string // 完成kpi姓名
18 sum  int    // 完成kpi总数量
19}
20
21// kpiTopVisitor 员工kpi排名访问者
22type kpiTopVisitor struct {
23 top []*kpi
24}
25
26func (k *kpiTopVisitor) VisitProductManager(pm *productManager) {
27 k.top = append(k.top, &kpi{
28  name: pm.name,
29  sum:  pm.productNum + pm.satisfaction,
30 })
31}
32
33func (k *kpiTopVisitor) VisitSoftwareEngineer(se *softwareEngineer) {
34 k.top = append(k.top, &kpi{
35  name: se.name,
36  sum:  se.requirementNum + se.bugNum,
37 })
38}
39
40func (k *kpiTopVisitor) VisitHR(hr *hr) {
41 k.top = append(k.top, &kpi{
42  name: hr.name,
43  sum:  hr.recruitNum,
44 })
45}
46
47// Publish 发布KPI排行榜
48func (k *kpiTopVisitor) Publish() {
49 sort.Slice(k.top, func(i, j int) bool {
50  return k.top[i].sum > k.top[j].sum
51 })
52 for i, curKPI := range k.top {
53  fmt.Printf("第%d名%s：完成KPI总数%d\n", i+1, curKPI.name, curKPI.sum)
54 }
55}
56
57// salaryVisitor 薪酬访问者
58type salaryVisitor struct{}
59
60func (s *salaryVisitor) VisitProductManager(pm *productManager) {
61 fmt.Printf("产品经理基本薪资：1000元，KPI单位薪资：100元，")
62 fmt.Printf("%s，总工资为%d元\n", pm.KPI(), (pm.productNum+pm.satisfaction)*100+1000)
63}
64
65func (s *salaryVisitor) VisitSoftwareEngineer(se *softwareEngineer) {
66 fmt.Printf("软件工程师基本薪资：1500元，KPI单位薪资：80元，")
67 fmt.Printf("%s，总工资为%d元\n", se.KPI(), (se.requirementNum+se.bugNum)*80+1500)
68}
69
70func (s *salaryVisitor) VisitHR(hr *hr) {
71 fmt.Printf("人力资源基本薪资：800元，KPI单位薪资：120元，")
72 fmt.Printf("%s，总工资为%d元\n", hr.KPI(), hr.recruitNum*120+800)
73}

11.2.3. 测试程序

 1package visitor
 2
 3import "testing"
 4
 5func TestVisitor(t *testing.T) {
 6 allEmployees := AllEmployees() // 获取所有员工
 7 kpiTop := new(kpiTopVisitor)   // 创建KPI排行访问者
 8 VisitAllEmployees(kpiTop, allEmployees)
 9 kpiTop.Publish() // 发布排行榜
10
11 salary := new(salaryVisitor) // 创建薪酬访问者
12 VisitAllEmployees(salary, allEmployees)
13}
14
15// VisitAllEmployees 遍历所有员工调用访问者
16func VisitAllEmployees(visitor EmployeeVisitor, allEmployees []Employee) {
17 for _, employee := range allEmployees {
18  employee.Accept(visitor)
19 }
20}
21
22// AllEmployees 获得所有公司员工
23func AllEmployees() []Employee {
24 var employees []Employee
25 employees = append(employees, NewHR("小明", 10))
26 employees = append(employees, NewProductManager("小红", 4, 7))
27 employees = append(employees, NewSoftwareEngineer("张三", 10, 5))
28 employees = append(employees, NewSoftwareEngineer("李四", 3, 6))
29 employees = append(employees, NewSoftwareEngineer("王五", 7, 1))
30 return employees
31}

11.2.4. 运行结果

 1=== RUN   TestVisitor
 2第1名张三：完成KPI总数15
 3第2名小红：完成KPI总数11
 4第3名小明：完成KPI总数10
 5第4名李四：完成KPI总数9
 6第5名王五：完成KPI总数8
 7人力资源基本薪资：800元，KPI单位薪资：120元，人力资源小明，招聘10名员工，总工资为2000元
 8产品经理基本薪资：1000元，KPI单位薪资：100元，产品经理小红，上线4个产品，平均满意度为7，总工资为2100元
 9软件工程师基本薪资：1500元，KPI单位薪资：80元，软件工程师张三，完成10个需求，修复5个问题，总工资为2700元
10软件工程师基本薪资：1500元，KPI单位薪资：80元，软件工程师李四，完成3个需求，修复6个问题，总工资为2220元
11软件工程师基本薪资：1500元，KPI单位薪资：80元，软件工程师王五，完成7个需求，修复1个问题，总工资为2140元
12--- PASS: TestVisitor (0.00s)
13PASS

12. 解释器模式

12.1. 概念

解释器模式是一种行为型模式。

解释器模式用于描述如何使用面向对象语言构成一个简单的语言解释器。在某些情况下，为了更好地描述某一些特定类型的问题，我们可以创建一种新的语言，这种语言拥有自己的表达式和结构，即文法规则，这些问题的实例将对应为该语言中的句子。此时，可以使用解释器模式来设计这种新的语言。对解释器模式的学习能够加深我们对面向对象思想的理解，并且掌握编程语言中文法规则的解释过程。

12.2. 示例

定义一个解析特征值的语句解释器，提供是否包含特征值的终结表达式，并提供或表达式与且表达式，同时，生成南极洲特征判断表达式，及美国人特征判断表达式，最后测试程序根据对象特征值描述，通过表达式判断是否为真。

12.2.1. 特征值解释器

 1package interpreter
 2
 3import "strings"
 4
 5// Expression 表达式接口，包含一个解释方法
 6type Expression interface {
 7 Interpret(context string) bool
 8}
 9
10// terminalExpression 终结符表达式，判断表达式中是否包含匹配数据
11type terminalExpression struct {
12 matchData string
13}
14
15func NewTerminalExpression(matchData string) *terminalExpression {
16 return &terminalExpression{matchData: matchData}
17}
18
19// Interpret 判断是否包含匹配字符
20func (t *terminalExpression) Interpret(context string) bool {
21 if strings.Contains(context, t.matchData) {
22  return true
23 }
24 return false
25}
26
27// orExpression 或表达式
28type orExpression struct {
29 left, right Expression
30}
31
32func NewOrExpression(left, right Expression) *orExpression {
33 return &orExpression{
34  left:  left,
35  right: right,
36 }
37}
38
39func (o *orExpression) Interpret(context string) bool {
40 return o.left.Interpret(context) || o.right.Interpret(context)
41}
42
43// andExpression 与表达式
44type andExpression struct {
45 left, right Expression
46}
47
48func NewAndExpression(left, right Expression) *andExpression {
49 return &andExpression{
50  left:  left,
51  right: right,
52 }
53}
54
55func (o *andExpression) Interpret(context string) bool {
56 return o.left.Interpret(context) && o.right.Interpret(context)
57}

12.2.2. 测试程序

 1package interpreter
 2
 3import (
 4 "fmt"
 5 "testing"
 6)
 7
 8func TestInterpreter(t *testing.T) {
 9 isAntarcticaExpression := generateCheckAntarcticaExpression()
10 // 大洲描述1
11 continentDescription1 := "此大洲生活着大量企鹅，全年低温，并且伴随着有暴风雪"
12 fmt.Printf("%s，是否是南极洲？%t\n", continentDescription1, isAntarcticaExpression.Interpret(continentDescription1))
13 // 大洲描述2
14 continentDescription2 := "此大洲生活着狮子，全年高温多雨"
15 fmt.Printf("%s，是否是南极洲？%t\n", continentDescription2, isAntarcticaExpression.Interpret(continentDescription2))
16
17 isAmericanExpression := generateCheckAmericanExpression()
18 peopleDescription1 := "此人生活在北美洲的黑人，说着英语，持有美国绿卡"
19 fmt.Printf("%s，是否是美国人？%t\n", peopleDescription1, isAmericanExpression.Interpret(peopleDescription1))
20
21 peopleDescription2 := "此人生活在欧洲，说着英语，是欧洲议会议员"
22 fmt.Printf("%s，是否是南极洲？%t\n", peopleDescription2, isAmericanExpression.Interpret(peopleDescription2))
23
24}
25
26// generateCheckAntarcticaExpression 生成校验是否是南极洲表达式
27func generateCheckAntarcticaExpression() Expression {
28 // 判断南极洲的动物，或关系
29 animalExpression := NewOrExpression(NewTerminalExpression("企鹅"),
30  NewTerminalExpression("蓝鲸"))
31 // 判断南极洲的天气，与关系
32 weatherExpression := NewAndExpression(NewTerminalExpression("低温"),
33  NewTerminalExpression("暴风雪"))
34 // 最终返回动物与天气的与关系
35 return NewAndExpression(animalExpression, weatherExpression)
36}
37
38// generateCheckAmericanExpression 生成检查美国人表达式
39func generateCheckAmericanExpression() Expression {
40 // 人种判断，或关系
41 raceExpression := NewOrExpression(NewTerminalExpression("白人"),
42  NewTerminalExpression("黑人"))
43 // 生活方式，与关系
44 lifeStyleExpression := NewAndExpression(NewTerminalExpression("英语"),
45  NewTerminalExpression("北美洲"))
46 // 身份，与关系
47 identityExpression := NewAndExpression(lifeStyleExpression, NewTerminalExpression("美国绿卡"))
48 return NewAndExpression(raceExpression, identityExpression)
49}

12.2.3. 运行结果

1=== RUN   TestInterpreter
2此大洲生活着大量企鹅，全年低温，并且伴随着有暴风雪，是否是南极洲？true
3此大洲生活着狮子，全年高温多雨，是否是南极洲？false
4此人生活在北美洲的黑人，说着英语，持有美国绿卡，是否是美国人？true
5此人生活在欧洲，说着英语，是欧洲议会议员，是否是美国人？false
6--- PASS: TestInterpreter (0.00s)
7PASS

13. 适配器模式

13.1. 概念

适配器模式是一种结构型设计模式，它能使接口不兼容的对象能够相互合作。

适配器可担任两个对象间的封装器，它会接收对于一个对象的调用，并将其转换为另一个对象可识别的格式和接口。

13.2. 示例

通过充电宝给不同充电接口的手机充电是一个非常符合适配器模式特征的生活示例。一般充电宝提供 USB 电源输出接口，手机充电输入接口则分为两类，一是苹果手机的lightning接口，另一类是安卓手机的typeC接口。这两类接口都需要通过适配电源线连接充电宝的 USB 接口，这里 USB 接口就相当于充电宝的通用接口，lightning 或 typeC 接口要想充电需要通过充电线适配。

13.2.1. 手机充电插头

 1package adapter
 2
 3import "fmt"
 4
 5// HuaweiPlug 华为手机充电插槽接口
 6type HuaweiPlug interface {
 7  ConnectTypeC() string
 8}
 9
10// HuaweiPhone 华为系列手机
11type HuaweiPhone struct {
12  model string
13}
14
15// NewHuaweiPhone 华为手机创建方法
16func NewHuaweiPhone(model string) *HuaweiPhone {
17  return &HuaweiPhone{
18    model: model,
19  }
20}
21
22// ConnectTypeC 华为手机TypeC充电插槽
23func (h *HuaweiPhone) ConnectTypeC() string {
24  return fmt.Sprintf("%v connect typeC plug", h.model)
25}
26
27// ApplePlug 苹果手机充电插槽
28type ApplePlug interface {
29  ConnectLightning() string
30}
31
32// IPhone 苹果系列手机
33type IPhone struct {
34  model string
35}
36
37// NewIPhone 苹果手机创建方法
38func NewIPhone(model string) *IPhone {
39  return &IPhone{
40    model: model,
41  }
42}
43
44// ConnectLightning 苹果手机Lightning充电插槽
45func (i *IPhone) ConnectLightning() string {
46  return fmt.Sprintf("%v connect lightning plug", i.model)
47}

13.2.2. 充电宝适配器

 1package adapter
 2
 3import "fmt"
 4
 5
 6// CommonPlug 通用的USB电源插槽
 7type CommonPlug interface {
 8  ConnectUSB() string
 9}
10
11// HuaweiPhonePlugAdapter 华为TypeC充电插槽适配通用USB充电插槽
12type HuaweiPhonePlugAdapter struct {
13  huaweiPhone HuaweiPlug
14}
15
16// NewHuaweiPhonePlugAdapter 创建华为手机适配USB充电插槽适配器
17func NewHuaweiPhonePlugAdapter(huaweiPhone HuaweiPlug) *HuaweiPhonePlugAdapter {
18  return &HuaweiPhonePlugAdapter{
19    huaweiPhone: huaweiPhone,
20  }
21}
22
23// ConnectUSB 链接USB
24func (h *HuaweiPhonePlugAdapter) ConnectUSB() string {
25  return fmt.Sprintf("%v adapt to usb ", h.huaweiPhone.ConnectTypeC())
26}
27
28// ApplePhonePlugAdapter 苹果Lightning充电插槽适配通用USB充电插槽
29type ApplePhonePlugAdapter struct {
30  iPhone ApplePlug
31}
32
33// NewApplePhonePlugAdapter 创建苹果手机适配USB充电插槽适配器
34func NewApplePhonePlugAdapter(iPhone ApplePlug) *ApplePhonePlugAdapter {
35  return &ApplePhonePlugAdapter{
36    iPhone: iPhone,
37  }
38}
39
40// ConnectUSB 链接USB
41func (a *ApplePhonePlugAdapter) ConnectUSB() string {
42  return fmt.Sprintf("%v adapt to usb ", a.iPhone.ConnectLightning())
43}
44
45// PowerBank 充电宝
46type PowerBank struct {
47  brand string
48}
49
50// Charge 支持通用USB接口充电
51func (p *PowerBank) Charge(plug CommonPlug) string {
52  return fmt.Sprintf("%v power bank connect usb plug, start charge for %v", p.brand, plug.ConnectUSB())
53}

13.2.3. 测试程序

 1package adapter
 2
 3import (
 4  "fmt"
 5  "testing"
 6)
 7
 8func TestAdapter (t *testing.T) {
 9  huaweiMate40Pro := NewHuaweiPhone("华为 mate40 pro")
10  iphone13MaxPro := NewIPhone("苹果 iphone13 pro max")
11
12  powerBank := &PowerBank{"飞利浦"}
13  fmt.Println(powerBank.Charge(NewHuaweiPhonePlugAdapter(huaweiMate40Pro)))
14  fmt.Println(powerBank.Charge(NewApplePhonePlugAdapter(iphone13MaxPro)))
15}

13.2.4. 运行结果

1=== RUN   TestAdapter
2飞利浦 power bank connect usb plug, start charge for 华为 mate40 pro connect typeC plug adapt to usb 
3飞利浦 power bank connect usb plug, start charge for 苹果 iphone13 pro max connect lightning plug adapt to usb 
4--- PASS: TestAdapter (0.00s)
5PASS

14. 桥接模式

14.1. 概念

桥接是一种结构型设计模式，可将业务逻辑或一个大类拆分为不同的层次结构，从而能独立地进行开发。

层次结构中的第一层（通常称为抽象部分）将包含对第二层（实现部分）对象的引用。抽象部分将能将一些（有时是绝大部分）对自己的调用委派给实现部分的对象。所有的实现部分都有一个通用接口，因此它们能在抽象部分内部相互替换。

简单的说，一个事物存在多个维度的变化点，每一个维度都抽象出一个接口，事物引用这些接口实现整体行为逻辑，而每一个接口都可以存在多个变化的实现。

更简单的一句话：依赖接口编程。

14.2. 示例

对于一段经历的描述，经历就可能有多种实现，比如旅游经历，探险经历这相当于第一层次的类结构，同时描述旅游经历或探险经历又包含多个维度，比如如何到达目的地，在目的地开展了什么活动等，到达目的地有很多种方式，比如飞机、火车、汽车等；开展的活动又根据地点不同而不同，海边可以冲浪，山地可以攀岩，荒漠可以徒步穿越等；这两个维度的变化点对于描述经历来说相当于第二层次类实现，通过接口被第一层次引用。

这里对于经历描述存在三个维度的变化：

经历本身的两个实现：旅游经历与探险经历。
交通方式的两个实现：飞机和汽车。
开展活动的三个实现：冲浪、攀岩与徒步穿越。如果用一个类层次去实现就需要2∗2∗3=12个不同的实现类，如果用桥接模式仅需要2+2+3=7个不同的类，而且两种方式的加速度也不一样，比如增加一个交通方式火车，非桥接模式需要增加2∗3∗3−12=6个实现类，桥接模式2+3+3−7=1个实现类；桥接模式大大增加了类之间组合的灵活性。

14.2.1. 交通工具

 1package bridge
 2
 3// Traffic 交通工具
 4type Traffic interface {
 5   Transport() string
 6}
 7
 8// airplane 飞机
 9type airplane struct{}
10
11// Transport 坐飞机
12func (a *airplane) Transport() string {
13   return "by airplane"
14}
15
16// car 汽车
17type car struct{}
18
19// Transport 坐汽车
20func (t *car) Transport() string {
21   return "by car"
22}

14.2.2. 目的地

 1package bridge
 2
 3import "fmt"
 4
 5// Location 地点
 6type Location interface {
 7  Name() string // 地点名称
 8  PlaySports() string // 参与运动
 9}
10
11// namedLocation 被命名的地点，统一引用此类型，声明名字字段及获取方法
12type namedLocation struct {
13  name string
14}
15
16// Name 获取地点名称
17func (n namedLocation) Name() string {
18  return n.name
19}
20
21// seaside 海边
22type seaside struct {
23  namedLocation
24}
25
26// NewSeaside 创建指定名字的海边，比如三亚湾
27func NewSeaside(name string) *seaside {
28  return &seaside{
29    namedLocation: namedLocation{
30      name: name,
31    },
32  }
33}
34
35// PlaySports 海边可以冲浪
36func (s *seaside) PlaySports() string {
37  return fmt.Sprintf("surfing")
38}
39
40// mountain 山
41type mountain struct {
42  namedLocation
43}
44
45// NewMountain 创建指定名字的山，比如泰山
46func NewMountain(name string) *mountain {
47  return &mountain{
48    namedLocation: namedLocation{
49      name: name,
50    },
51  }
52}
53
54// PlaySports 可以爬山
55func (m *mountain) PlaySports() string {
56  return fmt.Sprintf("climbing")
57}
58
59// desert 荒漠
60type desert struct {
61  namedLocation
62}
63
64// NewDesert 创建指定名字的荒漠，比如罗布泊
65func NewDesert(name string) *desert {
66  return &desert{
67    namedLocation: namedLocation{
68      name: name,
69    },
70  }
71}
72
73// PlaySports 荒漠可以徒步穿越
74func (d *desert) PlaySports() string {
75  return fmt.Sprintf("trekking")
76}

14.2.3. 经历描述

 1package bridge
 2
 3import "fmt"
 4
 5// Experience 经历
 6type Experience interface {
 7  Describe() string // 描述经历
 8}
 9
10// travelExperience 旅游经历
11type travelExperience struct {
12  subject  string
13  traffic  Traffic
14  location Location
15}
16
17// NewTravelExperience 创建旅游经历，包括主题、交通方式、地点
18func NewTravelExperience(subject string, traffic Traffic, location Location) *travelExperience {
19  return &travelExperience{
20    subject:  subject,
21    traffic:  traffic,
22    location: location,
23  }
24}
25
26// Describe 描述旅游经历
27func (t *travelExperience) Describe() string {
28  return fmt.Sprintf("%s is to %s %s and %s", t.subject, t.location.Name(), t.traffic.Transport(), t.location.PlaySports())
29}
30
31// adventureExperience 探险经历
32type adventureExperience struct {
33  survivalTraining string
34  travelExperience
35}
36
37// NewAdventureExperience 创建探险经历，包括探险需要的培训，其他的与路由参数类似
38func NewAdventureExperience(training string, subject string, traffic Traffic, location Location) *adventureExperience {
39  return &adventureExperience{
40    survivalTraining: training,
41    travelExperience: *NewTravelExperience(subject, traffic, location),
42  }
43}
44
45// Describe 描述探险经历
46func (a *adventureExperience) Describe() string {
47  return fmt.Sprintf("after %s, %s", a.survivalTraining, a.travelExperience.Describe())
48}

14.2.4. 测试程序

 1package bridge
 2
 3import (
 4   "fmt"
 5   "testing"
 6)
 7
 8func TestBridge(t *testing.T) {
 9   // 坐飞机去三亚度蜜月
10   honeymoonTravel := NewTravelExperience("honeymoon", new(airplane), NewSeaside("SanyaYalongBay"))
11   fmt.Println(honeymoonTravel.Describe())
12   // 坐车去泰山毕业旅游
13   graduationTrip := NewTravelExperience("graduationTrip", new(car), NewMountain("Tarzan"))
14   fmt.Println(graduationTrip.Describe())
15
16   // 野外生存培训后，坐车去罗布泊，徒步穿越
17   desertAdventure := NewAdventureExperience("wilderness survival training", "adventure", new(car), NewDesert("Lop Nor"))
18   fmt.Println(desertAdventure.Describe())
19}

14.2.5. 运行结果

1=== RUN   TestBridge
2honeymoon is to SanyaYalongBay by airplane and surfing
3graduationTrip is to Tarzan by car and climbing
4after wilderness survival training, adventure is to Lop Nor by car and trekking
5--- PASS: TestBridge (0.00s)
6PASS

15. 组合模式

15.1. 概念

组合是一种结构型设计模式，你可以使用它将对象组合成树状结构，并且能像使用独立对象一样使用它们。

对于绝大多数需要生成树状结构的问题来说，组合都是非常受欢迎的解决方案。组合最主要的功能是在整个树状结构上递归调用方法并对结果进行汇总。

15.2. 示例

一般来说一个地区统计人口或经济总量，总是通过行政区划一层层上报汇总得出结果，区镇是最低一级行政区划，需要落实统计人口及经济总量的工作，再上一级行政区划需要将所辖区镇的数据汇总统计，以此类推每一级行政区划都需要统计人口与经济总量，就像一个倒过来的树状结构，各级行政区划统一的组件接口是统计人口与经济总量，区镇相当于最底层的叶子节点，中间级别行政区划相当于组合节点；下面代码以苏州市为例。

15.2.1. 组件接口

1package composite
2
3// Region 行政区，作为组合模式component接口
4type Region interface {
5   Name() string    // 名称
6   Population() int //人口
7   GDP() float64    // gdp
8}

15.2.2. 区镇实现

 1package composite
 2
 3// town 区镇，组合模式中相当于叶子节点
 4type town struct {
 5  name       string
 6  population int
 7  gdp        float64
 8}
 9
10// NewTown 创建区镇，根据名称、人口、GDP
11func NewTown(name string, population int, gdp float64) *town {
12  return &town{
13    name:       name,
14    population: population,
15    gdp:        gdp,
16  }
17}
18
19func (c *town) Name() string {
20  return c.name
21}
22
23func (c *town) Population() int {
24  return c.population
25}
26
27func (c *town) GDP() float64 {
28  return c.gdp
29}

15.2.3. 县市地市实现

 1package composite
 2
 3// cities 市，包括县市或者地市，组合模式中相当于composite
 4type cities struct {
 5  name    string
 6  regions map[string]Region
 7}
 8
 9// NewCities 创建一个市
10func NewCities(name string) *cities {
11  return &cities{
12    name:    name,
13    regions: make(map[string]Region),
14  }
15}
16
17func (c *cities) Name() string {
18  return c.name
19}
20
21func (c *cities) Population() int {
22  sum := 0
23  for _, r := range c.regions {
24    sum += r.Population()
25  }
26  return sum
27}
28
29func (c *cities) GDP() float64 {
30  sum := 0.0
31  for _, r := range c.regions {
32    sum += r.GDP()
33  }
34  return sum
35}
36
37// Add 添加多个行政区
38func (c *cities) Add(regions ...Region) {
39  for _, r := range regions {
40    c.regions[r.Name()] = r
41  }
42}
43
44// Remove 递归删除行政区
45func (c *cities) Remove(name string) {
46  for n, r := range c.regions {
47    if n == name {
48      delete(c.regions, name)
49      return
50    }
51    if city, ok := r.(*cities); ok {
52      city.Remove(name)
53    }
54  }
55}
56
57func (c *cities) Regions() map[string]Region {
58  return c.regions
59}

15.2.4. 测试程序

 1package composite
 2
 3import (
 4   "fmt"
 5   "testing"
 6)
 7
 8func TestComposite(t *testing.T) {
 9   gusu := NewTown("姑苏区", 100, 2000.00)
10   fmt.Println(ShowRegionInfo(gusu))
11   wuzhong := NewTown("吴中区", 150, 2600.00)
12   fmt.Println(ShowRegionInfo(wuzhong))
13   huqiu := NewTown("虎丘区", 80, 1800.00)
14   fmt.Println(ShowRegionInfo(huqiu))
15
16   kunshan := NewCities("昆山市")
17   kunshan.Add(NewTown("玉山镇", 60, 1200.00),
18      NewTown("周庄镇", 68, 1900.00),
19      NewTown("花桥镇", 78, 2200.00))
20   fmt.Println(ShowRegionInfo(kunshan))
21
22   changshu := NewCities("常熟市")
23   changshu.Add(NewTown("沙家浜镇", 55, 1100.00),
24      NewTown("古里镇", 59, 1300.00),
25      NewTown("辛庄镇", 68, 2100.00))
26   fmt.Println(ShowRegionInfo(changshu))
27
28   suzhou := NewCities("苏州市")
29   suzhou.Add(gusu, wuzhong, huqiu, kunshan, changshu)
30   fmt.Println(ShowRegionInfo(suzhou))
31
32}
33
34func ShowRegionInfo(region Region) string {
35   return fmt.Sprintf("%s, 人口:%d万, GDP:%.2f亿", region.Name(), region.Population(), region.GDP())
36}

15.2.5. 运行结果

1=== RUN   TestComposite
2姑苏区, 人口:100万, GDP:2000.00亿
3吴中区, 人口:150万, GDP:2600.00亿
4虎丘区, 人口:80万, GDP:1800.00亿
5昆山市, 人口:206万, GDP:5300.00亿
6常熟市, 人口:182万, GDP:4500.00亿
7苏州市, 人口:718万, GDP:16200.00亿
8--- PASS: TestComposite (0.00s)
9PASS

16. 装饰模式

16.1. 概念

装饰是一种结构设计模式，允许你通过将对象放入特殊封装对象中来为原对象增加新的行为。

由于目标对象和装饰器遵循同一接口，因此你可用装饰来对对象进行无限次的封装。结果对象将获得所有封装器叠加而来的行为。

16.2. 示例

地铁进站的过程一般情况下只需要买票，检票进站。但是如果你是带行李，就需要进行安全检查。如果是疫情时期，就需要进行疫情防护检查，比如戴口罩、测量体温等。这里买票进站相当于通用进站流程，安检及防疫检查就相当于加强的修饰行为。

16.2.1. 修饰器实现

 1package decorator
 2
 3import "fmt"
 4
 5// Station 车站，修饰器模式统一接口
 6type Station interface {
 7  Enter() string // 进站
 8}
 9
10// subwayStation 地铁站
11type subwayStation struct {
12  name string
13}
14
15// NewSubwayStation 创建指定站名地铁站
16func NewSubwayStation(name string) *subwayStation {
17  return &subwayStation{
18    name: name,
19  }
20}
21
22// Enter 进地铁站
23func (s *subwayStation) Enter() string {
24  return fmt.Sprintf("买票进入%s地铁站。", s.name)
25}
26
27// securityCheckDecorator 进站安检修饰器
28type securityCheckDecorator struct {
29  station Station
30}
31
32func NewSecurityCheckDecorator(station Station) *securityCheckDecorator {
33  return &securityCheckDecorator{
34    station: station,
35  }
36}
37
38func (s *securityCheckDecorator) Enter() string {
39  return "行李通过安检；" + s.station.Enter()
40}
41
42// epidemicProtectionDecorator 进站疫情防护修饰器
43type epidemicProtectionDecorator struct {
44  station Station
45}
46
47func NewEpidemicProtectionDecorator(station Station) *epidemicProtectionDecorator {
48  return &epidemicProtectionDecorator{
49    station: station,
50  }
51}
52
53func (e *epidemicProtectionDecorator) Enter() string {
54  return "测量体温，佩戴口罩；" + e.station.Enter()
55}

16.2.2. 测试代码

 1package decorator
 2
 3import (
 4   "fmt"
 5   "testing"
 6)
 7
 8func TestDecorator(t *testing.T) {
 9   xierqiStation := NewSubwayStation("西二旗")
10   fmt.Println(EnhanceEnterStationProcess(xierqiStation, false, false).Enter())
11   fmt.Println(EnhanceEnterStationProcess(xierqiStation, true, false).Enter())
12   fmt.Println(EnhanceEnterStationProcess(xierqiStation, true, true).Enter())
13}
14
15// EnhanceEnterStationProcess 根据是否有行李，是否处于疫情，增加进站流程
16func EnhanceEnterStationProcess(station Station, hasLuggage bool, hasEpidemic bool) Station {
17   if hasLuggage {
18      station = NewSecurityCheckDecorator(station)
19   }
20   if hasEpidemic {
21      station = NewEpidemicProtectionDecorator(station)
22   }
23   return station
24}

16.2.3. 运行结果

1=== RUN   TestDecorator
2买票进入西二旗地铁站。
3行李通过安检；买票进入西二旗地铁站。
4测量体温，佩戴口罩；行李通过安检；买票进入西二旗地铁站。
5--- PASS: TestDecorator (0.00s)
6PASS

17. 外观模式

17.1. 概念

外观是一种结构型设计模式，能为复杂系统、程序库或框架提供一个简单（但有限）的接口。

尽管外观模式降低了程序的整体复杂度，但它同时也有助于将不需要的依赖移动到同一个位置。

17.2. 示例

用户在淘宝电商系统买商品时，只需要选好商品在结算页点击提交即可完成下单；在客户端系统仅需要一个创建订单的方法，但是整个订单的生成需要很多步骤，比如查询用户配送地址，查询商品价格，使用优惠券，扣减商品库存，支付相应价钱等。

17.2.1. 淘宝电商系统

 1package facade
 2
 3import "fmt"
 4
 5// TaobaoFacade 淘宝网站门面，在淘宝网站下单涉及到多个系统配合调用，包括用户系统，商品系统，优惠券系统，库存系统，支付系统，最终生成订单
 6type TaobaoFacade struct {
 7  userService    *UserService
 8  productService *ProductService
 9  couponService  *CouponService
10  stockService   *StockService
11  paymentService *PaymentService
12}
13
14// NewTaobaoFacade 创建淘宝网站
15func NewTaobaoFacade() *TaobaoFacade {
16  return &TaobaoFacade{
17    userService: &UserService{},
18    productService: &ProductService{
19      products: map[string]float64{"笔记本电脑": 6666.66},
20    },
21    couponService:  &CouponService{},
22    stockService:   &StockService{},
23    paymentService: &PaymentService{},
24  }
25}
26
27// CreateOrder 根据用户名，商品名，商品数量生成购买订单
28func (t *TaobaoFacade) CreateOrder(userName string, productName string, count int) string {
29  // 使用优惠券
30  couponInfo := t.couponService.useCoupon()
31  // 扣减库存
32  stockInfo := t.stockService.decreaseFor(productName, count)
33  // 计算商品总价
34  sumPrice := t.productService.getProductPrice(productName) * float64(count)
35  // 支付价格
36  payInfo := t.paymentService.pay(sumPrice)
37  return fmt.Sprintf("用户%s,购买了%d件%s商品,%s,%s,%s,送货到%s", userName, count, productName, couponInfo,
38    stockInfo, payInfo, t.userService.getUserAddress(userName))
39}
40
41// UserService 用户系统
42type UserService struct{}
43
44func (u *UserService) getUserAddress(userName string) string {
45  return fmt.Sprintf("%s地址是:北京市海淀区中关村大街，1号院2号楼3单元402", userName)
46}
47
48// ProductService 商品系统
49type ProductService struct {
50  products map[string]float64
51}
52
53func (p *ProductService) getProductPrice(productName string) float64 {
54  return p.products[productName]
55}
56
57// CouponService 优惠券系统
58type CouponService struct{}
59
60func (c *CouponService) useCoupon() string {
61  return "使用满100减20优惠券"
62}
63
64// StockService 库存系统
65type StockService struct{}
66
67func (s *StockService) decreaseFor(productName string, count int) string {
68  return fmt.Sprintf("扣减%d件%s商品库存", count, productName)
69}
70
71// PaymentService 支付系统
72type PaymentService struct{}
73
74func (p *PaymentService) pay(amount float64) string {
75  return fmt.Sprintf("支付金额%.2f", amount)
76}

17.2.2. 测试程序

 1package facade
 2
 3import (
 4   "fmt"
 5   "testing"
 6)
 7
 8func TestFacade(t *testing.T) {
 9   // 通过门面模式，隐藏下单过程中，后端多个系统的复杂交互
10   taobao := NewTaobaoFacade()
11   fmt.Println(taobao.CreateOrder("张三", "笔记本电脑", 1))
12}

17.2.3. 运行结果

1=== RUN   TestFacade
2用户张三,购买了1件笔记本电脑商品,使用满100减20优惠券,扣减1件笔记本电脑商品库存,支付金额6666.66,送货到张三地址是:北京市海淀区中关村大街，1号院2号楼3单元402
3--- PASS: TestFacade (0.00s)
4PASS

18. 享元模式

18.1. 概念

享元是一种结构型设计模式，它允许你在消耗少量内存的情况下支持大量对象。

模式通过共享多个对象的部分状态来实现上述功能。换句话来说，享元会将不同对象的相同数据进行缓存以节省内存。

18.2. 示例

北京出租车调度系统，需要每隔一分钟记录一下全市出租车的位置信息。假设为了提高系统响应速度，近一天的数据需要存储在内存中，每个位置信息包括出租车辆信息及位置信息，位置信息在系统中就是一个(x,y)坐标，车辆信息包括车的号牌，颜色，品牌和所属公司。在调度系统存储的出租车行驶轨迹中，位置是实时在变化的，但车辆信息就可以通过享元模式共用一个对象引用，来减少内存消耗。

18.2.1. 出租车享元对象

 1package flyweight
 2
 3import (
 4  "fmt"
 5)
 6
 7// Taxi 出租车，享元对象，保存不变的内在属性信息
 8type Taxi struct {
 9  licensePlate string // 车牌
10  color        string // 颜色
11  brand        string // 汽车品牌
12  company      string // 所属公司
13}
14
15// LocateFor 获取定位信息
16func (t *Taxi) LocateFor(monitorMap string, x, y int) string {
17  return fmt.Sprintf("%s,对于车牌号%s,%s,%s品牌,所属%s公司,定位(%d,%d)", monitorMap,
18    t.licensePlate, t.color, t.brand, t.company, x, y)
19}
20
21// taxiFactoryInstance 出租车工厂单例
22var taxiFactoryInstance = &TaxiFactory{
23  taxis: make(map[string]*Taxi),
24}
25
26// GetTaxiFactory 获取出租车工厂单例
27func GetTaxiFactory() *TaxiFactory {
28  return taxiFactoryInstance
29}
30
31// TaxiFactory 出租车工厂类
32type TaxiFactory struct {
33  taxis map[string]*Taxi // key为车牌号
34}
35
36// getTaxi 获取出租车
37func (f *TaxiFactory) getTaxi(licensePlate, color, brand, company string) *Taxi {
38  if _, ok := f.taxis[licensePlate]; !ok {
39    f.taxis[licensePlate] = &Taxi{
40      licensePlate: licensePlate,
41      color:        color,
42      brand:        brand,
43      company:      company,
44    }
45  }
46  return f.taxis[licensePlate]
47}

18.2.2. 出租车调度系统

 1package flyweight
 2
 3import "bytes"
 4
 5// TaxiPosition 出租车位置信息 x,y为外在数据信息，taxi为内在数据信息（享元对象）
 6type TaxiPosition struct {
 7  x    int
 8  y    int
 9  taxi *Taxi
10}
11
12func NewTaxiPosition(taxi *Taxi, x, y int) *TaxiPosition {
13  return &TaxiPosition{
14    taxi: taxi,
15    x:    x,
16    y:    y,
17  }
18}
19
20// LocateFor 定位信息
21func (p *TaxiPosition) LocateFor(monitorMap string) string {
22  return p.taxi.LocateFor(monitorMap, p.x, p.y)
23}
24
25// TaxiDispatcher 出租车调度系统
26type TaxiDispatcher struct {
27  name   string
28  traces map[string][]*TaxiPosition // 存储出租车当天轨迹信息，key为车牌号
29}
30
31func NewTaxiDispatcher(name string) *TaxiDispatcher {
32  return &TaxiDispatcher{
33    name:   name,
34    traces: make(map[string][]*TaxiPosition),
35  }
36}
37
38// AddTrace 添加轨迹
39func (t *TaxiDispatcher) AddTrace(licensePlate, color, brand, company string, x, y int) {
40  taxi := GetTaxiFactory().getTaxi(licensePlate, color, brand, company)
41  t.traces[licensePlate] = append(t.traces[licensePlate], NewTaxiPosition(taxi, x, y))
42}
43
44// ShowTraces 显示轨迹
45func (t *TaxiDispatcher) ShowTraces(licensePlate string) string {
46  bytesBuf := bytes.Buffer{}
47  for _, trace := range t.traces[licensePlate] {
48    bytesBuf.WriteString(trace.LocateFor(t.name))
49    bytesBuf.WriteByte('\n')
50  }
51  return bytesBuf.String()
52}

18.2.3. 测试程序

 1package flyweight
 2
 3import (
 4   "fmt"
 5   "testing"
 6)
 7
 8func TestFlyweight(t *testing.T) {
 9   dispatcher := NewTaxiDispatcher("北京市出租车调度系统")
10   dispatcher.AddTrace("京B.123456", "黄色", "北京现代", "北汽", 10, 20)
11   dispatcher.AddTrace("京B.123456", "黄色", "北京现代", "北汽", 20, 30)
12   dispatcher.AddTrace("京B.123456", "黄色", "北京现代", "北汽", 30, 40)
13   dispatcher.AddTrace("京B.123456", "黄色", "北京现代", "北汽", 40, 50)
14
15   dispatcher.AddTrace("京B.567890", "红色", "一汽大众", "首汽", 20, 40)
16   dispatcher.AddTrace("京B.567890", "红色", "一汽大众", "首汽", 50, 50)
17
18   fmt.Println(dispatcher.ShowTraces("京B.123456"))
19   fmt.Println(dispatcher.ShowTraces("京B.567890"))
20}

18.2.4. 运行结果

 1=== RUN   TestFlyweight
 2北京市出租车调度系统,对于车牌号京B.123456,黄色,北京现代品牌,所属北汽公司,定位(10,20)
 3北京市出租车调度系统,对于车牌号京B.123456,黄色,北京现代品牌,所属北汽公司,定位(20,30)
 4北京市出租车调度系统,对于车牌号京B.123456,黄色,北京现代品牌,所属北汽公司,定位(30,40)
 5北京市出租车调度系统,对于车牌号京B.123456,黄色,北京现代品牌,所属北汽公司,定位(40,50)
 6
 7北京市出租车调度系统,对于车牌号京B.567890,红色,一汽大众品牌,所属首汽公司,定位(20,40)
 8北京市出租车调度系统,对于车牌号京B.567890,红色,一汽大众品牌,所属首汽公司,定位(50,50)
 9--- PASS: TestFlyweight (0.00s)
10PASS

19. 代理模式

19.1. 概念

代理是一种结构型设计模式，让你能提供真实服务对象的替代品给客户端使用。代理接收客户端的请求并进行一些处理（访问控制和缓存等），然后再将请求传递给服务对象。

代理对象拥有和服务对象相同的接口，这使得当其被传递给客户端时可与真实对象互换。

修饰与代理是非常相似的设计模式，都是基于组合设计原则，也就是说一个对象应该将部分工作委派给另一个对象。但两者之间不同点我认为是，修饰器模式总是要执行服务对象，对于执行之前或执行之后结果进行加强，服务对象基本是客户端创建好再嵌套外层的修饰对象；而代理模式不一定执行服务对象，有可能通过缓存，延迟加载等没有访问服务对象，同时服务对象什么时候创建也是由代理类决定的。

19.2. 示例

房屋中介代理帮助房东卖房子，这个过程就是一个代理模式的过程。中介会收集尽量多的卖房信息，并通过各种渠道发布，同时中介会随时带客户看房，并初步商讨价格，如果达成初步购买意向，才会约房东讨论房屋价格，最后签约卖房。房屋中介与房东都实现卖房接口，中介会提前坐一些前期工作，如果都没问题，才会约房东执行真正的签约卖房流程。

19.2.1. 房屋中介卖房

 1package proxy
 2
 3import (
 4  "bytes"
 5  "fmt"
 6)
 7
 8// HouseSeller 房屋出售者
 9type HouseSeller interface {
10  SellHouse(address string, buyer string) string
11}
12
13// houseProxy 房产中介代理
14type houseProxy struct {
15  houseSeller HouseSeller
16}
17
18func NewHouseProxy(houseSeller HouseSeller) *houseProxy {
19  return &houseProxy{
20    houseSeller: houseSeller,
21  }
22}
23
24// SellHouse 中介卖房，看房->初步谈价->最终和房东签协议
25func (h *houseProxy) SellHouse(address string, buyer string) string {
26  buf := bytes.Buffer{}
27  buf.WriteString(h.viewHouse(address, buyer) + "\n")
28  buf.WriteString(h.preBargain(address, buyer) + "\n")
29  buf.WriteString(h.houseSeller.SellHouse(address, buyer))
30  return buf.String()
31}
32
33// viewHouse 看房介绍基本情况
34func (h *houseProxy) viewHouse(address string, buyer string) string {
35  return fmt.Sprintf("带买家%s看位于%s的房屋，并介绍基本情况", buyer, address)
36}
37
38// preBargain 初步沟通价格
39func (h *houseProxy) preBargain(address string, buyer string) string {
40  return fmt.Sprintf("讨价还价后，初步达成购买意向")
41}
42
43// houseOwner 房东
44type houseOwner struct{}
45
46// SellHouse 房东卖房，商讨价格，签署购房协议
47func (h *houseOwner) SellHouse(address string, buyer string) string {
48  return fmt.Sprintf("最终商讨价格后，与%s签署购买地址为%s的购房协议。", buyer, address)
49}

19.2.2. 测试程序

 1package proxy
 2
 3import (
 4  "fmt"
 5  "testing"
 6)
 7
 8func TestProxy(t *testing.T) {
 9  proxy := NewHouseProxy(&houseOwner{})
10  fmt.Println(proxy.SellHouse("北京市海淀区中关村大街，2号院1号楼4单元502室", "李四"))
11}

19.2.3. 运行结果

1=== RUN   TestProxy
2带买家李四看位于北京市海淀区中关村大街，2号院1号楼4单元502室的房屋，并介绍基本情况
3讨价还价后，初步达成购买意向
4最终商讨价格后，与李四签署购买地址为北京市海淀区中关村大街，2号院1号楼4单元502室的购房协议。
5--- PASS: TestProxy (0.00s)
6PASS

20. 工厂方法模式

20.1. 概念

工厂方法模式是一种创建型设计模式，其在父类中提供一个创建对象的方法，允许子类决定实例化对象的类型。

20.2. 示例

摊煎饼的小贩需要先摊个煎饼，再卖出去，摊煎饼就可以类比为一个工厂方法，根据顾客的喜好摊出不同口味的煎饼。

20.2.1. 接口

 1package factory_method
 2
 3// Pancake 煎饼
 4type Pancake interface {
 5 // ShowFlour 煎饼使用的面粉
 6 ShowFlour() string
 7 // Value 煎饼价格
 8 Value() float32
 9}
10
11// PancakeCook 煎饼厨师
12type PancakeCook interface {
13 // MakePancake 摊煎饼
14 MakePancake() Pancake
15}
16
17// PancakeVendor 煎饼小贩
18type PancakeVendor struct {
19 PancakeCook
20}
21
22// NewPancakeVendor ...
23func NewPancakeVendor(cook PancakeCook) *PancakeVendor {
24 return &PancakeVendor{
25  PancakeCook: cook,
26 }
27}
28
29// SellPancake 卖煎饼，先摊煎饼，再卖
30func (vendor *PancakeVendor) SellPancake() (money float32) {
31 return vendor.MakePancake().Value()
32}

20.2.2. 实现

20.2.2.1. 各种面的煎饼实现

 1package factory_method
 2
 3// cornPancake 玉米面煎饼
 4type cornPancake struct{}
 5
 6// NewCornPancake ...
 7func NewCornPancake() *cornPancake {
 8 return &cornPancake{}
 9}
10
11func (cake *cornPancake) ShowFlour() string {
12 return "玉米面"
13}
14
15func (cake *cornPancake) Value() float32 {
16 return 5.0
17}
18
19// milletPancake 小米面煎饼
20type milletPancake struct{}
21
22func NewMilletPancake() *milletPancake {
23 return &milletPancake{}
24}
25
26func (cake *milletPancake) ShowFlour() string {
27 return "小米面"
28}
29
30func (cake *milletPancake) Value() float32 {
31 return 8.0
32}

20.2.2.2. 制作各种口味煎饼的工厂方法实现

 1package factory_method
 2
 3// cornPancakeCook 制作玉米面煎饼厨师
 4type cornPancakeCook struct{}
 5
 6func NewCornPancakeCook() *cornPancakeCook {
 7 return &cornPancakeCook{}
 8}
 9
10func (cook *cornPancakeCook) MakePancake() Pancake {
11 return NewCornPancake()
12}
13
14// milletPancakeCook 制作小米面煎饼厨师
15type milletPancakeCook struct{}
16
17func NewMilletPancakeCook() *milletPancakeCook {
18 return &milletPancakeCook{}
19}
20
21func (cook *milletPancakeCook) MakePancake() Pancake {
22 return NewMilletPancake()
23}

20.2.3. 测试程序

 1package factory_method
 2
 3import (
 4 "fmt"
 5 "testing"
 6)
 7
 8func TestFactoryMethod(t *testing.T) {
 9 pancakeVendor := NewPancakeVendor(NewCornPancakeCook())
10 fmt.Printf("Corn pancake value is %v\n", pancakeVendor.SellPancake())
11
12 pancakeVendor = NewPancakeVendor(NewMilletPancakeCook())
13 fmt.Printf("Millet pancake value is %v\n", pancakeVendor.SellPancake())
14}

20.2.4. 运行结果

1=== RUN   TestFactoryMethod
2Corn pancake value is 5
3Millet pancake value is 8
4--- PASS: TestFactoryMethod (0.00s)
5PASS

21. 抽象工厂模式

21.1. 概念

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

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

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

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

21.2. 示例

厨师准备一餐时，会分别做吃的和喝的，根据早、中、晚三餐饮食习惯，会分别制作不同的饮食。厨师就相当于抽象工厂，制作三餐的不同烹饪方式就好比不同抽象工厂的实现。

21.2.1. 接口

 1package abstract_factory
 2// Cook 厨师接口，抽象工厂
 3type Cook interface {
 4 // MakeFood 制作主食
 5 MakeFood() Food
 6 // MakeDrink 制作饮品
 7 MakeDrink() Drink
 8}
 9
10// Food 主食接口
11type Food interface {
12 // Eaten 被吃
13 Eaten() string
14}
15
16// Drink 饮品接口
17type Drink interface {
18 // Drunk 被喝
19 Drunk() string
20}

21.2.2. 实现

三餐不同厨师接口的实现。

 1package abstract_factory
 2
 3// breakfastCook 早餐厨师
 4type breakfastCook struct{}
 5
 6func NewBreakfastCook() *breakfastCook {
 7 return &breakfastCook{}
 8}
 9
10func (b *breakfastCook) MakeFood() Food {
11 return &cakeFood{"切片面包"}
12}
13
14func (b *breakfastCook) MakeDrink() Drink {
15 return &gruelDrink{"小米粥"}
16}
17
18// lunchCook 午餐厨师
19type lunchCook struct{}
20
21func NewLunchCook() *lunchCook {
22 return &lunchCook{}
23}
24
25func (l *lunchCook) MakeFood() Food {
26 return &dishFood{"烤全羊"}
27}
28
29func (l *lunchCook) MakeDrink() Drink {
30 return &sodaDrink{"冰镇可口可乐"}
31}
32
33// dinnerCook 晚餐厨师
34type dinnerCook struct{}
35
36func NewDinnerCook() *dinnerCook {
37 return &dinnerCook{}
38}
39
40func (d *dinnerCook) MakeFood() Food {
41 return &noodleFood{"大盘鸡拌面"}
42}
43
44func (d *dinnerCook) MakeDrink() Drink {
45 return &soupDrink{"西红柿鸡蛋汤"}
46}

21.2.2.1. 不同吃的

 1package abstract_factory
 2
 3import "fmt"
 4
 5// cakeFood 蛋糕
 6type cakeFood struct {
 7 cakeName string
 8}
 9
10func (c *cakeFood) Eaten() string {
11 return fmt.Sprintf("%v被吃", c.cakeName)
12}
13
14// dishFood 菜肴
15type dishFood struct {
16 dishName string
17}
18
19func (d *dishFood) Eaten() string {
20 return fmt.Sprintf("%v被吃", d.dishName)
21}
22
23// noodleFood 面条
24type noodleFood struct {
25 noodleName string
26}
27
28func (n *noodleFood) Eaten() string {
29 return fmt.Sprintf("%v被吃", n.noodleName)
30}

21.2.2.2. 不同喝的

 1package abstract_factory
 2
 3import "fmt"
 4
 5// gruelDrink 粥
 6type gruelDrink struct {
 7 gruelName string
 8}
 9
10func (g *gruelDrink) Drunk() string {
11 return fmt.Sprintf("%v被喝", g.gruelName)
12}
13
14// sodaDrink 汽水
15type sodaDrink struct {
16 sodaName string
17}
18
19func (s *sodaDrink) Drunk() string {
20 return fmt.Sprintf("%v被喝", s.sodaName)
21}
22
23// soupDrink 汤
24type soupDrink struct {
25 soupName string
26}
27
28func (s *soupDrink) Drunk() string {
29 return fmt.Sprintf("%v被喝", s.soupName)
30}

21.2.3. 测试程序

 1package abstract_factory
 2
 3import (
 4 "fmt"
 5 "testing"
 6)
 7
 8func TestAbstractFactory(t *testing.T) {
 9 fmt.Printf("breakfast: %v\n", HaveMeal(NewBreakfastCook()))
10 fmt.Printf("lunch: %v\n", HaveMeal(NewLunchCook()))
11 fmt.Printf("dinner: %v\n", HaveMeal(NewDinnerCook()))
12}
13
14// HaveMeal 吃饭
15func HaveMeal(cook Cook) string {
16 return fmt.Sprintf("%s %s", cook.MakeFood().Eaten(), cook.MakeDrink().Drunk())
17}

21.2.4. 运行结果

1=== RUN   TestAbstractFactory
2breakfast: 切片面包被吃 小米粥被喝
3lunch: 烤全羊被吃 冰镇可口可乐被喝
4dinner: 大盘鸡拌面被吃 西红柿鸡蛋汤被喝
5--- PASS: TestAbstractFactory (0.00s)
6PASS

22. 生成器模式

22.1. 概念

生成器是一种创建型设计模式，使你能够分步骤创建复杂对象。

与其他创建型模式不同，生成器不要求产品拥有通用接口。这使得用相同的创建过程生成不同的产品成为可能。

22.2. 示例

还是摊煎饼的例子，摊煎饼分为四个步骤，1放面糊、2放鸡蛋、3放调料、4放薄脆，通过四个创建过程，制作好一个煎饼，这个摊煎饼的过程就好比煎饼生成器接口，不同生成器的实现就相当于摊不同品类的煎饼，比如正常的煎饼，健康的煎饼（可能用的是粗粮面、柴鸡蛋、非油炸薄脆、不放酱等），生成器接口方法也可以通过参数控制煎饼的大小，比如放两勺面糊，放2个鸡蛋等。

生成器的使用者为了避免每次都调用相同的构建步骤，也可以通过包装类固定几种构建过程，生成几类常用的产品，就好像摊煎饼有几类常卖固定成品，比如普通的，加两个鸡蛋的，不要香菜的等等，这几类固定构建过程提前定制好，直接通过简单工厂方法就直接创建，如果用户再需要细粒度的定制构建，再通过生成器创建。

22.2.1. 接口

 1package builder
 2
 3// Quantity 分量
 4type Quantity int
 5
 6const (
 7 Small  Quantity = 1
 8 Middle Quantity = 5
 9 Large  Quantity = 10
10)
11
12type PancakeBuilder interface {
13 // PutPaste 放面糊
14 PutPaste(quantity Quantity)
15 // PutEgg 放鸡蛋
16 PutEgg(num int)
17 // PutWafer 放薄脆
18 PutWafer()
19 // PutFlavour 放调料 Coriander香菜，Shallot葱 Sauce酱
20 PutFlavour(hasCoriander, hasShallot, hasSauce bool)
21 // Build 摊煎饼
22 Build() *Pancake
23}
24
25// Pancake  煎饼
26type Pancake struct {
27 pasteQuantity Quantity // 面糊分量
28 eggNum        int      // 鸡蛋数量
29 wafer         string   // 薄脆
30 hasCoriander  bool     // 是否放香菜
31 hasShallot    bool     // 是否放葱
32 hasSauce      bool     // 是否放酱
33}

22.2.2. 实现

22.2.2.1. 正常煎饼创建器

 1package builder
 2
 3type normalPancakeBuilder struct {
 4 pasteQuantity Quantity // 面糊量
 5 eggNum        int      // 鸡蛋数量
 6 friedWafer    string   // 油炸薄脆
 7 hasCoriander  bool     // 是否放香菜
 8 hasShallot    bool     // 是否放葱
 9 hasHotSauce   bool     // 是否放辣味酱
10}
11
12func NewNormalPancakeBuilder() *normalPancakeBuilder {
13 return &normalPancakeBuilder{}
14}
15
16func (n *normalPancakeBuilder) PutPaste(quantity Quantity) {
17 n.pasteQuantity = quantity
18}
19
20func (n *normalPancakeBuilder) PutEgg(num int) {
21 n.eggNum = num
22}
23
24func (n *normalPancakeBuilder) PutWafer() {
25 n.friedWafer = "油炸的薄脆"
26}
27
28func (n *normalPancakeBuilder) PutFlavour(hasCoriander, hasShallot, hasSauce bool) {
29 n.hasCoriander = hasCoriander
30 n.hasShallot = hasShallot
31 n.hasHotSauce = hasSauce
32}
33
34func (n *normalPancakeBuilder) Build() *Pancake {
35 return &Pancake{
36  pasteQuantity: n.pasteQuantity,
37  eggNum:        n.eggNum,
38  wafer:         n.friedWafer,
39  hasCoriander:  n.hasCoriander,
40  hasShallot:    n.hasShallot,
41  hasSauce:      n.hasHotSauce,
42 }
43}

22.2.2.2. 健康煎饼创建器

 1package builder
 2
 3type healthyPancakeBuilder struct {
 4 milletPasteQuantity Quantity // 小米面糊量
 5 chaiEggNum          int      // 柴鸡蛋数量
 6 nonFriedWafer       string   // 非油炸薄脆
 7 hasCoriander        bool     // 是否放香菜
 8 hasShallot          bool     // 是否放葱
 9}
10
11func NewHealthyPancakeBuilder() *healthyPancakeBuilder {
12 return &healthyPancakeBuilder{}
13}
14
15func (n *healthyPancakeBuilder) PutPaste(quantity Quantity) {
16 n.milletPasteQuantity = quantity
17}
18
19func (n *healthyPancakeBuilder) PutEgg(num int) {
20 n.chaiEggNum = num
21}
22
23func (n *healthyPancakeBuilder) PutWafer() {
24 n.nonFriedWafer = "非油炸的薄脆"
25}
26
27func (n *healthyPancakeBuilder) PutFlavour(hasCoriander, hasShallot, _ bool) {
28 n.hasCoriander = hasCoriander
29 n.hasShallot = hasShallot
30}
31
32func (n *healthyPancakeBuilder) Build() *Pancake {
33 return &Pancake{
34  pasteQuantity: n.milletPasteQuantity,
35  eggNum:        n.chaiEggNum,
36  wafer:         n.nonFriedWafer,
37  hasCoriander:  n.hasCoriander,
38  hasShallot:    n.hasShallot,
39  hasSauce:      false,
40 }
41}

22.2.2.3. 煎饼生成器的封装类-厨师

 1package builder
 2
 3// PancakeCook 摊煎饼师傅
 4type PancakeCook struct {
 5 builder PancakeBuilder
 6}
 7
 8func NewPancakeCook(builder PancakeBuilder) *PancakeCook {
 9 return &PancakeCook{
10  builder: builder,
11 }
12}
13
14// SetPancakeBuilder 重新设置煎饼构造器
15func (p *PancakeCook) SetPancakeBuilder(builder PancakeBuilder) {
16 p.builder = builder
17}
18
19// MakePancake 摊一个一般煎饼
20func (p *PancakeCook) MakePancake() *Pancake {
21 p.builder.PutPaste(Middle)
22 p.builder.PutEgg(1)
23 p.builder.PutWafer()
24 p.builder.PutFlavour(true, true, true)
25 return p.builder.Build()
26}
27
28// MakeBigPancake 摊一个巨无霸煎饼
29func (p *PancakeCook) MakeBigPancake() *Pancake {
30 p.builder.PutPaste(Large)
31 p.builder.PutEgg(3)
32 p.builder.PutWafer()
33 p.builder.PutFlavour(true, true, true)
34 return p.builder.Build()
35}
36
37// MakePancakeForFlavour 摊一个自选调料霸煎饼
38func (p *PancakeCook) MakePancakeForFlavour(hasCoriander, hasShallot, hasSauce bool) *Pancake {
39 p.builder.PutPaste(Large)
40 p.builder.PutEgg(3)
41 p.builder.PutWafer()
42 p.builder.PutFlavour(hasCoriander, hasShallot, hasSauce)
43 return p.builder.Build()
44}

22.2.3. 测试程序

 1package builder
 2
 3import (
 4 "fmt"
 5 "testing"
 6)
 7
 8func TestBuilder(t *testing.T) {
 9 pancakeCook := NewPancakeCook(NewNormalPancakeBuilder())
10 fmt.Printf("摊一个普通煎饼 %#v\n", pancakeCook.MakePancake())
11
12 pancakeCook.SetPancakeBuilder(NewHealthyPancakeBuilder())
13 fmt.Printf("摊一个健康的加量煎饼 %#v\n", pancakeCook.MakeBigPancake())
14}

22.2.4. 运行结果

1=== RUN   TestBuilder
2摊一个普通煎饼 &builder.Pancake{pasteQuantity:5, eggNum:1, wafer:"油炸的薄脆", hasCoriander:true, hasShallot:true, hasSauce:true}
3摊一个健康的加量煎饼 &builder.Pancake{pasteQuantity:10, eggNum:3, wafer:"非油炸的薄脆", hasCoriander:true, hasShallot:true, hasSauce:false}
4--- PASS: TestBuilder (0.00s)
5PASS

23. 原型模式

23.1. 概念

原型是一种创建型设计模式，使你能够复制对象，甚至是复杂对象，而又无需使代码依赖它们所属的类。

所有的原型类都必须有一个通用的接口，使得即使在对象所属的具体类未知的情况下也能复制对象。原型对象可以生成自身的完整副本，因为相同类的对象可以相互访问对方的私有成员变量。

23.2. 示例

纸质文件可以通过复印机轻松拷贝出多份，设置 Paper 接口，包含读取文件内容和克隆文件两个方法。同时声明两个类报纸（Newspaper）和简历（Resume）实现了 Paper 接口，通过复印机（Copier）复印出两类文件的副本，并读取文件副本内容。

23.2.1. 接口实现

 1package prototype
 2
 3import (
 4 "bytes"
 5 "fmt"
 6 "io"
 7)
 8
 9// Paper 纸张，包含读取内容的方法，拷贝纸张的方法，作为原型模式接口
10type Paper interface {
11 io.Reader
12 Clone() Paper
13}
14
15// Newspaper 报纸 实现原型接口
16type Newspaper struct {
17 headline string
18 content  string
19}
20
21func NewNewspaper(headline string, content string) *Newspaper {
22 return &Newspaper{
23  headline: headline,
24  content:  content,
25 }
26}
27
28func (np *Newspaper) Read(p []byte) (n int, err error) {
29 buf := bytes.NewBufferString(fmt.Sprintf("headline:%s,content:%s", np.headline, np.content))
30 return buf.Read(p)
31}
32
33func (np *Newspaper) Clone() Paper {
34 return &Newspaper{
35  headline: np.headline + "_copied",
36  content:  np.content,
37 }
38}
39
40// Resume 简历 实现原型接口
41type Resume struct {
42 name       string
43 age        int
44 experience string
45}
46
47func NewResume(name string, age int, experience string) *Resume {
48 return &Resume{
49  name:       name,
50  age:        age,
51  experience: experience,
52 }
53}
54
55func (r *Resume) Read(p []byte) (n int, err error) {
56 buf := bytes.NewBufferString(fmt.Sprintf("name:%s,age:%d,experience:%s", r.name, r.age, r.experience))
57 return buf.Read(p)
58}
59
60func (r *Resume) Clone() Paper {
61 return &Resume{
62  name:       r.name + "_copied",
63  age:        r.age,
64  experience: r.experience,
65 }
66}

23.2.2. 测试程序

 1package prototype
 2
 3import (
 4 "fmt"
 5 "reflect"
 6 "testing"
 7)
 8
 9func TestPrototype(t *testing.T) {
10 copier := NewCopier("云打印机")
11 oneNewspaper := NewNewspaper("Go是最好的编程语言", "Go语言十大优势")
12 oneResume := NewResume("小明", 29, "5年码农")
13
14 otherNewspaper := copier.copy(oneNewspaper)
15 copyNewspaperMsg := make([]byte, 100)
16 byteSize, _ := otherNewspaper.Read(copyNewspaperMsg)
17 fmt.Println("copyNewspaperMsg:" + string(copyNewspaperMsg[:byteSize]))
18
19 otherResume := copier.copy(oneResume)
20 copyResumeMsg := make([]byte, 100)
21 byteSize, _ = otherResume.Read(copyResumeMsg)
22 fmt.Println("copyResumeMsg:" + string(copyResumeMsg[:byteSize]))
23}
24
25// Copier 复印机
26type Copier struct {
27 name string
28}
29
30func NewCopier(n string) *Copier {
31 return &Copier{name: n}
32}
33
34func (c *Copier) copy(paper Paper) Paper {
35 fmt.Printf("copier name:%v is copying:%v ", c.name, reflect.TypeOf(paper).String())
36 return paper.Clone()
37}

23.2.3. 运行结果

1=== RUN   TestPrototype
2copier name:云打印机 is copying:*prototype.Newspaper copyNewspaperMsg:headline:Go是最好的编程语言_copied,content:Go语言十大优势
3copier name:云打印机 is copying:*prototype.Resume copyResumeMsg:name:小明_copied,age:29,experience:5年码农
4--- PASS: TestPrototype (0.00s)
5PASS

24. 单例模式

24.1. 概念

单例是一种创建型设计模式，让你能够保证一个类只有一个实例，并提供一个访问该实例的全局节点。

单例拥有与全局变量相同的优缺点。尽管它们非常有用，但却会破坏代码的模块化特性。

24.2. 示例

通过地球对象实现单例，earth不能导出，通过TheEarth方法访问全局唯一实例，并通过sync.Once实现多协程下一次加载。

24.2.1. 接口实现

 1package singleton
 2
 3import "sync"
 4
 5var once sync.Once
 6
 7// 不可导出对象
 8type earth struct {
 9 desc string
10}
11
12func (e *earth) String() string {
13 return e.desc
14}
15
16// theEarth 地球单实例
17var theEarth *earth
18
19// TheEarth 获取地球单实例
20func TheEarth() *earth {
21 if theEarth == nil {
22  once.Do(func() {
23   theEarth = &earth{
24    desc: "美丽的地球，孕育了生命。",
25   }
26  })
27 }
28 return theEarth
29}

24.2.2. 测试程序

 1package singleton
 2
 3import (
 4 "fmt"
 5 "testing"
 6)
 7
 8func TestSingleton(t *testing.T) {
 9 fmt.Println(TheEarth().String())
10}

24.2.3. 运行结果

1=== RUN   TestSingleton
2美丽的地球，孕育了生命。
3--- PASS: TestSingleton (0.00s)
4PASS

25. 参考文献

转自腾讯内部知识平台 KM，外网暂无链接

golang图片处理库image基本操作

Fri, 11 Nov 2022 09:52:22 +0800

1. 基本操作

图片的基本读取与保存。

2. 读取

图片读取和文件读取类似，需要先获取流：

注册图片的解码器（如：jpg则import _ “image/jpeg”, png则import _ “image/png”）
通过os.open打开文件获取流；
通过image.Decode解码流，获取图片；

 1import _ "image/jpeg"
 2func readPic() image.Image {
 3    f, err := os.Open("C:\\hatAndSunglass.jpg")
 4    if err != nil {
 5        panic(err)
 6    }
 7    defer f.Close()
 8
 9    img, fmtName, err := image.Decode(f)
10    if err != nil {
11        panic(err)
12    }
13    fmt.Printf("Name: %v, Bounds: %+v, Color: %+v", fmtName, img.Bounds(), img.ColorModel())
14
15    return img
16}

解码后返回的第一个参数为Image接口：

1type Image interface {
2  ColorModel() color.Model // 返回图片的颜色模型
3  Bounds() Rectangle       // 返回图片外框
4  At(x, y int) color.Color // 返回(x,y)像素点的颜色
5}

3. 新建

新建一个图片非常简单，只需image.NewRGBA即可创建一个透明背景的图片了

1img := image.NewRGBA(image.Rect(0, 0, 300, 300))

4. 保存

保存图片也很简单，需要编码后，写入文件流即可：

注册图片的解码器
通过os.create创建文件；通
过png.Encode编码图片并写入文件；

 1func savePic(img *image.RGBA) {
 2    f, err := os.Create("C:\\tmp.jpg")
 3    if err != nil {
 4        panic(err)
 5    }
 6    defer f.Close()
 7    b := bufio.NewWriter(f)
 8    err = jpeg.Encode(b, img, nil)
 9    if err != nil {
10        panic(err)
11    }
12    b.Flush()
13}

5. 图片修改

很多操作都需要用到绘制图片：

1func Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point, op Op)
2func DrawMask(dst Image, r image.Rectangle, src image.Image, sp image.Point, mask image.Image, mp image.Point, op Op)

主要参数说明：

dst：绘图的背景图
r：背景图的绘图区域
src：要绘制的图
sp：要绘制图src的开始点
op：组合方式
DrawMask多了一个遮罩蒙层参数，Draw为其一种特殊形式（遮罩相关参数为nil）。

6. 转换

读取的jpg图像不是RGBA格式的（为YCbCr格式）；在操作前需要先转换格式：

创建一个大小相同的RGBA图像；
把jpg画到新建的图像上去；

1func jpg2RGBA(img image.Image) *image.RGBA {
2    tmp := image.NewRGBA(img.Bounds())
3
4    draw.Draw(tmp, img.Bounds(), img, img.Bounds().Min, draw.Src)
5    return tmp
6}

7. 裁剪

通过subImage方法可方便地裁剪图片（需要为RGBA格式的）

1func subImg() {
2    pic := readPic()
3    fmt.Printf("Type: %T\n", pic)
4    img := jpg2RCBA(pic)
5
6    sub := img.SubImage(image.Rect(0, 0, pic.Bounds().Dx(), pic.Bounds().Dy()/2))
7    savePic(sub.(*image.RGBA))
8}

8. 缩放

图片缩放分为保持比例与不保持比例的缩放；保持比例时，要确定新图片的位置（是否居中），以及如何填充空白处。为了缩放，需要引入新的库golang.org/x/image/draw。

在保持比例缩放时，需要先计算缩放后的图片大小：

分别计算宽、高的缩放比例，以小者为准；
若是居中（否则靠左上）需要计算填充大小，然后据此计算位置；

 1func calcResizedRect(width int, src image.Rectangle, height int, centerAlign bool) image.Rectangle {
 2    var dst image.Rectangle
 3    if width*src.Dy() < height*src.Dx() { // width/src.width < height/src.height
 4        ratio := float64(width) / float64(src.Dx())
 5
 6        tH := int(float64(src.Dy()) * ratio)
 7        pad := 0
 8        if centerAlign {
 9            pad = (height - tH) / 2
10        }
11        dst = image.Rect(0, pad, width, pad+tH)
12    } else {
13        ratio := float64(height) / float64(src.Dy())
14        tW := int(float64(src.Dx()) * ratio)
15        pad := 0
16        if centerAlign {
17            pad = (width - tW) / 2
18        }
19        dst = image.Rect(pad, 0, pad+tW, height)
20    }
21
22    return dst
23}

有了缩放后的大小后，即可通过双线性插值bilinear的方式进行图片的缩放

img为要缩放的图片width、height为缩放后的大小
keepRatio为是否保持比例缩放
fill为填充的颜色（R、G、B都为fill）
centerAlign：保持比例缩放时，图片是否居中存放

 1import (
 2    "image"
 3    "image/color"
 4
 5    "golang.org/x/image/draw"
 6)
 7
 8func resizePic(img image.Image, width int, height int, keepRatio bool, fill int, centerAlign bool) image.Image {
 9    outImg := image.NewRGBA(image.Rect(0, 0, width, height))
10    if !keepRatio {
11        draw.BiLinear.Scale(outImg, outImg.Bounds(), img, img.Bounds(), draw.Over, nil)
12        return outImg
13    }
14
15    if fill != 0 {
16        fillColor := color.RGBA{R: uint8(fill), G: uint8(fill), B: uint8(fill), A: 255}
17        draw.Draw(outImg, outImg.Bounds(), &image.Uniform{C: fillColor}, image.Point{}, draw.Src)
18    }
19    dst := calcResizedRect(width, img.Bounds(), height, centerAlign)
20    draw.ApproxBiLinear.Scale(outImg, dst.Bounds(), img, img.Bounds(), draw.Over, nil)
21    return outImg
22}

到此这篇关于golang图片处理库image简介的文章就介绍到这了

开源的GSE golang的高效分词库，支持英文、中文、日文等

Thu, 10 Nov 2022 20:35:07 +0800

1. 开源项目地址

https://github.com/go-ego/gse

2. 信息

GSE

词典用双数组 trie（Double-Array Trie）实现，分词器算法为基于词频的最短路径加动态规划。

支持 HMM 分词, 使用 viterbi 算法.

支持普通和搜索引擎两种分词模式，支持用户词典、词性标注，可运行 JSON RPC 服务。

分词速度单线程 9MB/s，goroutines 并发 42MB/s（8核 Macbook Pro）。

3. 安装/更新

1go get -u github.com/go-ego/gse

4. 开始一个新程序

1re gse my-gse

5. 运行

1cd my-gse && re run

6. 使用

 1package main
 2
 3import (
 4    "fmt"
 5
 6    "github.com/go-ego/gse"
 7)
 8
 9func main() {
10    var seg gse.Segmenter
11    // 加载默认字典
12    seg.LoadDict()
13    // 载入词典
14    // seg.LoadDict("your gopath"+"/src/github.com/go-ego/gse/data/dict/dictionary.txt")
15
16    text := "你好世界, Hello world."
17
18    hmm := seg.Cut(text, true)
19    fmt.Println("hmm cut: ", hmm)
20
21    hmm = seg.CutSearch(text, true)
22    fmt.Println("hmm cut: ", hmm)
23
24    hmm = seg.CutAll(text)
25    fmt.Println("cut all: ", hmm)
26
27    // 分词文本
28    tb: = []byte("山达尔星联邦共和国联邦政府")
29
30    // 处理分词结果
31    // 支持普通模式和搜索模式两种分词，见代码中 ToString 函数的注释。
32    // 搜索模式主要用于给搜索引擎提供尽可能多的关键字
33    fmt.Println("输出分词结果, 类型为字符串, 使用搜索模式: ", seg.String(tb, true))
34    fmt.Println("输出分词结果, 类型为 slice: ", seg.Slice(tb))
35
36    segments := seg.Segment(tb)
37    // 处理分词结果
38    fmt.Println(gse.ToString(segments))
39
40    text1 := []byte("深圳地标建筑, 深圳地王大厦")
41    segments1 := seg.Segment([]byte(text1))
42    fmt.Println(gse.ToString(segments1, true))
43}

Golang Httprequest

Thu, 10 Nov 2022 19:57:29 +0800

Go语言HttpRequest项目源码地址： https://github.com/kirinlabs/HttpRequest

主要实现功能

支持常用的GET、POST、DELETE、PUT等
GET 除了正常请求url，也可以附带"name=flyfreely&address=beijing"或者map[string]interface{} 两种参数，包会自动整合到QueryString中
POST 支持string, []byte, *bytes.Reader, *bytes.Buffer, *strings.Reader, map[string]interface{}等参数; 如果发送JSON请求，几乎可以支持发送所有数据类型。
支持自定义Transport

具有快速构建Headers、Cookies、设置超时时间、请求、耗时、打印请求信息等功能

安装：

1go get https://github.com/kirinlabs/HttpRequest

发送请求

导入HttpRequest

1import "github.com/kirinlabs/HttpRequest"

实例化：

1req := HttpRequest.NewRequest()

然后，尝试获取某个网页。我们来获取 Github 的公共时间线

1res,err := req.Get("https://api.github.com/events")

返回一个res的Response对象和err的Error对象

自定义Transport

 1var transport *http.Transport
 2 
 3func init() {   
 4    transport = &http.Transport{
 5        DialContext: (&net.Dialer{
 6            Timeout:   30 * time.Second,
 7            KeepAlive: 30 * time.Second,
 8            DualStack: true,
 9        }).DialContext,
10        MaxIdleConns:          100, 
11        IdleConnTimeout:       90 * time.Second,
12        TLSHandshakeTimeout:   5 * time.Second,
13        ExpectContinueTimeout: 1 * time.Second,
14    }
15}
16 
17func demo(){
18    // Use http.DefaultTransport
19    res, err := HttpRequest.Get("http://127.0.0.1:8080")
20 
21    // Use custom Transport
22    res, err := HttpRequest.Transport(transport).Get("http://127.0.0.1:8080")
23}

Post 请求

 1//无参请求
 2res,err := req.Post("https://www.baidu.com")
 3 
 4//发送整数类型
 5res,err := req.Post("https://www.baidu.com",uint32(100))
 6 
 7//发送[]byte
 8res,err := req.Post("https://www.baidu.com",[]byte("bytes data"))
 9 
10//发送*bytes.Reader,*strings.Reader,*bytes.Buffer
11data := bytes.NewReader(buf []byte)
12res,err := req.Post("https://www.baidu.com",data)
13res,err := req.Post("https://www.baidu.com",strings.NewReader("string data"))
14 
15//请求体为文本
16res,err := req.Post("https://www.baidu.com","hello")
17 
18 
19//请求体为Json字符串
20res,err := req.Post("https://www.baidu.com","{\"name\":\"github\"}")
21 
22 
23//map传参
24res.err := req.Post("https://www.baidu.com",map[string]interface{}{
25    "name":"github",
26    "type":1,
27})

也可以不用实例化，直接发送请求

 1//快速发送Get请求
 2res,err := HttpRequest.Get("https://www.baidu.com")
 3 
 4res,err := HttpRequest.Get("https://www.baidu.com","title=baidu")
 5 
 6 
 7//快速发送Post请求
 8res,err := HttpRequest.Post("https://www.baidu.com")
 9 
10//发送整数类型
11res,err := req.Post("https://www.baidu.com",uint32(100))
12 
13//发送[]byte
14res,err := req.Post("https://www.baidu.com",[]byte("bytes data"))
15 
16//发送*bytes.Reader,*strings.Reader,*bytes.Buffer
17res,err := req.Post("https://www.baidu.com",bytes.NewReader(buf []byte))
18res,err := req.Post("https://www.baidu.com",bytes.NewBuffer(buf []byte))
19res,err := req.Post("https://www.baidu.com",strings.NewReader("string data"))
20 
21 
22res,err := HttpRequest.Post("https://www.baidu.com","title=baidu&type=pdf")
23 
24res,err := HttpRequest.Post("https://www.baidu.com",map[string]interface{}{
25    "title":"baidu",
26})
27 
28 
29//快速发送JSON请求
30res,err := HttpRequest.JSON().Post("https://www.baidu.com",map[string]interface{}{
31    "title":"baidu",
32})
33 
34res,err := HttpRequest.JSON().Post("https://www.baidu.com",`{"title":"baidu","type":"pdf"}`)

传递URL参数

你想为URL的查询字符串(query string)传递数据。如：手工构建URL,http://www.baidu.com/index?key=value。HttpRequest允许你使用第2个参数以字符串"id=100&name=github"或map[string]interface{}{“id”:10,“name”:“github”}字典的形式把数据传递给URL：

手工传参：

1res,err := req.Get("https://www.baidu.com/index?name=github")

字符串传参：

1res,err := req.Get("https://www.baidu.com/index?name=github","id=100&type=1")

map传参：

1res,err := req.Get("https://www.baidu.com/index?name=github",map[string]interface{}{
2    "id":10,
3    "type":1,
4})

响应内容

能读取服务器响应的内容

1res,err := req.Post("https://api.github.com/events")

获取服务器返回的内容：

1body,err := res.Body()
2 
3fmt.Println(string(body))

获取服务器响应状态码：

1res.StatusCode()

获取服务器响应Headers:

1res.Headers()

返回一个map[string]string的字典

获取请求响应时间：

1res.Time()

Json响应内容

HttpRequest内置JSON解码，来解析JSON数据：

1//Format the json return value
2body, err := res.Json() 
3 
4fmt.Println(body)

如果JSON解码失败，会返回一个err错误

定制请求头

如果想为请求添加HTTP头部信息，只需要简单的传一个map给SetHeaders方法

1req.SetHeaders(map[string]string{
2    "Content-Type":"application/json",
3    "Source":"api",
4})

注：所有header值必须是字符串，SetHeaders可以多次调用，如果Key重复则会覆盖前面设置的值

BasicAuth 认证