golang的聊天服务器实践(群聊，广播)

日期：2022-08-23 ;

golang的聊天服务器实践(群聊，广播)

其实从上学开始就一直想写一个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

相关内容

socket.io实现在线群聊

我自己在用socket.io开发，对官方网站上的文档，进行简单的整理，然后自己写了一个简单的聊天程序。最最开始

先安装socket.io:

1 npm install socket.io

利用Node的搭建Http服务

分为两个文件，服务端文件app.js和客户端index.html

app.js
01 var app = require(‘http‘).createServer(handler)02   , io = require(‘socket.io‘).listen(app)03   , fs = require(‘fs‘)04 
05 app.listen(80);06 
07 function handler (req, res) {08   fs.readFile(__dirname + ‘/index.html‘,09   function (err, data) {10     if (err) {11       res.writeHead(500);12       return res.end(‘Error loading index.html‘);13     }14 
15     res.writeHead(200);16     res.end(data);17   });18 }19 
20 io.sockets.on(‘connection‘, function (socket) {21   socket.emit(‘news‘, { hello: ‘world‘ });22   socket.on(‘my other event‘, function (data) {23     console.log(data);24   });25 });

这里需要注意的是： require(‘socket.io’).listen(app) 实际上这句就是讲socket的监听加入的app设置的http模块了 io.sockets.on(‘connection’,function()…)这里设置了在连接后进行的处理，代码示例中，主要包含两件事，一个是向前段发送news的事件，一个是监听my other event事件。

