其实从上学开始就一直想写一个im。 最近深入go，真是学会了太多，感觉人森虽然苦短，但是也不能只用python。很多知识是不用编译型语言无法了解的。
该来的还是会来，现在会一步一步用go把这个服务器完善起来 先从这个demo开始。
这个demo 我们要求所有连上服务器的用户都会知道有用户的离开，有用户的加入(除了第一个加入的用户)，每个人说话就像聊天室一样，房间里的所有人都能看到。
由于接收tcp请求，get accept的conn步骤都差不多所以先上main部分的代码：
func main() {
listener, err := net.Listen("tcp", "0.0.0.0:8888")
if err != nil {
log.Fatal(err)
}
go broadcaster()
for{
conn, err := listener.Accept()
if err != nil {
fmt.Fprintf(os.Stdout, "you got something wrong %v", err)
continue
}
go handleConn(conn)
}
}
使用net包里面提供的Listen监听tcp来自8888端口的数据。并获得一个listener对象。
发起一个goroutine用于消息广播使用
然后进入监听循环，使用listener对象提供的Accept方法来获取连接。
每获得一个连接就重新启一个goroutine去handle这个链接。
main里面写的代码非常简单，其实服务器要做的事情总结一下无非就是获得listener对象，然后不停的获取获取链接上来的conn对象，然后把这些对象丢给处理链接函数去进行处理。在使用handleConn方法处理conn对象的时候，我们同样对不同的链接都启一个goroutine去并发处理每个conn这样则无需等待。
用于要给在线的所有用户发送消息，而不同的用户的conn对象都在不同的goroutine里面，我们很容易想到使用队列这种东西来做消息的传递，但是golang里面有channel来处理各不同goroutine之间的消息传递，所以在这个demo我选择使用channel在各不同的goroutine中传递广播消息。
先申明一些要用到的channel
type client chan<- string // send only channel
var (
entering = make(chan client)
leaving = make(chan client)
messages = make(chan string)
)
这里要注意一点的是，重新定义了一个client类型，他是一个单向chennel，只能往里面写消息。
下面申请的entering和leaving都是client类型的channel。
什么意思呢？
就是说下面的entering和leaving都是装channel的channel。这里有点绕要注意，装channel的channel在<-的时候，会直接将channel对象装进去。
这里拓展开说说这个问题，以免下面的代码难以理解，来看一个例子：
package main
import (
"fmt"
"time"
)
type client chan string
var entering = make(chan client)
func main() {
ch := make(chan string)
go func() {ch <- "那你很棒棒哦?? "}()
go func() {entering <- ch}()
o := <-entering
time.Sleep(2 * time.Second)
fmt.Println(<-o)
}
这里我们创建了一个client类型，他是一个string类型的channel。
同时申明一个entering，他是一个client类型的channel。这里也可以写成 make(chan chan string) 但是写成client更方便清晰有木有。
在执行 entering <- ch的时候，并不是把ch里面装的string内容吐出去了，而是把自己装进了entering。
后面写的都是在验证这一行为就不继续赘述了。
继续回来说broadcaster函数：
func broadcaster() {
clients := make(map[client]bool) //all connected clients
for {
select {
case msg := <- messages:
// Broadcast incoming message to all
// clients‘ outgoing message channels.
for cli := range clients{
cli <- msg
}
case cli := <- entering:
clients[cli] = true
case cli := <- leaving:
delete(clients, cli)
close(cli)
}
}
}
我们在main里面使用goroutine开启了一个broadcaster函数来负责广播所有用户发送的消息。
这里使用一个字典来保存用户clients，字典的key是各连接申明的单向发队列。
使用一个select开启一个多路复用：
每当有广播消息从messages发送进来，都会循环cliens对里面的每个channel发消息。
每当有消息从entering里面发送过来，就生成一个新的key-value。相当于给clients里面增加一个新的client。
每当有消息从leaving里面发送过来，就删掉这个key-value对，并关闭对应的channel。
最后我们来看handleConn函数里的逻辑：
func handleConn(conn net.Conn) {
ch := make(chan string)
go clientWriter(conn, ch)
who := conn.RemoteAddr().String()
ch <- "You are " + who
messages <- who + " has joined us"
// 这里不是把数据吐出去。。而是吐出去了本身一个channel这里比较难理解。
entering <- ch
input := bufio.NewScanner(conn)
for input.Scan() {
messages <- who + ": " + input.Text()
}
leaving <- ch
messages <- who + " has left "
conn.Close()
}
为每个过来处理的conn都创建一个新的channel，开启一个新的goroutine去把发送给这个channel的消息写进conn。
获取连接过来的ip地址和端口号。
先把欢迎信息写进channel返回给客户端。
然后生成一条广播消息写进messages里。
然后把这个channel加入到客户端集合 也就是 entering <- ch
然后开始监听客户端往conn里写的数据，每扫描到一条就将这条消息发送到广播channel中
如果客户端关闭了标准输入，那么把队列离开写入leaving交给广播函数去删除这个客户端并关闭这个客户端。
广播这个人的离开给所有人。
最后关闭这个客户端的连接Conn.Close()。
最后上clientWriter的代码：
func clientWriter(conn net.Conn, ch <-chan string) {
for msg := range ch {
fmt.Fprintln(conn, msg) // NOTE: ignoring network errors
}
}
没什么好说的，就是把每个发送过来的消息都写入到conn中，没有消息发过来的时候就阻塞。
其实看似简单饿服务器做了一些细节上的处理，因为golang中字典并不是并发安全的，所以只有一个gonroutine单独干这件事情，保证了其并发情况也安全。
关于并发安全这个话题，可以写n篇文章来阐述其细节也不为过，以后可能会有更多机会介绍到。
这么看其实逻辑已经非常清楚了，后续我还会往这个服务器上加更多的功能，包括让客户端写入自己的名字来替代现在用ip地址标记远端连接的情况。
Reference:
https://github.com/gopl-zh/gopl-zh.github.com The Go Programming Language