伺服器端Go程式對長短連結的處理及運行參數的儲存_Golang

對長、短串連的處理策略（類比心跳）
作為一個可能會和很多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中的差不多，此處略過 

運行效果如下：