

[TOC]

# 环境

后端

-   语言golang
-   数据库elastisearch
-   web框架是基于[gin](https://gin-gonic.com/zh-cn/docs/)封装的
-   websocket库用的是[gorilla/websocket](https://github.com/gorilla/websocket)
-   日志: [zap](https://github.com/uber-go/zap)
-   Error: [pkg/errors](https://github.com/pkg/errors)

前端

-   框架: [react](https://zh-hans.reactjs.org/docs/getting-started.html)
-   服务端渲染: [nextjs](https://nextjs.org/docs/api-reference/next.config.js/static-optimization-indicator)
-   UI: [Material UI](https://material-ui.com/zh/components)
-   登录认证:  cookie [nookie](https://github.com/maticzav/nookies)  
-   websocket是浏览器原生支持
-   后续聊天功能模仿：[https://getstream.io/](https://github.com/GetStream/stream-chat-react)

登录

- [github OAuth documentation](https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/)
- [google Sign-In for Websites](https://developers.google.com/identity/sign-in/web)

# 如何建立连接

-   [websocket协议](https://www.cnblogs.com/chyingp/p/websocket-deep-in.html)

websocket复用http的握手通道，客户端通过HTTP请求与WebSocket服务端协商升级协议，协议升级完成后，后续的数据交换则按按照websocket的协议。

**1. 客户端：申请协议升级**

```http
Connection: Upgrade
Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits
Sec-WebSocket-Key: m3xNMIzhueJyd3N66EAK6w==
Sec-WebSocket-Version: 13
Upgrade: websocket
```

-   `Connection: Upgrade` 表示要升级协议
-   `Upgrade: websocket`  升级到websocket协议
-   `Sec-WebSocket-Version: 13` websocket协议版本，如果服务端不支持该版本，需要返回一个`Sec-WebSocket-Version`header，里面包含服务端支持的版本号。

-   `Sec-WebSocket-Key: m3xNMIzhueJyd3N66EAK6w==` 与后面服务端响应首部的`Sec-WebSocket-Accept`是配套的，提供基本的防护，比如恶意的连接，或者无意的连接

**2. 服务端：响应协议升级**

```http
HTTP/1.1 101 Switching Protocols
Connection: upgrade
Sec-WebSocket-Accept: qgWIKoKflyd9H8L/jCNa8XP4CYQ=
Upgrade: websocket
```

状态代码`101`表示协议切换。到此完成协议升级，后续的数据交互都按照新的协议来。

**3. Sec-WebSocket-Accept的计算**

`Sec-WebSocket-Accept`根据客户端请求首

`Sec-WebSocket-Accept`根据客户端请求首部的`Sec-WebSocket-Key`计算出来。

计算公式为：

1.  将`Sec-WebSocket-Key`跟`258EAFA5-E914-47DA-95CA-C5AB0DC85B11`拼接。
2.  通过SHA1计算出摘要，并转成base64字符串。

伪代码如下：

```
>toBase64( sha1( Sec-WebSocket-Key + 258EAFA5-E914-47DA-95CA-C5AB0DC85B11 )  )
```

验证下前面的返回结果：

```js
const crypto = require('crypto');
const magic = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
const secWebSocketKey = 'm3xNMIzhueJyd3N66EAK6w==';

let secWebSocketAccept = crypto.createHash('sha1')
    .update(secWebSocketKey + magic)
    .digest('base64');

console.log(secWebSocketAccept);
// qgWIKoKflyd9H8L/jCNa8XP4CYQ=
```

# 前端难点

**服务端渲染框架如何使用cookie**

nextjs是服务端渲染框架，nextjs会请求是在服务器上初始化一次dom，要获取cookie可以有2种方式

1. 从请求request中获取cookie，返回给组件
2. 客户端请求完成后用hook从浏览器本地加载cookie

cookie 库用的是 [nookies](https://github.com/maticzav/nookies)

```js
React.useEffect(() => {
  const all = parseCookies();
  if (all.douyacun) {
    const douyacun = JSON.parse(all.douyacun);
    setCook(douyacun);
  }
}, []);
```

另一个就是本地开发cookie跨域的问题, 本地域名localhost:3000,服务端域名localhost:9000：

本来是想用[http-proxy-middleware](https://github.com/chimurai/http-proxy-middleware) 来解决跨域的问题，但是websocket代理关于cookie的问题难以搞定，版本是1.0.3

最后还是nginx了，怎么统一一个域名呢？location，后端服务统一以api开头

```nginx
server {
	listen 80;
	server_name douyacun.io;

	location /api/ {
        		if ($request_method = 'OPTIONS') {
      					return 204;
           	}
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header Host  $http_host;
            proxy_set_header X-Nginx-Proxy true;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection 'upgrade';

    				# 不需要考虑到负载的，就无需配置upstream节点。
    				proxy_pass    http://127.0.0.1:9003;
        }
	location / {
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header Host  $http_host;
            proxy_set_header X-Nginx-Proxy true;
            proxy_set_header Connection "";

            # 不需要考虑到负载的，就无需配置upstream节点。
            proxy_pass    http//127.0.0.1:3000;
  }
}
```

修改本地dns douyacun.io => 127.0.0.1

**如何保证websocket初始化一次**

还是因为框架用的nextjs服务端渲染框架，不能在全局初始化websocket，只能在useEffect中使用

```js
useEffect(() => {
  initWebsocket();
  return () => {
  }
});
const initWebsocket = () => {
  conn = new WebSocket(WS_ADDRESS);
  conn.onmessage = handlerMessage;
  conn.onclose = function () {
    dispatch({ type: "dialog_open", dialogOpen: true })
  };
  conn.onerror = function () {
    console.log("连接失败");
  }
}
```

这样会有一个问题，只要有state变更，useEffect就会被调用，导致webSocket循环初始化

> todo: 后端服务如何识别这种重复性的初始化，如何拒绝？

react hook 文档给出了答案

> the **previous effect is cleaned up before executing the next effect**. In our example, this means a new subscription is created on every update. To avoid firing an effect on every update, refer to the next section. 
>
> 意味着组件的每一次更新都会创建新的订阅
>
> If you pass an empty array (`[]`), the props and state inside the effect will always have their initial values, 
>
> useEffect第二个参数传 []， 就不回每次state变更都调用了。

```js
useEffect(() => {
  initWebsocket();
  return () => {
  }
}, []);
```

**conn.onmessage(() => {setMessages()}) 不会触发state组件的重新渲染？**

这个问题没有弄懂，不过react hook提供另一种状态管理，useReducer(), 就像redux一样。

> state 逻辑较复杂且包含多个子值，或者下一个 state 依赖于之前的 state 等。并且，使用 `useReducer` 还能给那些会触发深更新的组件做性能优化，

**滑动条的位置**

1. 收到新消息时，滑动条回到最底部

hook 提供了useRef可以操作组件, 在收到消息时，控制滑动条到最底部，

```jsx
const scrollToBottom = () => {
  // 保证消息在最下面
  contentRef.current.scrollTop = contentRef.current.scrollHeight
}
const handlerMessage = function (evt) {
  let msg = JSON.parse(evt.data)
  dispatch({ type: "new_message", msg: msg, channel_id: msg['channel_id'] });
  scrollToBottom();
}

<div className="scrollable content" ref={contentRef} onScroll={upScrollLoadMore}>
  ...
</div>
```

2. 上拉加载更多历史消息

滑动条高度 = 加载历史消息完成后文档高度 - 加载前文档高度

```jsx
// 这里是为了在加载完成后，在控制滑动条位置，如果不是hook的话，setState(state, () => {})，第二个参数回掉函数完成，hook使用useEffect的代替了这种方式
useEffect(() => {
  // loadMore 是请求后端的接口
  let t = setTimeout(loadMore, 1000);
  if (!loading) {
    // 滑动条高度 = 加载历史消息完成后文档高度 - 加载前文档高度
    contentRef.current.scrollTop = contentRef.current.scrollHeight - messagesHeight;
  }
  return () => {
    clearTimeout(t);
  }
}, [loading]);

// contentRef.onScroll
const upScrollLoadMore = () => {
  let scrollTop = contentRef.current.scrollTop;
  // 记录加载前文档的高度
  let channelMessages = state.messages[state.currentId];
  if (scrollTop == 0 && !loading && channelMessages && channelMessages.length > 0) {
    let channel = getChannelById(state.currentId);
    if (channel.total > 0) {
      setloading(true);
    }
  }
}
```

3. 正在查看历史消息，如果有新消息来会导致滑动条到最底部

todo::

# nginx如何反向代理websocket?

前端开发环境配置的时候已经展示过一次

- `proxy_http_version 1.1;` : 代理http版本号
- `proxy_set_header Upgrade $http_upgrade;`: http协议升级的请求头Upgrade传给后端
- `proxy_set_header Connection 'upgrade';` http协议升级的请求头Connection传给后端



# 群聊和私聊是如何实现的

不管是私聊还是群聊，都会创建一个channel来包含成员，每次消息发送消息指定channel.id即可，服务器在收到消息后，根据channel.id向channel.members推送消息。

channel分了3中类型：

- global 全局，每个人都会订阅
- public 群聊 聊天人数超过2个
- private 私聊 聊天人群2个



# 一个连接的成本是多少？

这边使用[gorilla/websocket](https://github.com/gorilla/websocket/blob/master/examples/chat/main.go) 1万个连接测试

占用147.93MB RAM, 平均连接每个占用15kb 测试代码见：[github gwebsocket](https://github.com/douyacun/gwebsocket/blob/master/v3_ws_ulimit/wsserver.go)

```shell
(pprof) top
Showing nodes accounting for 137.93MB, 93.24% of 147.93MB total
Dropped 6 nodes (cum <= 0.74MB)
Showing top 10 nodes out of 51
      flat  flat%   sum%        cum   cum%
   73.79MB 49.88% 49.88%    73.79MB 49.88%  bufio.NewWriterSize
   34.63MB 23.41% 73.29%    34.63MB 23.41%  bufio.NewReaderSize
      11MB  7.44% 80.73%       11MB  7.44%  runtime.malg
       4MB  2.70% 83.44%     5.50MB  3.72%  net/textproto.(*Reader).ReadMIMEHeader
       3MB  2.03% 85.46%     3.50MB  2.37%  github.com/gorilla/websocket.newConn
       3MB  2.03% 87.49%    10.50MB  7.10%  net/http.readRequest
    2.50MB  1.69% 89.18%    16.50MB 11.16%  net/http.(*conn).readRequest
    2.50MB  1.69% 90.87%     3.50MB  2.37%  context.propagateCancel
       2MB  1.35% 92.23%        2MB  1.35%  syscall.anyToSockaddr
    1.50MB  1.01% 93.24%     1.50MB  1.01%  net.newFD
(pprof) web
failed to execute dot. Is Graphviz installed? Error: exec: "dot": executable file not found in $PATH
(pprof) list flat
Total: 147.93MB
```

goroutine是10003，每个goroutine占用4kb的内存

```shell
(pprof) top
Showing nodes accounting for 10001, 100% of 10003 total
Dropped 24 nodes (cum <= 50)
Showing top 10 nodes out of 19
      flat  flat%   sum%        cum   cum%
     10001   100%   100%      10001   100%  runtime.gopark
         0     0%   100%       9998   100%  bufio.(*Reader).Peek
         0     0%   100%       9998   100%  bufio.(*Reader).fill
         0     0%   100%       9999   100%  github.com/gorilla/websocket.(*Conn).NextReader
         0     0%   100%       9999   100%  github.com/gorilla/websocket.(*Conn).ReadMessage
         0     0%   100%       9999   100%  github.com/gorilla/websocket.(*Conn).advanceFrame
         0     0%   100%       9998   100%  github.com/gorilla/websocket.(*Conn).read
         0     0%   100%       9999   100%  internal/poll.(*FD).Read
         0     0%   100%      10001   100%  internal/poll.(*pollDesc).wait
         0     0%   100%      10001   100%  internal/poll.(*pollDesc).waitRead (inline)
(pprof) list flat
Total: 10003
(pprof)
```

根据  Eran Yanay 在 Gophercon Israel 分享的讲座 [https://www.youtube.com/watch?reload=9&v=LI1YTFMi8W4](https://www.youtube.com/watch?reload=9&v=LI1YTFMi8W4) 优化,  代码在[github](https://github.com/eranyanay/1m-go-websockets)


- 使用epoll优化, 复用goroutine， goroutine适合cpu密集型，而epoll适合I/O密集型，这里使用epoll来复用goroutine， 如果是1万个链接的话, 4kb *  10000 / 1024 ~= 39M , epoll的原理和用法可以看一下，[了解一下高大上的epoll](/article/4a999859dea85d6d65f34b0fc8c22f25)

这边使用epoll 内存节省了 147.93 - 79.94 = 67.99MB, 

```shell
(pprof) top
Showing nodes accounting for 79.94MB, 100% of 79.94MB total
Showing top 10 nodes out of 37
      flat  flat%   sum%        cum   cum%
   38.65MB 48.35% 48.35%    38.65MB 48.35%  bufio.NewReaderSize (inline)
   30.12MB 37.67% 86.02%    30.12MB 37.67%  bufio.NewWriterSize
    4.50MB  5.63% 91.65%        5MB  6.26%  github.com/gorilla/websocket.newConn
    2.50MB  3.13% 94.78%     2.50MB  3.13%  net.sockaddrToTCP
       2MB  2.50% 97.28%        2MB  2.50%  syscall.anyToSockaddr
    0.67MB  0.84% 98.12%     0.67MB  0.84%  main.(*epoll).Add
    0.50MB  0.63% 98.75%     0.50MB  0.63%  fmt.(*pp).handleMethods
    0.50MB  0.63% 99.37%     0.50MB  0.63%  net.newFD
    0.50MB  0.63%   100%     0.50MB  0.63%  github.com/gorilla/websocket.(*Conn).SetPingHandler
         0     0%   100%    38.65MB 48.35%  bufio.NewReader
(pprof) list flat
Total: 79.94MB
```

运行的goroutine只有5个

```shell
(pprof) top
Showing nodes accounting for 5, 100% of 5 total
Showing top 10 nodes out of 35
      flat  flat%   sum%        cum   cum%
         2 40.00% 40.00%          2 40.00%  runtime.gopark
         1 20.00% 60.00%          1 20.00%  runtime/pprof.writeRuntimeProfile
         1 20.00% 80.00%          1 20.00%  syscall.Syscall
         1 20.00%   100%          1 20.00%  syscall.Syscall6
         0     0%   100%          2 40.00%  internal/poll.(*FD).Accept
         0     0%   100%          1 20.00%  internal/poll.(*FD).Read
         0     0%   100%          2 40.00%  internal/poll.(*pollDesc).wait
         0     0%   100%          2 40.00%  internal/poll.(*pollDesc).waitRead (inline )
         0     0%   100%          2 40.00%  internal/poll.runtime_pollWait
         0     0%   100%          1 20.00%  main.(*epoll).Wait
(pprof) list flat
Total: 5
```

- 从上面内存占用情况来看还是buf占用内存比较多，接下来就考虑优化buf的使用。go websocket库有2个比较推荐，第一个就是上面一直用的另一个是：[gobwas/ws](https://github.com/gobwas/ws)， gobwas有几个特性：
  - Zero-copy upgrade
  - No intermediate allocations during I/O
  - Low-level API which allows to build your own logic of packet handling and buffers reuse
  - High-level wrappers and helpers around API in `wsutil` package, which allow to start fast without digging the protocol internals

1w个链接3M内存,  5个goroutine

```shell
(pprof) top
Showing nodes accounting for 3328.46kB, 100% of 3328.46kB total
Showing top 10 nodes out of 20
      flat  flat%   sum%        cum   cum%
 1024.12kB 30.77% 30.77%  1024.12kB 30.77%  net.newFD (inline)
 1024.05kB 30.77% 61.54%  1024.05kB 30.77%  net.sockaddrToTCP
  768.26kB 23.08% 84.62%   768.26kB 23.08%  main.(*epoll).Add
  512.03kB 15.38%   100%   512.03kB 15.38%  syscall.anyToSockaddr
         0     0%   100%   512.03kB 15.38%  internal/poll.(*FD).Accept
         0     0%   100%   512.03kB 15.38%  internal/poll.accept
         0     0%   100%  2560.20kB 76.92%  main.main
         0     0%   100%   768.26kB 23.08%  main.wsHandle
         0     0%   100%  2560.20kB 76.92%  net.(*TCPListener).Accept
         0     0%   100%  2560.20kB 76.92%  net.(*TCPListener).accept
(pprof) list flat
Total: 3.25MB

(pprof) top
Showing nodes accounting for 5, 100% of 5 total
Showing top 10 nodes out of 35
      flat  flat%   sum%        cum   cum%
         2 40.00% 40.00%          2 40.00%  runtime.gopark
         1 20.00% 60.00%          1 20.00%  runtime/pprof.writeRuntimeProfile
         1 20.00% 80.00%          1 20.00%  syscall.Syscall
         1 20.00%   100%          1 20.00%  syscall.Syscall6
         0     0%   100%          2 40.00%  internal/poll.(*FD).Accept
         0     0%   100%          1 20.00%  internal/poll.(*FD).Read
         0     0%   100%          2 40.00%  internal/poll.(*pollDesc).wait
         0     0%   100%          2 40.00%  internal/poll.(*pollDesc).waitRead (inline)
         0     0%   100%          2 40.00%  internal/poll.runtime_pollWait
         0     0%   100%          1 20.00%  main.(*epoll).Wait
(pprof) list flat
Total: 5
```

# heartbeat？？？

使用gobws重构了一下聊天室，每隔一段时间，如果不发消息连接会自动断开，问题定位在nginx上，代理超时的机制，2次读之间的超时。

```nginx
server {
        listen 80;
        server_name douyacun.io;

        location /api/ {
                if ($request_method = 'OPTIONS') {
                        return 204;
                }
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header Host  $http_host;
                proxy_set_header X-Nginx-Proxy true;
                proxy_http_version 1.1;
                proxy_set_header Upgrade $http_upgrade;
                proxy_set_header Connection 'upgrade';

                # 不需要考虑到负载的，就无需配置upstream节点。
                proxy_pass    http://127.0.0.1:9003;
        }
        location / {
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header Host  $http_host;
                proxy_set_header X-Nginx-Proxy true;
                proxy_set_header Connection "";

                # 不需要考虑到负载的，就无需配置upstream节点。
                proxy_pass    http://127.0.0.1:3000;
        }
}
```

nginx有2个参数是涉及到timeout

- proxy_read_timeout 默认值 60s   该指令设置与代理服务器的读超时时间。它决定了nginx会等待多长时间来获得请求的响应。 这个时间不是获得整个response的时间，而是两次reading操作的时间。
- proxy_send_timeout 默认值 60s  这个指定设置了发送请求给upstream服务器的超时时间。超时设置不是为了整个发送期间，而是在两次write操作期间。 如果超时后，upstream没有收到新的数据，nginx会关闭连接

**如何解决**？

通过定期发送ping帧以保持连接并确认连接是否还在使用

**定时给scoket发送ping消息？**

如果每个connection持有一个goroutine的话，初始化一个ticker定时器每隔N秒发送一次ping就ok了，问题是我们使用epoll来节省goroutine

TODO:: epoll如何实现定时轮询





# 如何限流，防止ddos

https://studygolang.com/articles/13254

# 如何实现分布式?

https://learnku.com/articles/39701

https://cloud.tencent.com/developer/article/1509469

一直以来对websocket保持一颗崇拜的心，php这方面比较弱势，学习go语言以后开发一套聊天功能，一起参观一下

golang开发的聊天室


### 背景：

数据库是联合主键，取出数据后存在map里面按主键直接取数据，以 date + campaign_id + adgroup_id + ad_id 作为唯一索引。以 struct做为map key是可以的，但是struct中有 time.time 不确定是否可行。

官方给出的答案是：key1 == key2 ，能否可以比较

实践了几种需要作为hash map key的情形：

1. pointer
2. struct
3. channel
4. slice



### 实践：

**struct 作为map key**

struct包含time、int64 ，2者都是可以相互比较的，struct就是可比较的。

```go
type TimeStruct struct {
	Date time.Time
	Id   int64
}

func main() {
	dat, _ := time.Parse("2006-01-02", "2021-06-22")

	t1 := TimeStruct{
		Date: dat,
		Id:   1,
	}

	t2 := TimeStruct{
		Date: dat,
		Id:   1,
	}

	mapList := map[TimeStruct]int64{
		TimeStruct{
			Date: dat,
			Id:   1,
		}: 1,
		TimeStruct{
			Date: dat,
			Id:   2,
		}: 2,
	}

	fmt.Println("> 输出：", mapList[t1], mapList[t2])
}

> 输出：1 1
```

在试一下结构体中包含 sync.mutex

```go
type TimeStruct struct {
  Date time.Time
  Id   int64
  mu   sync.Mutex
}
fmt.Println("> 输出：", mapList[t1], mapList[t2])
> 输出： 1 1
```

mutex 同样是一个结构体, 里面包含state，sema都是可以比较的。所以包含mutex也是可以比较。

```go
type Mutex struct {
	state int32
	sema  uint32
}
```



**pointer作为map key**

指针在go中是可以进行比较的，但是不能运算，理论上也是可以作为map key。但是不太建议作为map key取值。

指针指向的是内存地址。内存地址一样才是相同的。即使结构体的值一样，如果属于2个不同的变量，那么内存地址就是不一样的无法作为取到 map value的。

t2就是直接变量指针作为key，t2可以取到对应的值，t1与map 第一个key内存地址不一致无法取到对应的值。

```go
type TimeStruct struct {
		Date time.Time
		Id   int64
		mu   sync.Mutex
	}
	dat, _ := time.Parse("2006-01-02", "2021-06-22")
	t1 := TimeStruct{
		Date: dat,
		Id:   1,
		mu:   sync.Mutex{},
	}
	t2 := &TimeStruct{
		Date: dat,
		Id:   2,
		mu:   sync.Mutex{},
	}
	mapList := map[*TimeStruct]int64{
		&TimeStruct{
			Date: dat,
			Id:   1,
			mu:   sync.Mutex{},
		}: 1,
		t2: 2,
	}
	fmt.Println("> 输出：", mapList[&t1], mapList[t2])

> 输出： 0 2
```



**channel struct作为map key**

go make(chan string) 以后返回的是指针。channel作为map key 可以和 指针结构体作为map key 看作是同一个问题:

```go
fmt.Printf("%+v", make(chan string, 0))

0xc00008c060
```



**slice struct 作为map key**

看了make chan返回指针以后，make slice也是返回的指针？不是

slice不能作为map key，slice 无法进行相等比较的

Invalid operation: t1 == t2 (the operator == is not defined on []string)

数据库有联合主键，取出数据后存在map里面按主键直接取数据

go语言struct能否作为map的key


背景：之前开发的聊天是的功能，用的人太少了，考虑再三就决定去掉聊天室的功能了，改做一些其他有意思的事情，比如目前已经开发好了的左边栏当前在线人数，阅读时长统计（正在开发中）

遇到的问题：

- 页面虽然是react写的，但是nextjs服务端渲染的，不是单页应用就不能像单页应用那样有全局变量存储整站的websocket
- 服务端使用nginx作为代理服务器（之前是kong，后来干掉了），nginx proxy模块默认有 read_timeout/send_timeout 默认值 60s
- 服务端socket存储数据结构选型
- 安全防护

实现思路：

因为是多页模式，就需要每个页面初始化一个wss连接，按cookie去重以后就是当前在线人数。

页面wss重联机制，毕竟断网是很常见的

```jsx
/**
* websocket: 初始化 
*/
const connect = () => {
  conn = new WebSocket(ws_address);
  conn.onmessage = handlerMessage;
  // ws 关闭需要重新连接，每隔1s尝试1次
  conn.onclose = function (e) {
    console.log('Socket is closed. Reconnect will be attempted in 1 second.', e.reason);
    setTimeout(function () {
      connect();
    }, 1000);
  };
  // 连接失败
  conn.onerror = function (e) {
    console.error('Socket encountered error: ', e.message, 'Closing socket');
    conn.close()
  }
}
```



nginx：proxy_read_timeout/proxy_send_timeout默认60s超时，心跳检测，只需要服务端在60s内定时发送ping(0x9)消息就可以了，浏览器会自动回复pong消息

```go
for {
  select {
    // 定时向客户端推送，当前在线人数
    case <-countTicker.C:
    c.send <- c.hub.Count().Bytes()
    // 定时心跳检测
    case <-pingTicker.C:
    _ = c.conn.SetWriteDeadline(time.Now().Add(writeWait))
    if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
      return
    }
  }
}
```



服务端存储socket结构体，没有向指定socket写数据的需求，不需要额外维护socket的数据结构，维护一个cookie在线页面数即可

```go
type Hub struct {
	// Registered uid
	uuid map[string]int
	// Inbound messages from the clients.
	broadcast chan Responser
	// Register requests from the clients.
	register chan *Client
	// Unregister requests from clients.
	unregister chan *Client
}

func (h *Hub) Run() {
  for {
    select {
      case client := <-h.register:
      // 注册ws
      h.uuid[client.uuid]++
      client.send <- hub.Count().Bytes()
      case client := <-h.unregister:
      // 删除ws
      h.uuid[client.uuid]--
      if h.uuid[client.uuid] == 0 {
        delete(h.uuid, client.uuid)
      }
    }
  }
```

安全方面需要考虑的内容是：

1. 如何检测跨站点 WebSocket 劫持漏洞?
2. 同一设备  ws 连接数如何限制，避免bug导致连接数过多导致服务挂掉?

解决方法：

1. check origin, 确保是自己网站的来源
2. 服务器端为每个 WebSocket 客户端生成唯一的一次性 Token；
3. 客户端将 Token 作为 WebSocket 连接 URL 的参数（譬如 wss://www.douyacun.com/?token＝randomOneTimeToken），发送到服务器端进行 WebSocket 握手连接；
4. 服务器端验证 Token 是否正确，一旦正确则将这个 Token 标示为废弃不再重用，同时确认 WebSocket 握手连接成功；如果 Token 验证失败或者身份认证失败，则返回 403 错误。
5. 限流，限制设备最多最大链接数，必要时，deny ip地址

鉴于之前开发的聊天功能没人用，考虑在三去掉了聊天功能，改成统计当前在线人数

websocket如何实现统计当前在线人数

[TOC]

版本:

- go 1.13.4
- tcmalloc  gperftools 2.7

我是学习go源码时看到go内存分配使用tcmalloc,早在看redis源码时就了解到tcmalloc了，redis支持zmalloc、tcmalloc、jemalloc几种内存分配，之前只是看了redis自带的zmalloc,没深入了解一下tcmalloc。看来存在必有其道理，不定啥时候就用到

- https://github.com/gperftools/gperftools
- [TCMalloc : Thread-Caching Malloc](http://goog-perftools.sourceforge.net/doc/tcmalloc.html)

学习内存分配，就要先了解一下物理内存的相关概念和描述：

- [linux物理内存描述](http://www.ilinuxkernel.com/files/Linux_Physical_Memory_Description.pdf)
- [Linux物理内存页面分配](http://www.ilinuxkernel.com/files/Linux_Physical_Memory_Page_Allocation.pdf)
- [linux内存地址映射](http://www.ilinuxkernel.com/files/Linux_Memory_Address_Mapping.pdf)

看完这些以后总结了几个问题：

- 什么是逻辑地址、线性地址、物理地址，linux是如何进行地址映射的？

- linux是管理内存的(NUMA), 节点(node)、区域(zone)、page(页面)？

- 为什么一个16G的内存，内核需要160M维护page_table？

- 什么是缺页异常？（给顶的逻辑地址不合法，逻辑页面没有对应的物理页面，MMU将会产生中断，向核心发出信号）


# 基础知识

## 堆栈

![](/images/blog/1/golang/assert/堆栈.png)

进程如何分配内存：

1. static alloction: 声明全局变量时属于静态分配，该空间只会分配一次，并且永远不会释放。
2. automatic allocation: 声明函数参数/局部变量 的复合语句会自动栈空间，复合语句推出时会自动释放变量
3. dynamic allocation: malloc/free

# TCMalloc

1. **TCMalloc要比操作系统提供glibc 2.3 malloc（ptmalloc2）内存分配快**。内存的分配速度和合适的大小对于开发者来说非常重要，如果满足不了开发者的需求可能更倾向于自己实现内存分配规则
2. **TCMalloc减少了多线程之间的锁竞争**。对于小对象分配，几乎是0竞争，对于大对象，TCMalloc使用避免上下文切换的自旋锁，ptmalloc2使用per thread arenas(每个线程都会有自己的锁，避免线程之间的竞争)，问题是内存无法从arenas移动到另外一个arenas。例如：线程一申请一块300M内存，任务完成后。线程二在相同的地址空间启动，如果两个线程绑定了不同arena,线程一申请的300M内存就无法复用，必须重新申请，导致内存爆炸。
3. **TCMalloc另一个优势是对琐碎内存的高效利用**。
> 自旋锁：多线程同步的一种锁，线程反复检查锁变量是否可用。由于线程在这一过程中保持执行，因此是一种忙等待。一旦获取了自旋锁，线程会一直保持该锁，直至显式释放自旋锁。自旋锁避免了进程上下文的调度开销，因此对于线程只会阻塞很短时间的场合是有效的 - [摘自维基百科](https://zh.wikipedia.org/wiki/自旋锁)

## 概述

基本思想: 小内存通过线程层次缓存分配(无锁，速度快)，分配失败后请求上层补一批，前面分配了过多的内存则回收

线程:

ThreadCache: 每个线程私有一份，尺寸小于256K的小内存申请均由ThreadCache进行分配，线程之间不需要竞争，非常高效。节省了加锁释放锁的时间。

全局: 

PageHeap: 中央堆处理器，被所有线程共享（分配需要锁定），负责和操作系统申请、释放内存，大尺寸内存申请直接通过PageHeap分配，

CentralCache: 作为PageHeap和ThreadCache的中间人，负责将PageHeap的内存切分为小块，恰当时机分配给ThreadCache，回收ThreadCache的内存并部分返还给PageHeap

span: 一块连续的内存页。
object: object是由span切分成的小块，object预设了一些规则，如8byte、16byte、32bbyte..., 同一个span切出来的object都是相同的规格，object不大于256k，超大内存直接分配span使用\

ThreadCache、CentralCache管理object, PageHeap管理的是span

## PageHeap 大内存分配

大对象（>32k）对齐内存页面4k(4的倍数)， 由central page heap处理，central page heap也是一个数组

k个pages分配过程：

1. 查看k个页面的空闲列表（free_list）。
2. 如果free_list为空，看下一个空闲列表是否有，如此循环
3. 最终，查询到最后一个空闲列表
4. 如果匹配失败，会从操作系统申请
5. 如果有大于k个page的空闲列表，会分配k给当前申请，剩下的pages会重新插入到相应的空闲列表中。

```c++
// 根据起始page的位置和长度确定span的范围
struct Span {
  PageID        start;          // Starting page number
  Length        length;         // Number of pages in span
  Span*         next;           // 注意，这里span结构一个双向链表
  Span*         prev;           // 
  union {
    void* objects;              // Span会在CentralFreeList中拆分成由object组成的free list
    char span_iter_space[sizeof(SpanSet::iterator)];
  };
  unsigned int  refcount : 16;  // span的object被引用次数，refcount = 0时表示此span没有被使用
  unsigned int  sizeclass : 8;  // span被切分的object属于哪个级别的sizeClass
  unsigned int  location : 2;   // Span在的位置IN_USE？normal？returned？
  unsigned int  sample : 1;     // Sampled jobject?
  bool          has_span_iter : 1; 
  // What freelist the span is on: IN_USE if on none, or normal or returned
  enum { IN_USE, ON_NORMAL_FREELIST, ON_RETURNED_FREELIST };
};
```
- IN_USE：正在使用 ON_NORMAL_FREELIST：未被使用 ON_RETURNED_FREELIST：用户已经归还

> refcount、sizeclass、objects数据CentralFreeList管理的内存

PageHeap维护了
- page和span的关系
- 空闲span的伙伴关系

PageHeap结构体

```c++
class PERFTOOLS_DLL_DECL PageHeap {
  PageMap pagemap_;
  struct SpanList {
    Span        normal;
    Span        returned;
  };
  SpanSet large_normal_;
  SpanSet large_returned_;

  SpanList free_[kMaxPages];
};
```

- PageMap pagemap_ 维护id和Page的映射关系
- 大于kMaxPages页面统一存放在large_normal_中，不在按照页面数目区分

## CentralCache
CentralCache是由size_class个CentralFreeList组成的数组由Static(static_vars.h)类管理
```c++
class CentralFreeList {
  SpinLock lock_;
  // We keep linked lists of empty and non-empty spans.
  size_t   size_class_;     // size-class span切分尺寸，每个span只能按同一种size-class切分
  Span     empty_;          // 未分配Span
  Span     nonempty_;       // 已分配Span
}
```
CentralFreeList作为中间人，从PageHeap中取出部分span并按照预定大小将其拆分为大小固定的object供ThreadCache共享。CentralFreelist是全局的，除了构造函数，其余操作都需加锁。

## ThreadCache 小内存分配

**小对象分配**

1. 将其大小映射到相应的大小object
2. 在本地thread_cached中相应的free_list查找
3. 如果free_list不为空，从列表中删除第一个对象并返回它

**thread_cache free_list为空**

1. 从此大小类的central cache的free_list中获取一堆object
2. 将获取到的object放到thread_cache的free_list中
3. 将新获取的object其中一个返回

**central_cache free_list为空**

1. 从central page allocator中申请一批page
2. 拆分为该大小级别（size_class）的一组object
3. 新对象(object)放置在中央缓存（central cache）的空闲列表（free_list）中

每个thread独立维护了各自的离散式空闲列表

```c++
// https://github.com/gperftools/gperftools/blob/master/src/thread_cache.h
// https://github.com/gperftools/gperftools/blob/master/src/thread_cache.cc
class ThreadCache {
  class FreeList {
    void*    list_;       // 链表第一个节点
    uint32_t length_;      // 当前长度
    int32_t size_;
  }
  ThreadCache* next_;
  ThreadCache* prev_;
  // kClassSizesMax 96
  FreeList      list_[96];    // size_class 数组，可用链表
  int32         size_;        // 可用内存大小
  int32         max_size_;    // size_ > max_size_ --> Scavenge()
  pthread_t     tid_;         // 属于哪个线程
}
```
ThreadCache list_变量即为size class的实现，在实现free list时没有使用next来指针指向下一个位置，而是直接使用 void* list_, 将下一个object的地址直接存储在上个前8个字节中，可以模拟单向链表，object分配个应用程序后可以直接覆盖前8个字节，节省了一个指针的空间。

![object](/images/blog/1/golang/assert/tcmalloc-object.png)

## size-class
```c++
  // 1. Sizes <= 1024 have an alignment >= 8. ceil(size/8)
  // 2. Sizes > 1024 have an alignment >= 128. ceil(size/128).

  //   Size       Expression                      Index
  //   -------------------------------------------------------
  //   0          (0 + 7) / 8                     0
  //   1          (1 + 7) / 8                     1
  //   ...
  //   1024       (1024 + 7) / 8                  128
  //   1025       (1025 + 127 + (120<<7)) / 128   129
  //   ...
  //   32768      (32768 + 127 + (120<<7)) / 128  376
```



# go 内存分配

go在程序启动时会分配一块虚拟内存地址是连续的内存, 结构如下

![](/images/blog/1/golang/assert/go-内存布局.png)

## 布局

### spans

是page和其管理对象的反查表，在回收时，从哪来回哪去。利用该表可访问地址相邻大块内存使用状态，以便将多个相邻内存合并成更大的内存，减少碎片，更好适应分配需求。

### bitemap

和gc有关，先不做过多深入，研究gc时候会深入理解

栈(stack)、全局变量和静态变量（.data/.bss）占用1bit，0: gc不需要关心是否回收，1: 需要分析是否需要回收

堆(heap) 需要占用2bit

### arena

用户对象分配区域，就是通常说的堆(heap)，go从heap中申请的内存就是在这个区域。

### 逃逸分析

什么时候从heap分配对象，go会自动确定哪些对象应该放在栈上，哪些应该放在堆上。简单的说：当一个对象的内容可能在生成该对象的函数结束后被访问，那么这个对象就会被分配在堆上。

**返回对象指针**

```go
func foo() *string {
	str := "Hello world"
	return &str
}
func main() {
	fmt.Println(foo())
}
```

```shell
$ git:(master) ✗ go run -gcflags '-m -l' bar.go
# command-line-arguments
./bar.go:7:9: &str escapes to heap
./bar.go:6:2: moved to heap: str
./bar.go:11:17: foo() escapes to heap
./bar.go:11:13: main ... argument does not escape
0xc0000101e0
```

**传递了对象的指针到其他函数**

```go
func greeter(name *string) {
	 *name = "hello " + *name
}
func main() {
	name := "douyacun"
	greeter(&name)
	fmt.Println(name)
}
```

```shell
➜  bar git:(master) ✗ go run -gcflags '-m -l' bar.go
# command-line-arguments
./bar.go:6:20: "hello " + *name escapes to heap
./bar.go:5:14: greeter name does not escape
./bar.go:12:13: name escapes to heap
./bar.go:11:10: main &name does not escape
./bar.go:12:13: main ... argument does not escape
hello douyacun
```

**在闭包中使用了对象并且需要修改对象**

```go
func main() {
	name := "douyacun"
	greeter := func() {
		name = "hello " + name
	}
	greeter()
	fmt.Println(name)
}
```

```shell
➜  bar git:(master) ✗ go run -gcflags '-m -l' bar.go
# command-line-arguments
./bar.go:11:13: name escapes to heap
./bar.go:8:19: "hello " + name escapes to heap
./bar.go:7:13: main func literal does not escape
./bar.go:11:13: main ... argument does not escape
hello douyacun
```

**使用new**

```go
func main() {
	name := new([]string)
	fmt.Println(name)
}
```

```shell
➜  bar git:(master) ✗ go run -gcflags '-m -l' bar.go
# command-line-arguments
./bar.go:7:13: name escapes to heap
./bar.go:6:13: new([]string) escapes to heap
./bar.go:7:13: main ... argument does not escape
&[]
```

## 小对象分配过程

这里翻译了一下源代码的注释，描述的很清楚`runtime/mheap.go`

**mcache分配**

1. 将尺寸四舍五入到small size classes的一种
2. 在 **P** 的 mcache中查看相应的mspan
3. 扫描mspan的bitmap查找空闲坑位
4. 如果有空闲坑位，分配这个坑位，这个过程不需要获取锁

> P是协程中的用于运行go代码的虚拟资源,同一时间只能有一个线程访问同一个P,所以p的资源不需要锁

**mcentral分配**

1. mcache没有空闲坑位
2. 从有坑位的mcentral列表中获取一个新的mspan
3. 获得这个mspan需要锁定mcentral，mcentral是在线程的共享空间中，会有竞争

**mheap分配**

1. mcentral没有坑位
2. 从mheap申请一批page，切分为mspan
3. 这个过程需要加锁
4. 如果mheap没有坑位，从操作系统申请

小对象分3个阶段获取可用的span，然后从span中分配对象

![](/images/blog/1/golang/assert/go-内存分配-三阶段分配.png)



## 大对象分配

分配大内存直接通过mhe

ap获取，绕过mcache/mcentral, 大对象分配时会四舍五入(8kb)，在包含k个页面的空闲列表中寻找第K个条目，如果他是空的，向上查找，直到找到，如果失败，从操作系统查看早


go内存分配原理


背景：

- gin框架，中间件
- 博客开放好玩的 API

需求：

- 接口限流
- 按账户/IP/Token限流
- 定时加载配置

todo:

- 分布式限流

# time/rate 原理

time/rate 是go提供的官方限流工具

原理: 令牌桶，以一个恒定的速度往桶里放入令牌，而如果请求需要被处理，则需要先从桶里获取一个令牌，当桶里没有令牌可取时，则拒绝服务

我首先想到的方案初始化定时任务，每隔多长时间往桶里放一令牌。但是相比之下，time/rate的实现方式就是更优雅了

关键变量:

- 令牌放入桶的速度 limit 每秒产生多少token
- 桶的容量 burst 

已知变量：

- 最后一次消耗令牌的时间 last

简化公式：

当前可用令牌数，tokens（当前可用令牌数） := (now (当前时间) - last(上一次消耗令牌的时间) ).Seconds() * limit(令牌/每秒)

完整代码是：

```go
// advance calculates and returns an updated state for lim resulting from the passage of time.
// lim is not changed.
func (lim *Limiter) advance(now time.Time) (newNow time.Time, newLast time.Time, newTokens float64) {
	last := lim.last
	if now.Before(last) {
		last = now
	}

	// Avoid making delta overflow below when last is very old.
  // 这里限制令牌数不超过burst，lim.tokens 是上一次结余
	maxElapsed := lim.limit.durationFromTokens(float64(lim.burst) - lim.tokens)
	elapsed := now.Sub(last)
	if elapsed > maxElapsed {
		elapsed = maxElapsed
	}

	// Calculate the new number of tokens, due to time that passed.
	delta := lim.limit.tokensFromDuration(elapsed)
	tokens := lim.tokens + delta // 上一次结余 + 时间增量
	if burst := float64(lim.burst); tokens > burst {
		tokens = burst
	}

	return now, last, tokens
}
```

比起定时器来说是不是很优雅？这里有个比较绕的点：limit 的单位，n/s, 每秒多少个令牌

```go
// Every converts a minimum time interval between events to a Limit.
func Every(interval time.Duration) Limit {
	if interval <= 0 {
		return Inf
	}
	return 1 / Limit(interval.Seconds())
}
```

计算可用tokens的公式就更好理解了，用  tokens（当前可用令牌数） := (now (当前时间) - last(上一次消耗令牌的时间) ).Seconds() * limit(令牌/每秒)

# time/rate 改造

time/rate 只是给出了最基础的实现，绝大部分的需求

- 接口 > IP/user 多层限流
- 动态加载配置
- 在响应中给出剩余请求次数，下一次重置时间

其实 time/rate 的成本是非常低的，所以我们只需要多层map结构就可以满足, 每次初始化一个 rate.Limiter 就可以满足

```go
type ApiKeyRateLimit interface {
	Load()
	GetLimiter(api, key string) (limiter *Limiter, ok bool)
}

// API - UserId - rate.Limiter
type ApiKeyRateLimitImpl struct {
	hub map[string]map[string]*rate.Limiter
}
```

动态加载配置，可以使用etcd订阅配置，我实现的是定时从数据库里捞配置

```go

type ApiAccountRateLimit struct {
	ctx context.Context
	lim rate.ApiKeyRateLimit
}

func NewApiAccountRateLimit(ctx context.Context, limit rate.ApiKeyRateLimit) *ApiAccountRateLimit {
	r := &ApiAccountRateLimit{
		ctx: ctx,
		lim: limit,
	}
	go r.load()
	return r
}

func (h *ApiAccountRateLimit) Hook() gin.HandlerFunc {
	return func(ctx *gin.Context) {
		path := ctx.Request.URL.Path
		acctId, ok := ctx.Get(consts.OpenapiAccountId)
		if !ok {
			ctx.JSON(http.StatusOK, gin.H{"code": http.StatusUnauthorized, "message": http.StatusText(http.StatusUnauthorized)})
			ctx.Abort()
			return
		}
		limiter, ok := h.lim.GetLimiter(path, acctId.(string))
		if !ok {
			ctx.JSON(http.StatusOK, gin.H{"code": http.StatusUnauthorized, "message": http.StatusText(http.StatusUnauthorized)})
			ctx.Abort()
		}
    // 响应头：X-RateLimit-* 这里time/rat没有放出Advance，需要改一下
		_, _, tokens := limiter.Advance(time.Now())
		burst := limiter.Burst()
		ctx.Header("X-RateLimit-Limit", strconv.Itoa(burst))
		ctx.Header("X-RateLimit-Remaining", strconv.Itoa(int(tokens)))
    
		if !limiter.Allow() {
			ctx.JSON(http.StatusOK, gin.H{"code": http.StatusTooManyRequests, "message": http.StatusText(http.StatusTooManyRequests)})
			ctx.Abort()
			return
		}
		ctx.Next()
	}
}

// 定时加载配置
func (h *ApiAccountRateLimit) load() {
	ticker := time.NewTicker(5 * time.Minute)
	for {
		select {
		case <-h.ctx.Done():
			logger.Errorf("quit: RateLimit load config")
		case <-ticker.C:
			h.lim.Load()
		}
	}
}
```

# 推荐阅读

- go time/rate 限流 https://www.douyacun.com/article/f8f4e2bb806a6176e9c61dcaa0a4a6cc
- Go可用性(三) 限流2: 令牌桶的实现 rate/limt https://lailin.xyz/post/go-training-week6-3-token-bucket-2.html



1. 接口限流 2. 按账户/ip/token限流 3. 定时加载配置

go time/rate 接口-账户/IP 限流



# gositemap

Sitemap 协议: https://www.sitemaps.org/protocol.html

博客: [https://www.douyacun.com](https://www.douyacun.com)

博客 sitemap: [https://www.douyacun.com/sitemap.xml](https://www.douyacun.com/sitemap.xml)

Github: [https://github.com/douyacun/gositemap](https://github.com/douyacun/gositemap)

pkg.go.dev: [https://pkg.go.dev/github.com/douyacun/gositemap](https://pkg.go.dev/github.com/douyacun/gositemap)

### Installation

```
import "github.com/douyacun/gositemap"
```

go语言实现的sitemap生成工具
```go
st := gositemap.NewSiteMap()
st.SetPretty(true)

url := gositemap.NewUrl()
url.SetLoc("https://www.douyacun.com/")
url.SetLastmod(time.Now())
url.SetChangefreq(Daily)
url.SetPriority(1)
st.AppendUrl(url)
bt, err := st.ToXml()
if err != nil {
  fmt.Printf("%v", err)
  return
}
fmt.Printf("%s", bt)
```
输出
```xml
<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://www.douyacun.com/</loc>
    <lastmod>2020-04-19T17:28:33+08:00</lastmod>
    <changefreq>daily</changefreq>
    <priority>1</priority>
  </url>
</urlset>
```

### Features

- [x]  [gositemap](#gositemap)
- [x]  [Image sitemap](#image-sitemap)
- [x]  [News sitemap](#news-sitemap)
- [x]  [Video sitemap](#video-sitemap)
- [x]  [file storage](#file-storage)
- [x]  [Sitemap index](#sitemap-index)

### Image sitemap

Google 图片扩展功能 [Google Image Support: 
https://support.google.com/webmasters/answer/178636?hl=zh-Hans&ref_topic=4581190

- **提供适当的相关信息**：确保您的视觉内容与其所在网页的主题相关。我们建议您仅在能为网页增添原创价值的情况下展示图片。我们极不赞成在网页中完全使用非原创的图片和文字内容。
- **优化放置位置**：尽可能将图片放置在相关文字附近。必要时，也可考虑将最重要的图片放置在网页顶部附近。
- **勿将重要文字内嵌在图片中**：避免将文字（特别是网页标题和菜单项等重要的文字元素）内嵌在图片中，因为并非所有用户都能访问这类文字（而且网页翻译工具不适用于图片）。为了尽可能让更多的人能访问您的内容，请使用 HTML 格式提供文本，并为图片提供替代文本。
- **创建信息丰富的优质网站**：对 Google 图片而言，优质的网页内容与视觉内容同等重要 - 它可以提供背景信息并更能吸引用户点击搜索结果。网页内容可用于为图片生成一段文本摘要，而且 Google 在进行图片排名时会考虑对应的网页内容质量
- **创建适合在各种设备上访问的网站**：比起桌面设备，用户更多地使用移动设备在 Google 图片上进行搜索。因此，有必要设计一个适合所有设备类型和尺寸的网站。请使用移动设备适合性测试工具测试您的网页在移动设备上的运行效果，并获取反馈以了解哪些内容需要修正。
- **为图片创建良好的网址结构**：Google 会借助网址路径以及文件名来理解您的图片。我们建议您好好组织图片内容，以使网址结构合乎逻辑。

```go
st := NewSiteMap()
st.SetPretty(true)
url := NewUrl()
url.SetLoc("https://www.douyacun.com/show_image")
// 注意这里url.SetLoc设置网页的网址
// image.SetLoc 设置的是图片访问路径，image的域名和网址域名不一致也可以
_image := NewImage().
    SetLoc("https://www.douyacun.com/image1.jpg").
    SetTitle("example").
    SetCaption("图片的说明。").
    SetLicense("https://www.douyacun.com")
url.AppendImage(_image)

_image = NewImage().
    SetLoc("https://www.douyacun.com/image2.jpg").
    SetTitle("example").
    SetCaption("图片的说明。").
    SetLicense("https://www.douyacun.com")
url.AppendImage(_image)

st.AppendUrl(url)
data, err := st.ToXml()
if err != nil {
    fmt.Printf("%v", err)
    return
}
fmt.Printf("%s", data)
```

输出
```xml
<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">
  <url>
    <loc>https://www.douyacun.com/show_image</loc>
    <image:image>
      <image:loc>https://www.douyacun.com/image1.jpg</image:loc>
      <image:caption>图片的说明。</image:caption>
      <image:title>example</image:title>
      <image:license>https://www.douyacun.com</image:license>
    </image:image>
    <image:image>
      <image:loc>https://www.douyacun.com/image2.jpg</image:loc>
      <image:caption>图片的说明。</image:caption>
      <image:title>example</image:title>
      <image:license>https://www.douyacun.com</image:license>
    </image:image>
  </url>
</urlset>
```

### News sitemap

Google 新闻站点地图准则 google news support
https://support.google.com/webmasters/answer/178636?hl=zh-Hans&ref_topic=4581190

```go
st := NewSiteMap()
st.SetPretty(true)

url := NewUrl()
url.SetLoc("https://www.douyacun.com/business/article55.html")
url.AppendNews(NewNews().SetName("《示例时报》").
    SetTitle("公司 A 和 B 正在进行合并谈判").
    SetLanguage("zh-cn").
    SetPublicationDate(time.Now()))
st.AppendUrl(url)
data, err := st.ToXml()
if err != nil {
    fmt.Printf("%v", err)
    return
}
fmt.Printf("%s", data)
```
输出
```xml
<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:news="http://www.google.com/schemas/sitemap-news/0.9">
  <url>
    <loc>https://www.douyacun.com/business/article55.html</loc>
    <news:news>
      <news:publication>
        <news:name>《示例时报》</news:name>
        <news:language>zh-cn</news:language>
      </news:publication>
      <news:publication_date>2020-04-19T17:24:49+08:00</news:publication_date>
      <news:title>公司 A 和 B 正在进行合并谈判</news:title>
    </news:news>
  </url>
</urlset>
```

### Video sitemap

视频 Sitemap 及其替代方案  Google Video Support 
https://support.google.com/webmasters/answer/80471?hl=zh-Hans&ref_topic=4581190

- **Google 必须能够找到该视频。** 系统会根据是否存在某种 HTML 标记（例如 ``、`` 或 ``）来识别网页中的视频。请确保相应网页不[需要复杂的用户操作或特定的网址片段即可加载](https://support.google.com/webmasters/answer/156442#complex-javascript)，否则 Google 可能找不到它。**提示**：虽然我们可以通过自然抓取找到网页中内嵌的视频，但您也可以通过发布[视频 Sitemap](https://support.google.com/webmasters/answer/80471) 帮助我们找到您的视频。
- **您必须为视频提供高品质的缩略图 。**
- **确保每个视频都位于可公开访问的网页中**，用户可以在其中观看视频。该网页不应该要求用户登录，也不应该被 robots.txt 或 noindex屏蔽（必须可供 Google 访问）。
- **视频内容应确切吻合其托管网页的内容。** 例如，如果您拥有一个介绍桃饼的食谱网页，不要嵌入笼统介绍甜点的视频。
- 确保您在视频 Sitemap 或视频标记中提供的任何信息与实际视频内容**一致**。

```go
st := NewSiteMap()
url := NewUrl()
url.Loc = "https://www.douyacun.com"

video := NewVideo().
    SetThumbnailLoc("http://www.example.com/thumbs/123.jpg").
    SetTitle("适合夏季的烧烤排餐").
    SetDescription("小安教您如何每次都能烤出美味牛排").
    SetContentLoc("http://streamserver.example.com/video123.mp4").
    SetPlayerLoc("http://www.example.com/videoplayer.php?video=123", true).
    SetDuration(600*time.Second).
    SetExpirationDate(time.Now().Add(time.Hour*24)).
    SetRating(4.2).
    SetViewCount(12345).
    SetPublicationDate(time.Now().Add(-time.Hour*24)).
    SetFamilyFriendly(true).
    SetRestriction([]string{"IE", "GB", "US", "CN", "CA"}, true).
    SetPrice(6.99, "EUR", true, true).
    SetRequiresSubscription(true).
    SetUploader("GrillyMcGrillerson", "http://www.example.com/users/grillymcgrillerson").
    SetLive(true)

url.AppendVideo(video)
st.AppendUrl(url)
bt, err := st.ToXml()
if err != nil {
    log.Printf("%v", err)
    return
}
fmt.Printf("%s", bt)
```

输出
```xml
<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:video="http://www.google.com/schemas/sitemap-video/1.1">
  <url>
    <loc>https://www.douyacun.com</loc>
    <video:video>
      <video:thumbnail_loc>http://www.example.com/thumbs/123.jpg</video:thumbnail_loc>
      <video:title>适合夏季的烧烤排餐</video:title>
      <video:description>小安教您如何每次都能烤出美味牛排</video:description>
      <video:content_loc>http://streamserver.example.com/video123.mp4</video:content_loc>
      <video:player_loc allow_embed="yes">http://www.example.com/videoplayer.php?video=123</video:player_loc>
      <video:duration>600</video:duration>
      <video:expiration_date>2020-04-20T17:25:49+08:00</video:expiration_date>
      <video:rating>4.2</video:rating>
      <video:view_count>12345</video:view_count>
      <video:publication_date>2020-04-18T17:25:49+08:00</video:publication_date>
      <video:family_friendly>yes</video:family_friendly>
      <video:restriction relationship="allow">IE GB US CN CA</video:restriction>
      <video:price currency="EUR" type="own" resolution="hd">6.99</video:price>
      <video:requires_subscription>yes</video:requires_subscription>
      <video:uploader info="http://www.example.com/users/grillymcgrillerson">GrillyMcGrillerson</video:uploader>
      <video:live>yes</video:live>
    </video:video>
  </url>
</urlset>
```

### file storage

```go
st := NewSiteMap()
// 默认域名
st.SetDefaultHost("https://www.douyacun.com")
st.SetPretty(true)
// 每个sitemap文件不能多于50000个链接，这里可以自己配置每个文件最多，如果超过MaxLinks，会自动生成sitemap_index.xml文件
// st.SetMaxLinks(2)
st.SetPublicPath("/tmp/gositemap")

url := NewUrl()
url.SetLoc("https://www.douyacun.com/business/article55.html")
url.AppendNews(NewNews().SetName("《示例时报》").
               SetTitle("公司 A 和 B 正在进行合并谈判").
               SetLanguage("zh-cn").
               SetPublicationDate(time.Now()))
st.AppendUrl(url)

path, err := st.Storage()
if err != nil {
  fmt.Printf("%v", err)
  return
}
fmt.Println(path)
```

生成`sitemap.xml`文件

```xml
<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:news="http://www.google.com/schemas/sitemap-news/0.9">
  <url>
    <loc>https://www.douyacun.com/business/article55.html</loc>
    <news:news>
      <news:publication>
        <news:name>《示例时报》</news:name>
        <news:language>zh-cn</news:language>
      </news:publication>
      <news:publication_date>2020-04-19T17:44:33+08:00</news:publication_date>
      <news:title>公司 A 和 B 正在进行合并谈判</news:title>
    </news:news>
  </url>
</urlset>
```

### Sitemap index 

拆分较大的站点地图

```go
mapIndex := NewSiteMapIndex()

st1 := NewSiteMap()
st1.SetPretty(true)
st1.SetFilename("sitemap1")
st1.SetCompress(true)

# 以news为例
url := NewUrl()
url.SetLoc("https://www.douyacun.com/business/article55.html")
url.AppendNews(NewNews().SetName("《示例时报》").
               SetTitle("公司 A 和 B 正在进行合并谈判").
               SetLanguage("zh-cn").
               SetPublicationDate(time.Now()))
st1.AppendUrl(url)

url2 := NewUrl().SetLoc("https://www.douyacun.com/business/article56.html")
url2.AppendNews(NewNews().SetName("《示例时报》").
               SetTitle("公司 A 和 C 正在进行合并谈判").
               SetLanguage("zh-cn").
               SetPublicationDate(time.Now()))
st1.AppendUrl(url2)
st1Filename, err := st1.Storage()
if err != nil {
  fmt.Printf("%v", err)
  return
}
mapIndex.Append("https://www.douyacun.com/" + st1Filename)
filename, err := mapIndex.Storage("/Users/liuning/Documents/github/gositemap/sitemap_index.xml")
if err != nil {
  fmt.Printf("%v", err)
  return
}
fmt.Printf("%v", filename)
```

使用sitemap_index时，建议每个单独的sietmap comporess压缩成.gz文件，`SetCompress`后会自动添加 `.gz`后缀名 ,  生成`sitemap1.xml.gz` 和 `sitemap_index.xml`

### Documentation

Api Reference : https://pkg.go.dev/github.com/douyacun/gositemap?tab=doc



# LICENSE

MIT@[douyacun](https://github.com/douyacun).

![douyacun](/images/blog/1/assert/douyacun_qrcode.jpg)