服務器端Go程序對長短鏈接的處理及運行參數的保存

對長、短連接的處理策略（模擬心跳）
作為一個可能會和很多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內容如下：

<?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內容如下：

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中的差不多，此處略過  

運行效果如下：