IM系统设计之websocket消息转发

于 2024-03-23 21:20:45 发布
阅读量1.2k 收藏 29
点赞数 23
分类专栏： IM系统 文章标签： websocket 网络协议 网络 go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wksycxy/article/details/136970780
版权

Websocket消息转发

项目地址：git@github.com:muyixiaoxi/Link.git

上周面试被面试官问到：“在分布式IM系统中，如何实现多个websocket集群之间的通信”。

我在思考了良久后回答：“不会”。

随着我的回答，我和面试官的故事也到此完结了…

为什么会出现websocket集群

在IM系统中，需要在服务端和客户端之间维持一个长连接，而这个长连接可以通过websocket实现。
但服务端能维持websocket的数量并不是无限的。

WebSocket的并发连接数受到多种因素的影响，其中最主要的瓶颈通常在于服务器资源。在传统的模型中，一台服务器上的最大WebSocket连接数受到操作系统中TCP/IP连接数的限制。在Linux系统中，每个IPv4地址允许的最大连接数为65535，这意味着如果每个连接都使用不同的IP地址，一台服务器最多只能维持65535个WebSocket连接。

当用户量很多时，一台websocket服务器远远是不够的，所以需要多台websocket服务器。

假如现在只有一台IM服务器（即 Websocket 服务器），用户A、用户B均在线，用户A向用户B发送一条消息
在这里插入图片描述
单台IM服务器发送消息大概流程如下：

  1. 客户端向IM服务端发送消息
  2. IM服务端收到消息判断用户B是否在线
    • 在线，Websocket转发
    • 离线，将消息存储到B的离线消息库
  3. 用户B立即了消息，或者在下次上线时收到了消息

因为现在只有一台IM服务器，所以直接可以判断用户B是否在线，并且转发。

假如现在我有多台IM服务器，重复上面的操作

如果恰巧A和B连接在一台IM服务器上，那么和上面的流程一样

假如现在A连接在IM1上，B连接在IM2上
在这里插入图片描述

其中红线的部分，就是我们要解决的部分

websocket集群通信

我查阅了网上的一些资料（这一块具体采用哪种技术栈实现，网上的资料很少），大概分为两种

方法一：互为客户端

分别将IM服务端与其他IM服务端连接起来，可以通过网络编程或者MQ来实现
在这里插入图片描述
优点：

  • 不需要额外的服务
  • 转发过程中，各个IM服务负载相对均匀

缺点：

  • 每增加一个IM服务端都需要其他服务端多维持一个连接或者MQ
  • 水平扩展有点繁琐

方法二：C/S

采用c/s架构，新建一个transmit服务，单独实现转发功能，可以通过网络编程或者MQ实现。
因为各个 IM 都与 transmit 连接，所以扩展只需要该配置文件的运行端口
在这里插入图片描述
优点：

  • 高可用，IM server扩展方便，只需要修改自己的运行端口

缺点：

  • 不同服务端之间的消息需要通过 transmit 转发，当海量消息时，对 transmit 压力比较大
代码实现

为了实现消息的时效性，以及高可用，我采用net包中的tcp实现了c/s架构
项目目录如下：

transmit:
│  client.go
│  main.go
│
├─common
│  └─proto
│          proto.go
│
└─types
        types.go
proto

使用 net 包的 tcp 可能会出现粘包现象，封装编码与解码方法从而避免粘包

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"github.com/zeromicro/go-zero/core/logx"
	"net"
	"sync"
	"transmit/common/proto"
	"transmit/types"
)

var Connects sync.Map

func main() {
	listenClient()
}

// listenClient 监听
func listenClient() {
	lister, err := net.Listen("tcp", "127.0.0.1:8333")
	if err != nil {
		fmt.Println("net.Listen failed:", err)
	}
	for {
		conn, err := lister.Accept()
		if err != nil {
			continue
		}
		fmt.Println(conn.RemoteAddr().String())
		Connects.Swap(conn.RemoteAddr().String(), conn)
		go addReceiver(conn)
	}
}

// addReceiver 向连接添加接收器
func addReceiver(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	for {
		m, err := proto.Decode(reader)
		if err != nil {
			fmt.Println("与客户端", conn.LocalAddr(), "断开连接")
			return
		}
		transmit := types.TransmitMap{}
		json.Unmarshal([]byte(m), &transmit)
		// 读到消息后，根据服务器进行转发
		for connect := range transmit.Users {
			transmitMessage(conn, connect, transmit)
		}
	}
}

