Go module不但遵循语义化版本规范 2.0.0,而且还更进一步，对语义化版本中的major还还赋予了更深的意义。

阅读全文

昨天在GopherChina 2021大会上分享了《深入Go Module》，干货太多了，接下来的分几篇文章详细介绍下。

阅读全文

Go语言的channel有两种类型，一种是无缓存的channel，一种是有缓存的buffer，这两种类型的channel大家都比较熟悉了，但是对于有缓存的channel,它的缓存长度在创建channel的时候就已经确定了，中间不能扩缩容，这导致在一些场景下使用有问题，或者说不太适合特定的场景。

阅读全文

chromedp是一个更快更简单的支持Chrome DevTools Protocol协议的Go库，它是目前最流行的headless浏览器库之一，你可以使用它做很多只能通过浏览器才能执行的任务，比如网页截屏、网页渲染测试、下载视频、模拟登录等，今天我介绍它的一个有用而且很简单的功能：为一个网页生成一个pdf格式的截屏,更多的例子你可以查看官方示例chromedp/examples。

阅读全文

当前， rpcx支持tcp、kcp、quic、unix domain、http、jsonrpc 2.0等传输协议，并没有考虑websocket的支持，原因在于考虑到微服务更多的是企业内部服务之间的通讯，不太可能暴露给浏览器，企业内部大多采用tcp的方式传输，或者udp族(kcp、quic)方式的传输，但是还是有用户提出希望能支持websocket。

我想websocket可能还是会有一些场景下使用，比如游戏开发，移动端核服务端的通讯等等，所以经过慎重考虑，我决定在 rpcx 1.6.2版本中增加对websocket的支持。

基于rpcx良好的架构设计，实现对websocket的支持并不难。

本来，rpcx对kcp、quic的支持也不复杂，原因在于rpcx的通讯采用的net.Conn的这样一个通用的接口，listent.Accept方法接受客户端的请求后返回一个net.Conn对象，后续请求的解析、处理，写回都是在这个通用接口上操作的，所以非常容易支持新的传输协议。

• kcp: 基于xtaci/kcp-go库
• quic: 基于定制的smallnest/quick库，依赖uic-go的实现。

以前rpcx还支持其它的udp的扩展协议，比如

• uTP
• rudp

因为这两个协议用的人很少，所以在rpcx 1.6中把这两个协议的支持去掉了。

所以，对于websocket来说，找到一个可信赖的、合适的websocket库，可以很容易的实现基于websocket传输的微服务框架。

目前Go生态圈常用的websocket库如下：

• x/net/websocket
• gorilla/websocket: 老牌的gorilla框架提供的websocket库
• gobwas/ws
• nhooyr/websocket

虽然像gobwas/ws性能优良、gorilla/websocket功能齐全，但是考虑到API的便利性，我还是决定使用Go官方的x/net/websocket库，一来有官方背书，值得信赖，二来rpcx使用websocket功能比较简单，就是期望能获得一个net.Conn对象，x/net/websocket库正好能满足需求。

服务端

如果服务端采用websocket协议，那么network应该写成ws或者wss,而不是tcp或者quic。

服务端会启动一个http server处理websocket请求。 默认的websocket path为 share.DefaultRPCPath,只要服务端核客户端保持一致即可。

ServeWS会传入一个*websocket.Conn参数，它实现了net.Conn接口，所以后续的处理使用通用的s.serveConn(conn)即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

func (s *Server) Serve(network, address string) (err error) {
	......

	if network == "ws" || network == "wss" {
		s.serveByWS(ln, "")
		return nil
	}

	......
}


func (s *Server) serveByWS(ln net.Listener, rpcPath string) {
	s.ln = ln

	if rpcPath == "" {
		rpcPath = share.DefaultRPCPath
	}
	mux := http.NewServeMux()
	mux.Handle(rpcPath, websocket.Handler(s.ServeWS))
	srv := &http.Server{Handler: mux}

	srv.Serve(ln)
}

func (s *Server) ServeWS(conn *websocket.Conn) {
	s.mu.Lock()
	s.activeConn[conn] = struct{}{}
	s.mu.Unlock()

	s.serveConn(conn)
}

服务端的改造就如此简单，接下来看看如何部署一个服务端的websocket服务:

1
2
3
4
5
6
7
8
9
10

func main() {
	flag.Parse()

	s := server.NewServer()
	s.RegisterName("Arith", new(Arith), "")
	err := s.Serve("ws", *addr)
	if err != nil {
		panic(err)
	}
}

客户端

客户端最重要的是要实现一个websocket协议的建连，如果实现了这个方法，客户端的改造基本就完成了。这个方法的实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