index.html
1 <script src="/socket.io/socket.io.js"></script>2 <script>3   var socket = io.connect(‘http://localhost‘);4   socket.on(‘news‘, function (data) {5     console.log(data);6     socket.emit(‘my other event‘, { my: ‘data‘ });7   });8 </script>

客户端一个引用了socket.io.js的javscript库还有就是连接服务器(通过io.connect(‘http://localhost’)) 之后在监听收到news的事件后，发送my other event事件

利用Express3框架上面的例子只是使用nodejs建立了一个交互，也可以使用express2的web框架，具体app.js代码如下：

ar app = require(‘express‘)()
 , server = require(‘http‘).createServer(app)
 , io = require(‘socket.io‘).listen(server);

server.listen(80);

app.get(‘/‘, function (req, res) {
 res.sendfile(__dirname + ‘/index.html‘);});

io.sockets.on(‘connection‘, function (socket) {
 socket.emit(‘news‘, { hello: ‘world‘ });
 socket.on(‘my other event‘, function (data) {
   console.log(data);
 });});

接收发送事件 socket.io允许用户自定义发送接收的事件。除了connect，message，disconnect三个事件外，用户可以自定义自己的事件

// note, io.listen(<port>) will create a http server for youvar io = require(‘socket.io‘).listen(80);

io.sockets.on(‘connection‘, function (socket) {
 io.sockets.emit(‘this‘, { will: ‘be received by everyone‘});

 socket.on(‘private message‘, function (from, msg) {
   console.log(‘I received a private message by ‘, from, ‘ saying ‘, msg);
 });

 socket.on(‘disconnect‘, function () {
   io.sockets.emit(‘user disconnected‘);
 });});

存储数据有的时候需要存储一些和客户端关联的数据在会话里，socket.io也是支持的，代码如下：

var io = require(‘socket.io‘).listen(80);

io.sockets.on(‘connection‘, function (socket) {
 socket.on(‘set nickname‘, function (name) {
   socket.set(‘nickname‘, name, function () {
     socket.emit(‘ready‘);
   });
 });

 socket.on(‘msg‘, function () {
   socket.get(‘nickname‘, function (err, name) {
     console.log(‘Chat message by ‘, name);
   });
 });});

socket.set和socket.get方法分为用于设置和获取变量。

设置命名空间有的时候要一个程序支持多个应用，如果使用默认的 “/” 命名空间可能会比较混乱。如果想让一个连接可以支持多个连接，可以使用如下的命名空间的方法：

app.js
var io = require(‘socket.io‘).listen(80);var chat = io
 .of(‘/chat‘)
 .on(‘connection‘, function (socket) {
   socket.emit(‘a message‘, {
       that: ‘only‘
     , ‘/chat‘: ‘will get‘
   });
   chat.emit(‘a message‘, {
       everyone: ‘in‘
     , ‘/chat‘: ‘will get‘
   });
 });

var news = io .of(‘/news’) .on(‘connection’, function (socket) { socket.emit(‘item’, { news: ‘item’ }); });

client.js
<script>
 var chat = io.connect(‘http://localhost/chat‘)
   , news = io.connect(‘http://localhost/news‘);
 
 chat.on(‘connect‘, function () {
   chat.emit(‘hi!‘);
 });
 
 news.on(‘news‘, function () {
   news.emit(‘woot‘);
 });</script>

发送获取数据有的时候，你需要在发送数据后，等待服务器的消息确认。当然简单的发，可以通过两次消息发送，来完成。这里介绍一种使用回调函数的方法：

app.js
var io = require(‘socket.io‘).listen(80);

io.sockets.on(‘connection‘, function (socket) {
 socket.on(‘ferret‘, function (name, fn) {
   fn(‘woot‘);
 });});
client.html
<script>
 var socket = io.connect(); // TIP: .connect with no args does auto-discovery
 socket.on(‘connect‘, function () { // TIP: you can avoid listening on `connect` and listen on events directly too!
   socket.emit(‘ferret‘, ‘tobi‘, function (data) {
     console.log(data); // data will be ‘woot‘
   });
 });</script>

广播向所有的连接触发事件，这里注意：不包括本身连接的事件。

var io = require(‘socket.io‘).listen(80);

io.sockets.on(‘connection‘, function (socket) {
 socket.broadcast.emit(‘user connected‘);});

我写的聊天程序：

index.html

<script src="/socket.io/socket.io.js"></script><script>
  var socket = io.connect(‘http://localhost‘);
    
    socket.on("notice", function(data){
        var msg = document.getElementById(‘all‘).value;
        document.getElementById(‘all‘).innerText = msg + "
" + data.message;
    });

    var chat_fn = function(){
        var msg = document.getElementById("message").value;
        socket.emit("chat", {message: msg});
    };


    socket.on("nickname ready", function(data){
        alert("nickname changed.");
    });

    var change_nickname = function(){
        var nickname = document.getElementById("nickname").value;
        socket.emit(‘set nickname‘, nickname);
    };</script><textarea id="all" cols=40 rows=20></textarea><br /><label>Message:</label><input id="message" type="text" name="message" cols=120/><input id="chat_btn" type="button" value="chat" onclick="javascript:chat_fn()" /><label>NickName:</label><input id="nickname" typee="text" name="nickname" /><input id="chang_name" type="button" value="nickname" onclick="javascript:change_nickname()" />

app.js

var app = require(‘http‘).createServer(handler)
  , io = require(‘socket.io‘).listen(app)
  , fs = require(‘fs‘);


app.listen(80);function handler (req, res) {
  fs.readFile(__dirname + ‘/index.html‘,
  function (err, data) {
    if (err) {
      res.writeHead(500);
      return res.end(‘Error loading index.html‘);
    }

    res.writeHead(200);
    res.end(data);
  });}

io.sockets.on(‘connection‘, function (socket) {
  // socket.emit(‘news‘, { hello: ‘world‘ });
  // socket.on(‘my other event‘, function (data) {
  //   console.log(data);
  // });

  socket.set(‘nickname‘, ‘nickname‘, function(){
  });

  socket.on(‘set nickname‘, function(name){
    socket.set(‘nickname‘, name, function(){
      console.log("change nickname=>" + name);
      socket.emit(‘nickname ready‘);
    });
  });

  socket.on(‘chat‘, function(data){
    socket.get(‘nickname‘, function(err, name){

    socket.emit("notice", {message: name + ":" + data.message});
    socket.broadcast.emit("notice", {message: name + ":" + data.message});
    console.log("chat: " + data.message);
    });
  });});

文章来源于网络，原文链接请点击 这里
文章版权归作者所有，如作者不同意请直接联系小编删除。
作者：吱吱吱(piperck)XD

golang的聊天服务器实践(群聊，广播)

本类热门