func transmitMessage(conn net.Conn, ip string, transmit types.TransmitMap) {
	c, ok := Connects.Load(ip)
	message := types.TransmitMap{
		Users: map[string][]uint64{},
	}
	if !ok {
		message = types.TransmitMap{
			Message: types.Message{
				Id:          "",
				From:        0,
				To:          0,
				Type:        100,
				ContentType: 0,
				Time:        "",
				Content:     "客户端离线",
			},
		}
		s, _ := json.Marshal(message)
		msg, _ := proto.Encode(string(s))
		conn.Write(msg)
		fmt.Println("客户端离线：", ip)
		logx.Error("connect ip offline:", ip)
		return
	}
	message.Users[ip] = transmit.Users[ip]
	message.Message = transmit.Message
	j, _ := json.Marshal(message)
	msg, _ := proto.Encode(string(j))
	fmt.Println("ip:", ip, "msg:", string(msg))
	c.(net.Conn).Write(msg)
}
main

通过监听某个端口，让 IM server与其建立间接，实现转发功能

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"github.com/zeromicro/go-zero/core/logx"
	"net"
	"sync"
	"transmit/common/proto"
	"transmit/types"
)

var Connects sync.Map

func main() {
	listenClient()
}

// listenClient 监听
func listenClient() {
	lister, err := net.Listen("tcp", "127.0.0.1:8333")
	if err != nil {
		fmt.Println("net.Listen failed:", err)
	}
	for {
		conn, err := lister.Accept()
		if err != nil {
			continue
		}
		fmt.Println(conn.RemoteAddr().String())
		Connects.Swap(conn.RemoteAddr().String(), conn)
		go addReceiver(conn)
	}
}

// addReceiver 向连接添加接收器
func addReceiver(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	for {
		m, err := proto.Decode(reader)
		if err != nil {
			fmt.Println("与客户端", conn.LocalAddr(), "断开连接")
			return
		}
		transmit := types.TransmitMap{}
		json.Unmarshal([]byte(m), &transmit)
		// 读到消息后，根据服务器进行转发
		for connect := range transmit.Users {
			transmitMessage(conn, connect, transmit)
		}
	}
}

func transmitMessage(conn net.Conn, ip string, transmit types.TransmitMap) {
	c, ok := Connects.Load(ip)
	message := types.TransmitMap{
		Users: map[string][]uint64{},
	}
	if !ok {
		message = types.TransmitMap{
			Message: types.Message{
				Id:          "",
				From:        0,
				To:          0,
				Type:        100,
				ContentType: 0,
				Time:        "",
				Content:     "客户端离线",
			},
		}
		s, _ := json.Marshal(message)
		msg, _ := proto.Encode(string(s))
		conn.Write(msg)
		fmt.Println("客户端离线：", ip)
		logx.Error("connect ip offline:", ip)
		return
	}
	message.Users[ip] = transmit.Users[ip]
	message.Message = transmit.Message
	j, _ := json.Marshal(message)
	msg, _ := proto.Encode(string(j))
	fmt.Println("ip:", ip, "msg:", string(msg))
	c.(net.Conn).Write(msg)
}
client

模拟客户端，根据自己的项目拆分到 IM server中

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"net"
	"time"
	"transmit/common/proto"
	"transmit/types"
)

func client() {
	conn, _ := InitConnect()
	go Consumer(conn)
	var ip string
	message := types.Message{
		Id:          "123",
		From:        1,
		To:          2,
		Type:        1,
		ContentType: 1,
		Time:        "123",
		Content:     "你好",
	}
	for {
		fmt.Scan(&ip)
		users := map[string][]uint64{}
		users[ip] = []uint64{1, 2}
		time.Sleep(2 * time.Second)
		if err := Producer(conn, users, message); err != nil {
			fmt.Println("Producer(conn, ip, message) failed", err)
		}
	}

}

func InitConnect() (conn net.Conn, err error) {
	conn, err = net.Dial("tcp", "127.0.0.1:8333")
	fmt.Println(conn.LocalAddr())
	return
}

func Producer(conn net.Conn, user map[string][]uint64, mes types.Message) (err error) {
	transmit := types.TransmitMap{
		Users:   user,
		Message: mes,
	}
	message, _ := json.Marshal(transmit)
	m, _ := proto.Encode(string(message))
	_, err = conn.Write(m)
	if err != nil {
		// 重试三次，一次休眠一秒
		for i := 0; i < 3 && err != nil; i++ {
			time.Sleep(1 * time.Second)
			_, err = conn.Write(m)
		}
	}
	return
}

// Consumer 消费者 读消息
func Consumer(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	for {
		m, err := proto.Decode(reader)
		if err != nil {
			continue
		}
		transmit := types.TransmitMap{}
		json.Unmarshal([]byte(m), &transmit)
		// 读到消息后，进行转发
		for _, uIds := range transmit.Users {
			for _, id := range uIds {
				fmt.Println(id, transmit.Message)
			}
		}
	}
}
types