func newDirectWSConn(c *Client, network, address string) (net.Conn, error) {
	if c == nil {
		return nil, errors.New("empty client")
	}
	path := c.option.RPCPath
	if path == "" {
		path = share.DefaultRPCPath
	}

	var conn net.Conn
	var err error

	// url := "ws://localhost:12345/ws"

	var url, origin string
	if network == "ws" {
		url = fmt.Sprintf("ws://%s%s", address, path)
		origin = fmt.Sprintf("http://%s", address)
	} else {
		url = fmt.Sprintf("wss://%s%s", address, path)
		origin = fmt.Sprintf("https://%s", address)
	}

	if c.option.TLSConfig != nil {
		config, err := websocket.NewConfig(url, origin)
		if err != nil {
			return nil, err
		}
		config.TlsConfig = c.option.TLSConfig
		conn, err = websocket.DialConfig(config)
	} else {
		conn, err = websocket.Dial(url, "", origin)
	}

	return conn, err
}

在建立连接的时候为ws和wss协议调用这个方法即可:

1
2
3
4
5
6
7
8
9
10
11
12

func (c *Client) Connect(network, address string) error {
	var conn net.Conn
	var err error

	switch network {
	case "http":
		conn, err = newDirectHTTPConn(c, network, address)
	case "ws", "wss":
		conn, err = newDirectWSConn(c, network, address)
	case "kcp":
		conn, err = newDirectKCPConn(c, network, address)
    .......

客户端改造完成后，我们写一个客户端调用改车把刚才启动的websocket服务:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

func main() {
	flag.Parse()

	d, _ := client.NewPeer2PeerDiscovery("ws@"+*addr, "")
	opt := client.DefaultOption
	opt.SerializeType = protocol.JSON

	xclient := client.NewXClient("Arith", client.Failtry, client.RandomSelect, d, opt)
	defer xclient.Close()

	args := example.Args{
		A: 10,
		B: 20,
	}

	reply := &example.Reply{}
	err := xclient.Call(context.Background(), "Mul", args, reply)
	if err != nil {
		log.Fatalf("failed to call: %v", err)
	}

	log.Printf("%d * %d = %d", args.A, args.B, reply.C)

}

所以你看到，对于一个新的传输协议来说，如果它的连接能够遵循net.Conn接口，rpcx支持它还是很容易的。

完整的使用websocket传输协议的例子: websocket example。

我在二月份的文章利好！极大可能在go 1.17中就能尝试泛型提到，虽然Go泛型会在Go 1.18中正式发布，但是因为各种原因，代码已经开始在master分支中实现，所以极大可能你会在今年9月份发布的Go 1.17中就能尝试使用Go泛型。

那么，现在，可以去掉"可能"这两个字了。在Go 1.17可以确定的说你能够尝试Go泛型编程了，尽管建议你还是在Go 1.18以及以后的版本才正式在产品中使用泛型。

阅读全文

代码覆盖率是软件测试中的一种度量，描述程序中源代码被测试的比例和程度，所得比例称为代码覆盖率。

阅读全文

你也知道，Go 将在1.18 中正式支持泛型。依照Go每年发布两个版本的节奏，Go 1.18会在2022年春,也就是二月份左右发布，但是有可能你会在Go 1.17中尝鲜。

Go的泛型近一年来一直由Ian Lance Taylor(编译器大牛、Go核心成员)和Robert Griesemer（Go创始三巨头之一，Google V8、Chubby和HotSpot JVM的主要贡献者）等人开发，一直在dev.typeparams分支上做预研和开发工作。

阅读全文

Go编译的程序非常适合部署，如果没有通过CGO引用其它的库的话，我们一般编译出来的可执行二进制文件都是单个的文件，非常适合复制和部署。在实际使用中，除了二进制文件，可能还需要一些配置文件，或者静态文件，比如html模板、静态的图片、CSS、javascript等文件，如何这些文件也能打进到二进制文件中，那就太美妙，我们只需复制、按照单个的可执行文件即可。

一些开源的项目很久以前就开始做这方面的工作，比如gobuffalo/packr、markbates/pkger、rakyll/statik、knadh/stuffbin等等，但是不管怎么说这些都是第三方提供的功能，如果Go官方能内建支持就好了。2019末一个提案被提出issue#35950,期望Go官方编译器支持嵌入静态文件。后来Russ Cox专门写了一个设计文档Go command support for embedded static assets, 并最终实现了它。

Go 1.16中包含了go embed的功能，而且Go1.16基本在一个月左右的时间就会发布了，到时候你可以尝试使用它，如果你等不及了，你也可以下载Go 1.16beta1尝鲜。

本文将通过例子，详细介绍go embed的各个功能。

阅读全文

Go语言语法简单，学习起来容易，也容易上手，所以越来越多的公司和个人采用Go语言开发应用程序。不管使用什么语言，内存泄露是经常遇到的一类问题，而使用Go语言编写内存泄露的代码却不容易，本文将教你几招编写出内存泄露的代码，以满足你创造出内存泄露bug的心里需求。

即使你编写出内存泄露的bug,一般来说也很容易通过pprof查找出来，或者通过pprof的两次对比中找出哪一块出现的问题，所以不要因为写出bug就沾沾自喜，此类bug还是很容易被发现的。

阅读全文