每日一抄 Go语言聊天服务器

server.go

package main

import (
	"bufio"
	"fmt"
	"log"
	"net"
)

/*
服务端程序中包含 4 个 goroutine，分别是一个主 goroutine 和广播（broadcaster）goroutine，每一个连接里面又包含一个连接处理（handleConn）goroutine 和一个客户写入（clientwriter）goroutine。

广播器（broadcaster）是用于如何使用 select 的一个规范说明，因为它需要对三种不同的消息进行响应。

主 goroutine 的工作是监听端口，接受连接客户端的网络连接，对每一个连接，它将创建一个新的 handleConn goroutine。

完整的示例代码如下所示：
*/
func main() {

	/*
		1.main函数就是获得listener对象，然后不停的获取连接上来的conn对象，最后把这些对象丢给处理连接函数进行处理
		2.在使用handleConn方法处理conn对象的时候，对不同的连接都启用一个goroutine去并发处理每个conn这样则无须等待。
		3.由于要给所有在线的用户发送消息，而不同的用户的conn对象都在不同的goroutine里面，但是Go语言中有channel来处理
		各个不同goroutine之间的消息传递，所以这里我们选择使用channel在各个不同的goroutine之间传递广播消息
	*/

	//开启一个监听端口
	listener, err := net.Listen("tcp", "localhost:8000")
	if err != nil {
		log.Fatal(err)
	}
	//开启广播协程
	go broadcaster()

	//不停的监听请求
	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Fatal(err)
		}

		//开启处理请求的协程
		go handleConn(conn)
	}

}

/*
介绍broadcaster广播器，它使用局部变量clients来记录当前连接客户集合，每个客户唯一记录的信息是其对外发送消息通道的ID，下面是细节
*/
//对外发送消息的通道
type client chan<- string

var (
	entering = make(chan client)
	leaving  = make(chan client)
	messages = make(chan string) //所有连接的客户端
)

/*
在main函数中使用了一个goroutine开启了一个broadcaster函数来负责广播所有用户发送的信息
这里使用一个字典在保存clients，字典的key是各种连接申明的单向并发队列
*/
func broadcaster() {
	clients := make(map[client]bool)
	for {
		/*
			使用select开启一个多路复用：
			1.每当有广播消息从messages发送进来，都会循环clients对里面的每个channel发消息
			2.每当有消息从entering里面发送过来，就会生成一个新的key-value，相当于给clients里面增加一个新的client
			3.每当有消息从leaving里面发过来就删掉这个key-value对，并关闭对应的channel
		*/
		select {
		case msg := <-messages:
			//把所有接收到的消息广播给所有客户端
			//发送消息通道
			for cli := range clients {
				cli <- msg
			}
		//上线
		case cli := <-entering:
			clients[cli] = true

		//下线
		case cli := <-leaving:
			delete(clients, cli)
		}
	}
}

/*
下面再来看下每个用户自己的goroutine
handleConn函数创建一个对外发送消息的新通道，然后通过entering通道通知广播新客户到来，
接着它读取客户发来的每一行文本，通过全局接收消息通道将每一行发送给广播，发送时在每一条消息前面加上发送者ID作为前缀
一旦从客户端读取完毕消息，handleConn通过leaving通道通知客户离开然后关闭连接
*/

/*
handleConn函数会为每一个过来处理的conn创建一个新的channel，开启一个新的goroutine去把发送这个channel的消息写进conn
handleConn函数的执行过程可以简单地总结为一下几步
1.获取连接过来的IP地址和端口号
2.把欢迎信息写进channel返回给客户端
3.生成一条广播消息写进messages里
4.把这个channel加入到客户端集合，也就是entering <- ch
5.监听客户端往conn里写入数据，每扫描到一条就讲这条消息发送到广播channel中
6.如果关闭了客户端，如果关闭了客户端，那么把队列离开写入 leaving 交给广播函数去删除这个客户端并关闭这个客户端；
7.广播通知其他客户端该客户端已关闭；
8.最后关闭这个客户端的连接 Conn.Close()。
*/
func handleConn(conn net.Conn) {
	ch := make(chan string) //对外发送客户消息的通道
	go clientWriter(conn, ch)
	who := conn.RemoteAddr().String()
	ch <- "欢迎" + who
	messages <- who + "上线"
	entering <- ch

	input := bufio.NewScanner(conn)
	for input.Scan() {
		messages <- who + ":" + input.Text()
	}
	//注意input.Err()中可能的错误
	leaving <- ch
	messages <- who + "下线"
	conn.Close()
}

//ch <-chan string只写管道
func clientWriter(conn net.Conn, ch <-chan string) {
	for msg := range ch {
		fmt.Fprintln(conn, msg) //注意：忽略网络层面的错误
	}
}

client.go

package main

import (
	"io"
	"log"
	"net"
	"os"
)

/*
前面对服务端做了简单的介绍，下面介绍客户端，这里将其命名为“client.go”，完整代码如下所示：
*/

//client 是一个简单的TCP服务器读/写客户端
func main() {
	conn, err := net.Dial("tcp", "localhost:8000")
	if err != nil {
		log.Fatal(err)
	}
	done := make(chan struct{})
	go func() {
		io.Copy(os.Stdout, conn) //注意：忽略错误
		log.Println("done")
		done <- struct{}{} //向主goroutine发出信号
	}()
	mustCopy(conn, os.Stdin)
	conn.Close()
	<-done //等待后台goroutine完成
}

func mustCopy(dst net.Conn, src io.Reader) {
	if _, err := io.Copy(dst, src); err != nil {
		log.Fatal(err)
	}
}

client1.go

package main

import (
	"io"
	"log"
	"net"
	"os"
)

/*
前面对服务端做了简单的介绍，下面介绍客户端，这里将其命名为“client.go”，完整代码如下所示：
*/

//client 是一个简单的TCP服务器读/写客户端
func main() {
	conn, err := net.Dial("tcp", "localhost:8000")
	if err != nil {
		log.Fatal(err)
	}
	done := make(chan struct{})
	go func() {
		io.Copy(os.Stdout, conn) //注意：忽略错误
		log.Println("done")
		done <- struct{}{} //向主goroutine发出信号
	}()
	mustCopy(conn, os.Stdin)
	conn.Close()
	<-done //等待后台goroutine完成
}

func mustCopy(dst net.Conn, src io.Reader) {
	if _, err := io.Copy(dst, src); err != nil {
		log.Fatal(err)
	}
}

client2.go

package main

import (
	"io"
	"log"
	"net"
	"os"
)

/*
前面对服务端做了简单的介绍，下面介绍客户端，这里将其命名为“client.go”，完整代码如下所示：
*/

//client 是一个简单的TCP服务器读/写客户端
func main() {
	conn, err := net.Dial("tcp", "localhost:8000")
	if err != nil {
		log.Fatal(err)
	}
	done := make(chan struct{})
	go func() {
		io.Copy(os.Stdout, conn) //注意：忽略错误
		log.Println("done")
		done <- struct{}{} //向主goroutine发出信号
	}()
	mustCopy2(conn, os.Stdin)
	conn.Close()
	<-done //等待后台goroutine完成
}

func mustCopy2(dst net.Conn, src io.Reader) {
	if _, err := io.Copy(dst, src); err != nil {
		log.Fatal(err)
	}
}