服务器端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的详细信息可以参考：

   比如我们可以将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中的差不多，此处略过 

运行效果如下：