golang 创建一个简单的广播echo服务器

package main;

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

//里面的代码部分参考cmu440课程
//https://github.com/cmu440/p0

//广播服务器接口
type MultiEchoServer interface {
	//开始
	Start(port int) error;
	//停止
	Close();
	//当前客户端连接数
	Count() int;
}

//广播服务器
type multiEchoServer struct {
	lis *net.TCPListener;
	//当前客户端ID
	curClientId int;
	//所有客户端
	clients map[int]*client;
	//广播消息
	broadcastMsg chan []byte;
}

//客户端
type client struct {
	//ID
	id int;
	//连接
	conn net.Conn;
	//接收消息
	recvMsg chan []byte;
	//发送消息
	sendMsg chan []byte;
	//接收消息是否关闭
	isRecvMsgClose chan bool;
	//发送消息是否关闭
	isSendMsgClose chan bool;
	//服务器
	mes *multiEchoServer;
}

//返回一个广播服务器
func New() *multiEchoServer {
	return &multiEchoServer{
		curClientId:  0,
		clients:      make(map[int]*client),
		broadcastMsg: make(chan []byte, 1),
	};
}

//启动服务器
func (m *multiEchoServer) Start(port int) error {
	//获取tcp地址
	addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf(":%d", port));
	if err != nil {
		return err;
	}
	//监听端口
	m.lis, err = net.ListenTCP("tcp", addr);
	if err != nil {
		return err;
	}
	//启一个goroutine处理广播
	go m.BroadcastLoop();
	//启一个goroutine处理客户端来的连接
	go func() {
		for {
			conn, err := m.lis.Accept();
			if err != nil {
				continue;
			}
			cli := &client{
				id:             m.curClientId,
				conn:           conn,
				recvMsg:        make(chan []byte, 1),
				sendMsg:        make(chan []byte, 1),
				isRecvMsgClose: make(chan bool, 1),
				isSendMsgClose: make(chan bool, 1),
				mes:            m,
			}
			//加客户端加入到服务器clients中
			clis := m.clients;
			clis[m.curClientId] = cli;
			m.clients = clis;
			m.curClientId++;

			//启两个goroutine分别处理客户端的接收与发送消息
			go cli.RecvLoop();
			go cli.SendLoop();
		}
	}();
	return nil;
}

//停止服务器
func (m *multiEchoServer) Close() {
	m.lis.Close();
	//循环关闭客户端
	for _, client := range m.clients {
		client.conn.Close();
		//这里只需给一个发送消息就好了
		client.isRecvMsgClose <- true;
	}
}

//返回当前客户端连接数
func (m *multiEchoServer) Count() int {
	return len(m.clients);
}

//处理广播
func (m *multiEchoServer) BroadcastLoop() {
	for {
		select {
		case data := <-m.broadcastMsg:
			{
				//遍历所有客户端，循环发送消息
				for _, client := range m.clients {
					client.sendMsg <- data;
				}
				break;
			}
		}
	}
}

//删除客户端
func (m *multiEchoServer) DelClient(c *client) error {
	c.conn.Close();
	clis := m.clients;
	delete(clis, c.id);
	m.clients = clis;
	return nil;
}

//处理客户端接收消息
func (c *client) RecvLoop() {
	defer func() {
		fmt.Println(c.conn.RemoteAddr().String() + " RecvLoop exit");
	}();
	for {
		read := bufio.NewReader(c.conn);
		data, err := read.ReadBytes('\n');
		if err != nil {
			c.isSendMsgClose <- true;
			//这里直接返回，如果不直接返回
			//当客户端退出时，这里会运行2次，导致c.isSendMsgClose<-true执行2次造成阻塞
			//没有机会运行后面的select，那么一直无法返回，不能回收。
			return;
		}

		select {
		//接收消息是否关闭
		case <-c.isRecvMsgClose:
			{
				c.isSendMsgClose <- true;
				return;
			}
		//广播消息
		case c.mes.broadcastMsg <- data:
			{
				break;
			}
		}
	}
}

//处理客户端发送消息
func (c *client) SendLoop() {
	defer func() {
		fmt.Println(c.conn.RemoteAddr().String() + " SendLoop exit");
	}();
	for {
		select {
		//发送消息关闭，则把客户端从服务中删除
		case <-c.isSendMsgClose:
			{
				c.mes.DelClient(c);
				return;
			}
		//向客户写入要发送的消息
		case data := <-c.sendMsg:
			{
				_, err := c.conn.Write(data);
				if err != nil {
					return;
				}
			}
		}
	}
}

func main() {
	mes := New();
	mes.Start(8888);

	//循环
	select {};
}