在转发群聊消息时，需要将 m 个用户转发到 n 个IM服务端上，如果单独发送需要多次发送，所以封装成 TransmitMap 进行转发。

type Message struct {
	Id          string `json:"id"`
	From        uint64 `json:"from,optional"`
	To          uint64 `json:"to"`
	Type        uint32 `json:"type"`
	ContentType uint32 `json:"contentType"`
	Time        string `json:"time"`
	Content     string `json:"content"`
}


type TransmitMap struct {
	Users map[string][]uint64 `json:"users"`  // map[主机地址]用户集合
	Message
}

为什么这里要封装一个?

type TransmitMap struct {
	Users map[string][]uint64 `json:"users"`
	Message
}

比如用户A、B、C、D、E、F、G在同一个群聊里，各自连接到的 IM server 如图所示
在这里插入图片描述
如果群聊消息采用上面单聊的转发方式

  1. 用户A发送一条消息
  2. IM server1 收到群聊消息，查找群里的其他用户（B、C、D、E、F、G）
  3. 判断哪些用户在当前 IM servier 上，发现 B，直接转发
  4. 遍历（B、C、D、E、F、G）： 将在线用户消息转发消息到 transmit
  5. …

如果不做任何操作的化，光过程 4 就需要转发5次消息

用户A发送一条群聊消息的过程

  1. 用户A发送一条群聊消息
  2. IM server1 收到群聊消息，查找群里的其他用户（B、C、D、E、F、G）
  3. 判断哪些用户在当前 IM servier 上，发现 B，直接转发
  4. 通过 redis 判断哪些用户在线并获取主机地址，将通过map将相同地址的用户分类 map[主机地址]用户集合，一块转发到 transmit
  5. transmit 以主机地址为组，将消息发送给 IM server2 和 IM server3
  6. IM server2 和 IM server3 收到消息后，将消息进行转发
  7. 离线用户同步离线消息库

这样的好处是，有效的减少群聊消息转发的次数。

ps:如果存在哪些不足，欢迎大家在评论区指正~

