對長、短連接的處理策略（模擬心跳）
作為一個可能會和很多Client進行通訊交互的Server，首先要保證的就是整個Server運行狀態的穩定性，因此在和Client建立連接通訊的時候，確保連接的及時斷開非常重要，否則一旦和多個客戶端建立不關閉的長連接，對于服務器資源的占用是很可怕的。因此，我們需要針對可能出現的短連接和長連接，設定不同的限制策略。
針對短連接，我們可以使用golang中的net包自帶的timeout函數，一共有三個，分別是：
func (*IPConn) SetDeadline
func (c *IPConn) SetDeadline(t time.Time) error
func (*IPConn) SetReadDeadline
func (c *IPConn) SetReadDeadline(t time.Time) error
func (*IPConn) SetWriteDeadline
func (c *IPConn) SetWriteDeadline(t time.Time) error
如果想要給服務器設置短連接的timeout,我們就可以這么寫：
netListen, err := net.Listen("tcp", Port)
Log("Waiting for clients")
for {
conn, err := netListen.Accept()
if err != nil {
continue
}
conn.SetReadDeadline(time.Now().Add(time.Duration(10) * time.Second))
這里的三個函數都是用于設置每次socket連接能夠維持的最長時間，一旦超過設置的timeout后，便會在Server端自動斷開連接。其中SetReadline, SetWriteline設置的是讀取和寫入的最長持續時間，而SetDeadline則同時包含了 SetReadline, SetWriteline兩個函數。
通過這樣設定，每個和Server通訊的Client連接時長最長也不會超過10s了~~
搞定短連接后，接下來就是針對長連接的處理策略了~~
作為長連接，由于我們往往很難確定什么時候會中斷連接，因此并不能像處理短連接那樣簡單粗暴的設定一個timeout就可以搞定，而在Golang的net包中，并沒有針對長連接的函數，因此需要我們自己設計并實現針對長連接的處理策略啦~
針對socke長連接，常見的做法是在Server和Socket之間設計通訊機制，當兩者之間沒有信息交互時，雙方便會定時發送數據包(心跳)，以維持連接狀態。
這種方法是目前使用相對比較多的做法，但是開銷相對也較大，特別是當Server和多個client保持長連接的時候，并發會比較高，考慮到公司的業務需求，我最后選擇了邏輯相對簡單，開銷相對較小的策略：
當Server每次收到Client發到的信息之后，便會開始心跳計時，如果在心跳計時結束之前沒有再次收到Client發來的信息，那么便會斷開跟Client的連接。而一旦在設定時間內再次收到Client發來的信息，那么Server便會重置計時器，再次重新進行心跳計時，直到超時斷開連接為止。
下面就是實現該計時的代碼：
//長連接入口
func handleConnection(conn net.Conn,timeout int) {
buffer := make([]byte, 2048)
for {
n, err := conn.Read(buffer)
if err != nil {
LogErr(conn.RemoteAddr().String(), " connection error: ", err)
return
}
Data :=(buffer[:n])
messnager := make(chan byte)
postda :=make(chan byte)
//心跳計時
go HeartBeating(conn,messnager,timeout)
//檢測每次Client是否有數據傳來
go GravelChannel(Data,messnager)
Log( "receive data length:",n)
Log(conn.RemoteAddr().String(), "receive data string:", string(Data
}
}
//心跳計時，根據GravelChannel判斷Client是否在設定時間內發來信息
func HeartBeating(conn net.Conn, readerChannel chan byte,timeout int) {
select {
case fk := <-readerChannel:
Log(conn.RemoteAddr().String(), "receive data string:", string(fk))
conn.SetDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
//conn.SetReadDeadline(time.Now().Add(time.Duration(5) * time.Second))
break
case <-time.After(time.Second*5):
Log("It's really weird to get Nothing!!!")
conn.Close()
}
}
func GravelChannel(n []byte,mess chan byte){
for _ , v := range n{
mess <- v
}
close(mess)
}
func Log(v ...interface{}) {
log.Println(v...)
}
這樣，就可以成功實現對于長連接的處理了~~，我們可以這么進行測試：
func sender(conn net.Conn) {
for i := 0; i <5; i++ {
words:= strconv.Itoa(i)+"This is a test for long conn"
conn.Write([]byte(words))
time.Sleep(2*time.Second)
}
fmt.Println("send over")
}
可以發現，Sender函數中time.Sleep阻塞的時間設定的比Server中的timeout短的時候，Client端的信息可以自由的發送到循環結束，而當我們設定Sender函數的阻塞時間較長時，就只能發出第一次循環的信息。
將運行參數放入配置文件（XML/YAML）
為了將我們寫好的Server發布到服務器上，就要將我們的代碼進行build打包，這樣如果以后想要修改一些代碼的話，需要重新給代碼進行編譯打包并上傳到服務器上。
顯然，這么做過于繁瑣。。。因此常見的做法都是將Server運行中可能會頻繁變更的變量、數值寫入配置文件中，這樣直接讓程序從配置文件讀取參數，避免對代碼頻繁的操作。
關于配置文件的格式，在這里推薦YAML 和XML~ XML是傳統的配置文件寫法，不過本人比較推薦yaml，他比XML要更加人性化，也更好寫，關于yaml的詳細信息可以參考： yaml官網
比如我們可以將Server監聽的端口作為變量，寫入配置文件 config.yaml 和 config.xml，放入代碼的根目錄下，這樣當我們想要更換服務器端口的時候，只要在配置文件中修改port對應的值就可以拉。 config.xml內容如下：
|
1
2
3
4
5
6
7
|
<?xml version="1.0" encoding="UTF-8"?> <Config1>GetConfig</Config1> <Config2>THE</Config2> <Config3>Information</Config3> <Feature1>HereIsTEST1</Feature1> <Feature2>1024</Feature2> <Feature3>Feature23333</Feature3> |
config.yaml內容如下：
|
1
2
3
4
5
6
7
8
|
Address: 172.168.0.1 Config1: Easy Config2: Feature1: 2 Feature2: [3, 4] Port: :6060 Config4: IS Config5: ATest |
接下來就是解析他們了，目前golang官方還沒有解析yaml的庫，因此我推薦使用第三方的go-yaml包，
地址如下： go-yaml ，go get安裝該包后，我們就可以通過他解析文件啦：
//解析文件，取出所有參數
func GetYamlConfig() map[interface{}]interface{}{
data, err := ioutil.ReadFile("config.yaml")
//將解析出的參數轉為map的形式
m := make(map[interface{}]interface{})
if err != nil {
LogErr("error: %v", err)
}
err = yaml.Unmarshal([]byte(data), &m)
return m
}
//根據需求取出對應值
func GetElement(key string,themap map[interface{}]interface{})string {
if value,ok:=themap[key];ok {
return value.(string)
}
LogErr("Can't find the *.yaml")
return ""
}
這里同樣給出解析xml配置文件的代碼：
func GetXMLConfig() map[string]string {
var t xml.Token
var err error
Keylst := make([]string,6)
Valuelst:=make([]string,6)
//將解析出的元素填入map中，便于查找
map1:=make(map[string]string)
content, err := ioutil.ReadFile("config.xml")
CheckError(err)
decoder := xml.NewDecoder(bytes.NewBuffer(content))
i:=0
j:=0
for t, err = decoder.Token(); err == nil; t, err = decoder.Token() {
switch token := t.(type) {
// 處理元素
case xml.StartElement:
name := token.Name.Local
Keylst[i]=string(name)
i=i+1
case xml.CharData:
content1 := string([]byte(token))
//Valuelst=append(Valuelst,content1)
Valuelst[j]=content1
j=j+1
}
}
for count:=0;count<len(Keylst);count++{
map1[Keylst[count]]=Valuelst[count]
}
return map1
}
//取出map的函數跟yaml中的差不多，此處略過
運行效果如下：