木易小熙
关注
  • 23
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
websocket 并发_1230万个并发WebSocket
cullen2012的博客
09-10 3549
websocket 并发One thing about WebSockets is that you need a lot of resources on the client's side to generate high enough load for the server to actually eat up all the CPU resources. 关于WebSockets的一件事是，...
niginx 配置代理websokcet
qq_40167174的博客
03-20 786
server { listen 80; server_name xxx.xxx.cn; client_max_body_size 20m; location / { proxy_redirect off; proxy_set_header Host $host:$server_port; ...
Python-一个简单的代理可以将Websocket消息转发到Unix套接字反之亦然
08-10
这是Websockets和Unix域套接字之间非常简单的代理。 它充当Websocket服务器，同时将所有消息转发到指定的Unix套接字。
gateway转发websocket
lqz1993的博客
07-06 2436
gateway转发websocket和netty-webSocket
nginx配置websocket转发功能
Leon_Jinhai_Sun的博客
07-14 677
之前配置好了服务器上面的linux-dash和jupyter notebook，然后想着每次都是要输入ip和端口很麻烦，于是想给它配置个网址，然后用Nginx转发过去。 前面都很顺利，DNS解析增加记录，配置Nginx。 但是遇到了奇怪的问题， linux-dash迟迟不显示系统状态，重启了N遍还是没办法， jupyter能登录但是没办法连接到内核，显示kernel error，点开就是not found。 找了很久的问题，最后猜测是nginx的问题，然后发现他们都有个共同点那就是用了websocke
基于websocket实现将公网请求映射到本地的请求转发(服务端篇)
xiong305的博客
03-09 1663
公网ip可以被互联网访问，而本机的私有ip则不被允许，如何实现将公网ip的请求映射到本机的室友ip呢，我们基于websocket技术，将访问服务器的请求全部转发到本机上websocket实现的话，是需要分为两个端，第一个是放在公网的服务端，第二个是放在本机的客户端，客户端则需要主动的去请求公网的服务端，实现连接成功后，服务端会把所有的请求推给客户端，客户端处理完成后，则将处理结果返回给服务端，再由服务端返回给请求端技术框架的使用的是springboot框架，这里只展示有用的代码。
基于WebSocket的企业级即时通讯WebIM，使用EXTJS做为前端设计工具
11-12
1. **WebSocket服务器**：作为核心组件，负责处理客户端的连接、断开以及消息的转发。它可以基于诸如Node.js的Socket.IO库或者Java的Jetty等WebSocket实现。 2. **EXTJS前端**：通过EXTJS的组件库，构建用户界面，...
java即时通讯(IM)系统.zip
06-21
Java IM系统通常采用客户端-服务器（C/S）架构，其中服务器负责处理消息的转发、存储和用户管理，而客户端则作为用户界面，用于接收和发送消息。服务器端可能包含多个组件，如认证服务器、消息服务器和状态服务器等...
Netty 仿写微信 IM 即时通讯系统.zip
02-05
通过这个项目，开发者不仅可以学习到Netty的基本用法，还能深入理解IM系统的架构设计和实现细节，提高在网络编程和分布式系统领域的技能。同时，这个项目也是实践理论知识、提升问题解决能力的好平台。
IM.rar_im_及时通讯
09-21
2. **服务器**：处理客户端请求，存储和转发消息，维护用户状态。这里服务器端使用C#实现，可能包含了WebSocket或HTTP长轮询等技术来实现实时通讯。 3. **协议**：定义客户端和服务端如何交换数据，如XMPP、MQTT或...
websocket 示例发送广播
07-29
http://localhost:8080/websocketServer/broadcast.html 发送广播 http://localhost:8080/websocketServer/client.html 接收消息
基于Nodejswebsocketsocketio的消息转发系统
08-11
基于Nodejs的消息转发系统 message pusher written in nodejs based on socket.io and express4。
基于Java的小程序+Socket+Node的IM系统毕业设计与实现.zip
03-09
在这个基于Java的小程序+Socket+Node的IM系统毕业设计中，开发者构建了一个实时通信平台，融合了多种技术，包括Java后端开发、WebSocket协议、以及Node.js环境下的服务端搭建。这个项目旨在提供一个功能完善的即时...
IM即时通讯的技术123
09-01
- 提供的技术文档可能包括系统设计图、API接口文档、数据库设计文档等，这些是理解并开发IM系统的重要参考资料。 10. **即时通讯系统PPT**： - PPT文件可能包含系统架构的概述、关键技术讲解、流程图和用例分析，...
ten_im.rar
06-20
【腾讯即时通讯IM的Web端调试Demo】是一个用于学习和测试腾讯即时通讯系统的重要资源，主要涵盖注册、创群、加群以及发送聊天等基础功能。这个压缩包文件"ten_im.rar"包含了实现这些功能的源代码和相关配置，使得...
WebSocket端口转发：一步步教你实现高效通信
奇妙的Bug之旅
10-25 819
在现代网络应用中，WebSocket 是一种非常有用的技术，它允许客户端和服务器之间进行双向实时通信。然而，有时候我们需要将 WebSocket 流量从一个端口转发到另一个端口，以实现更灵活的网络配置或提高安全性。本文将详细介绍如何使用 Nginx 实现 WebSocket 端口转发。现在，Nginx 已经配置为将客户端请求的 WebSocket 流量从一个端口转发到另一个端口。这样，我们就可以实现更灵活的网络配置或提高安全性。希望本文对你有所帮助！最后，我们需要重启 Nginx 以使更改生效。
nginx支持websocket转发
u013104575的博客
06-24 555
nginx支持websocket转发 nginx配置文件： server { listen 80; server_name localhost; access_log /var/log/nginx/access_80_log main; location / { proxy_pass http://127.0.0.1:4000; proxy_ht...
C# WebSocket通讯 转发mqtt信息
Suxiang1997的博客
05-26 864
如前所述，基于发布/订阅）模式的“轻量级”通讯协议，该协议构建于TCP/IP协议上MQTT最大优点在于，。低开销、低带宽占用的即时通讯协议。
配置springcloud 网关gateway 转发websocket请求
最新发布
x_h_j_的博客
03-08 1410
每个条件都是一个谓词（Predicate），可以基于请求的各种属性进行匹配，例如请求方法（GET、POST等）、路径模式、查询参数、头信息等。如果请求满足所有谓词条件，那么它就会被路由到该路由配置的下游服务。是一个过滤器列表，用于在请求被转发到下游服务之前或响应返回给客户端之前对请求和响应进行处理。过滤器可以是内置的（如StripPrefix、Retry等），也可以是自定义的。它可以是一个绝对URL，也可以是一个相对于网关的相对URL。它是可选的，但建议为每个路由提供一个有意义的ID，以便于管理和诊断。
websocket转发
04-29
因此，您应该仔细设计您的WebSocket转发服务，以确保它能够处理高并发的连接和消息。 3. 可靠性：WebSocket转发需要在网络不稳定的环境下正常工作。因此，您应该使用一些机制，如心跳检测、消息重传等，来保证...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值