百万级并发 - IM项目实战

最新推荐文章于 2023-09-02 19:22:54 发布
VIP文章 最新推荐文章于 2023-09-02 19:22:54 发布
阅读量1.6k 收藏 8
点赞数 2
分类专栏： Golang 项目实战 文章标签： 系统架构 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42063529/article/details/128236144
版权

百万级并发 - IM项目实战

需求分析：

项目目的：

项目背景：IM对性能和体验敏感度非常高 。 大厂必备

你将获得什么：

熟悉开发流程 ，熟练相关技术栈 gin+GORM+swagger + logrus auth 等中间件，三高性能

核心功能：

​ 发送和接受消息，文字 表情 图片 音频 ，访客，点对点，群聊 ，广播，快捷回复，撤回，心跳检测…

技术栈：

​ 前端 后端 （webSocket ,channel/goroutine ,gin ,temlate,gorm ,sql,nosql,mq…）

系统架构：

​ 四层：前端，接入层，逻辑层，持久层

消息发送流程：

​ A > 登录> 鉴权>(游客) > 消息类型 >(群/广播) > B

环境搭建：

​ go version go1.17.8 windows/amd64

​ set GO111MODULE=on

​ go mod init go_exam

​ go mod tidy

系统架构

image-1666343867758

核心流程：

image-1666343894583

image-1666343928806

image-1666343946893

效果展示：

image-1666344179175

image-1666344192229

image-1666344202937

image-1666344215099

image-1666344227541

image-1666344237243

image-1666344247334

image-1666344268342

image-1666344280635

image-1666344295006

部分项目代码展示

image-1666344380115

image-1666344404391

image-1666344418358

image-1666344432655

功能实现

完成用户模块基本的

加入修改电话号码和邮箱 并校验

先引入

 get github.com/asaskevich/govalidator
 结构体字段后面 加检验规则  
 最后service govalidator.ValidatorStrut(user)

1.router包 app.go

	r.GET("/user/getUserList", service.GetUserList)
	r.GET("/user/createUser", service.CreateUser)
	r.GET("/user/deleteUser", service.DeleteUser)
	r.POST("/user/updateUser", service.UpdateUser)

2.service 包 userservice.go

// GetUserList
// @Summary 所有用户
// @Tags 用户模块
// @Success 200 {string} json{"code","message"}
// @Router /user/getUserList [get]
func GetUserList(c *gin.Context) {
	data := make([]*models.UserBasic, 10)
	data = models.GetUserList()

	c.JSON(200, gin.H{
		"message": data,
	})
}

// CreateUser
// @Summary 新增用户
// @Tags 用户模块
// @param name query string false "用户名"
// @param password query string false "密码"
// @param repassword query string false "确认密码"
// @Success 200 {string} json{"code","message"}
// @Router /user/createUser [get]
func CreateUser(c *gin.Context) {
	user := models.UserBasic{}
	user.Name = c.Query("name")
	password := c.Query("password")
	repassword := c.Query("repassword")
	if password != repassword {
		c.JSON(-1, gin.H{
			"message": "两次密码不一致！",
		})
		return
	}
	user.PassWord = password
	models.CreateUser(user)
	c.JSON(200, gin.H{
		"message": "新增用户成功！",
	})
}

// DeleteUser
// @Summary 删除用户
// @Tags 用户模块
// @param id query string false "id"
// @Success 200 {string} json{"code","message"}
// @Router /user/deleteUser [get]
func DeleteUser(c *gin.Context) {
	user := models.UserBasic{}
	id, _ := strconv.Atoi(c.Query("id"))
	user.ID = uint(id)
	models.DeleteUser(user)
	c.JSON(200, gin.H{
		"message": "删除用户成功！",
	})
}

// UpdateUser
// @Summary 修改用户
// @Tags 用户模块
// @param id formData string false "id"
// @param name formData string false "name"
// @param password formData string false "password"
// @param phone formData string false "phone"
// @param email formData string false "email"
// @Success 200 {string} json{"code","message"}
// @Router /user/updateUser [post]
func UpdateUser(c *gin.Context) {
	user := models.UserBasic{}
	id, _ := strconv.Atoi(c.PostForm("id"))
	user.ID = uint(id)
	user.Name = c.PostForm("name")
	user.PassWord = c.PostForm("password")
	user.Phone = c.PostForm("phone")
	user.Email = c.PostForm("email")
	fmt.Println("update :", user)

	_, err := govalidator.ValidateStruct(user)
	if err != nil {
		fmt.Println(err)
		c.JSON(200, gin.H{
			"message": "修改参数不匹配！",
		})
	} else {
		models.UpdateUser(user)
		c.JSON(200, gin.H{
			"message": "修改用户成功！",
		})
	}

}

3.modesl包 user_basic.go

	Phone         string `valid:"matches(^1[3-9]{1}\\d{9}$)"`
	Email         string `valid:"email"`

4，然后测试 

重复注册校验：

func FindUserByName(name string) UserBasic {
	user := UserBasic{}
	utils.DB.Where("name = ?", name).First(&user)
	return user
}
func FindUserByPhone(phone string) *gorm.DB {
	user := UserBasic{}
	return utils.DB.Where("Phone = ?", phone).First(&user)
}
func FindUserByEmail(email string) *gorm.DB {
	user := UserBasic{}
	return utils.DB.Where("email = ?", email).First(&user)
}


再到service层 加入判断
	data := models.FindUserByName(user.Name)
	if data.Name != "" {
		c.JSON(-1, gin.H{
			"message": "用户名已注册！",
		})
		return
	}

注册 加密操作

package utils

import (
	"crypto/md5"
	"encoding/hex"
	"fmt"
	"strings"
)

//小写
func Md5Encode(data string) string {
	h := md5.New()
	h.Write([]byte(data))
	tempStr := h.Sum(nil)
	return hex.EncodeToString(tempStr)
}

//大写
func MD5Encode(data string) string {
	return strings.ToUpper(Md5Encode(data))
}

//加密
func MakePassword(plainpwd, salt string) string {
	return Md5Encode(plainpwd + salt)
}

//解密
func ValidPassword(plainpwd, salt string, password string) bool {
	md := Md5Encode(plainpwd + salt)
	fmt.Println(md + "				" + password)
	return md == password
}



service层 判断之后加入
	//user.PassWord = password
	user.PassWord = utils.MakePassword(password, salt)
	user.Salt = salt  //表更新了字段  db.AutoMigrate(&models.UserBasic{})
	fmt.Println(user.PassWord)
	models.CreateUser(user)

登录解密 ：

//dao层 
func FindUserByNameAndPwd(name string, password string) UserBasic {
	user := UserBasic{}
	utils.DB.Where("name = ? and pass_word=?", name, password).First(&user)
	return user
}



// GetUserList
// @Summary 所有用户
// @Tags 用户模块
// @param name query string false "用户名"
// @param password query string false "密码"
// @Success 200 {string} json{"code","message"}
// @Router /user/findUserByNameAndPwd [get]
func FindUserByNameAndPwd(c *gin.Context) {
	data := models.UserBasic{}

	name := c.Query("name")
	password := c.Query("password")
	user := models.FindUserByName(name)
	if user.Name == "" {
		c.JSON(200, gin.H{
			"message": "该用户不存在",
		})
		return
	}

	flag := utils.ValidPassword(password, user.Salt, user.PassWord)
	if !flag {
		c.JSON(200, gin.H{
			"message": "密码不正确",
		})
		return
	}
	pwd := utils.MakePassword(password, user.Salt)
	data = models.FindUserByNameAndPwd(name, pwd)

	c.JSON(200, gin.H{
		"message": data,
	})
}



router层  ：

r.POST("/user/findUserByNameAndPwd", service.FindUserByNameAndPwd)

token的加入对返回的结构调整 。

修改登录的方法：

func FindUserByNameAndPwd(name string, password string) UserBasic {
	user := UserBasic{}
	utils.DB.Where("name = ? and pass_word=?", name, password).First(&user)

	//token加密
	str := fmt.Sprintf("%d", time.Now().Unix())
	temp := utils.MD5Encode(str)
	utils.DB.Model(&user).Where("id = ?", user.ID).Update("identity", temp)
	return user
}


// 返回的结果：
	c.JSON(200, gin.H{
			"code":    0, //  0成功   -1失败
			"message": "修改用户成功！",
			"data":    user,
		})

加入Redis

go get github.com/go-redis/redis

配置redis

redis:
  addr: "192.168.137.131:6379"
  password: ""
  DB: 0
  poolSize: 30
  minIdleConn: 30

然后main方法中

utils.InitRedis()

最后再 utils

func InitRedis() {
	Red = redis.NewClient(&redis.Options{
		Addr:         viper.GetString("redis.addr"),
		Password:     viper.GetString("redis.password"),
		DB:           viper.GetInt("redis.DB"),
		PoolSize:     viper.GetInt("redis.poolSize"),
		MinIdleConns: viper.GetInt("redis.minIdleConn"),
	})
	pong, err := Red.Ping().Result()
	if err != nil {
		fmt.Println("init redis  。。。。", err)
	} else {
		fmt.Println(" Redis inited 。。。。", pong)
	}
}

测试看是否正常

通过WebSocket通信

go get github.com/gorilla/websocket
go get github.com/go-redis/redis/v8



package utils

import (
	"context"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/go-redis/redis/v8"
	"github.com/spf13/viper"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

var (
	DB  *gorm.DB
	Red *redis.Client
)

func InitConfig() {
	viper.SetConfigName("app")
	viper.AddConfigPath("config")
	err := viper.ReadInConfig()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("config  app inited 。。。。")
}

func InitMySQL() {
	//自定义日志模板 打印SQL语句
	newLogger := logger.New(
		log.New(os.Stdout, "\r\n", log.LstdFlags),
		logger.Config{
			SlowThreshold: time.Second, //慢SQL阈值
			LogLevel:      logger.Info, //级别
			Colorful:      true,        //彩色
		},
	)

	DB, _ = gorm.Open(mysql.Open(viper.GetString("mysql.dns")),
		&gorm.Config{Logger: newLogger})
	fmt.Println(" MySQL inited 。。。。")
	//user := models.UserBasic{}
	//DB.Find(&user)
	//fmt.Println(user)
}

func InitRedis() {
	Red = redis.NewClient(&redis.Options{
		Addr:         viper.GetString("redis.addr"),
		Password:     viper.GetString("redis.password"),
		DB:           viper.GetInt("redis.DB"),
		PoolSize:     viper.GetInt("redis.poolSize"),
		MinIdleConns: viper.GetInt("redis.minIdleConn"),
	})
}

const (
	PublishKey = "websocket"
)

//Publish 发布消息到Redis
func Publish(ctx context.Context, channel string, msg string) error {
	var err error
	fmt.Println("Publish 。。。。", msg)
	err = Red.Publish(ctx, channel, msg).Err()
	if err != nil {
		fmt.Println(err)
	}
	return err
}

//Subscribe 订阅Redis消息
func Subscribe(ctx context.Context, channel string) (string, error) {
	sub := Red.Subscribe(ctx, channel)
	fmt.Println("Subscribe 。。。。", ctx)
	msg, err := sub.ReceiveMessage(ctx)
	if err != nil {
		fmt.Println(err)
		return "", err
	}
	fmt.Println("Subscribe 。。。。", msg.Payload)
	return msg.Payload, err
}





userservice.go中加入

//防止跨域站点伪造请求
var upGrader = websocket.Upgrader{
	CheckOrigin: func(r *http.Request) bool {
		return true
	},
}

func SendMsg(c *gin.Context) {
	ws, err := upGrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer func(ws *websocket.Conn) {
		err = ws.Close()
		if err != nil {
			fmt.Println(err)
		}
	}(ws)
	MsgHandler(c, ws)
}
func MsgHandler(c *gin.Context, ws *websocket.Conn) {
	for {
		msg, err := utils.Subscribe(c, utils.PublishKey)
		if err != nil {
			fmt.Println(" MsgHandler 发送失败", err)
		}

		tm := time.Now().Format("2006-01-02 15:04:05")
		m := fmt.Sprintf("[ws][%s]:%s", tm, msg)
		err = ws.WriteMessage(1, []byte(m))
		if err != nil {
			log.Fatalln(err)
		}
	}
}



router层 app.go
	//发送消息
	r.GET("/user/sendMsg", service.SendMsg)

测试： http://www.jsons.cn/websocket/

ws://localhost:8081/user/sendMsg

设计 关系表 ，群信息表 ，消息表

package models

import "gorm.io/gorm"

//消息
type Message struct {
	gorm.Model
	FormId   uint   //发送者
	TargetId uint   //接受者
	Type     string //消息类型  群聊 私聊 广播
	Media    int    //消息类型  文字 图片 音频
	Content  string //消息内容
	Pic      string
	Url      string
	Desc     string
	Amount   int //其他数字统计
}

func (table *Message) TableName() string {
	return "message"
}


package models

import "gorm.io/gorm"

//群信息
type GroupBasic struct {
	gorm.Model
	Name    string
	OwnerId uint
	Icon    string
	Type    int
	Desc    string
}

func (table *GroupBasic) TableName() string {
	return "group_basic"
}

package models

import "gorm.io/gorm"

//人员关系
type Contact struct {
	gorm.Model
	OwnerId  uint //谁的关系信息
	TargetId uint //对应的谁
	Type     int  //对应的类型  0  1  3
	Desc     string
}

func (table *Contact) TableName() string {
	return "contact"
}

发送消息 接受消息

​ 需要 ：发送者ID ，接受者ID ，消息类型，发送的内容，发送类型

​ 校验token ，关系 ，

package models

import (
	"encoding/json"
	"fmt"
	"net"
	"net/http"
	"strconv"
	"sync"

	"github.com/gorilla/websocket"
	"gopkg.in/fatih/set.v0"
	"gorm.io/gorm"
)

//消息
type Message struct {
	gorm.Model
	FormId   int64  //发送者
	TargetId int64  //接受者
	Type     int    //发送类型  群聊 私聊 广播
	Media    int    //消息类型  文字 图片 音频
	Content  string //消息内容
	Pic      string
	Url      string
	Desc     string
	Amount   int //其他数字统计
}

func (table *Message) TableName() string {
	return "message"
}

type Node struct {
	Conn      *websocket.Conn
	DataQueue chan []byte
	GroupSets set.Interface
}

//映射关系
var clientMap map[int64]*Node = make(map[int64]*Node, 0)

//读写锁
var rwLocker sync.RWMutex

//	需要 ：发送者ID ，接受者ID ，消息类型，发送的内容，发送类型
func Chat(writer http.ResponseWriter, request *http.Request) {
	//1.  获取参数 并 检验 token 等合法性
	//token := query.Get("token")
	query := request.URL.Query()
	Id := query.Get("userId")
	userId, _ := strconv.ParseInt(Id, 10, 64)
	//msgType := query.Get("type")
	//targetId := query.Get("targetId")
	//	context := query.Get("context")
	isvalida := true //checkToke()  待.........
	conn, err := (&websocket.Upgrader{
		//token 校验
		CheckOrigin: func(r *http.Request) bool {
			return isvalida
		},
	}).Upgrade(writer, request, nil)
	if err != nil {
		fmt.Println(err)
		return
	}
	//2.获取conn
	node := &Node{
		Conn:      conn,
		DataQueue: make(chan []byte, 50),
		GroupSets: set.New(set.ThreadSafe),
	}
	//3. 用户关系
	//4. userid 跟 node绑定 并加锁
	rwLocker.Lock()
	clientMap[userId] = node
	rwLocker.Unlock()
	//5.完成发送逻辑
	go sendProc(node)
	//6.完成接受逻辑
	go recvProc(node)
	sendMsg(userId, []byte("欢迎进入聊天系统"))

}

func sendProc(node *Node) {
	for {
		select {
		case data := <-node.DataQueue:
			err := node.Conn.WriteMessage(websocket.TextMessage, data)
			if err != nil {
				fmt.Println(err)
				return
			}
		}
	}
}

func recvProc(node *Node) {
	for {
		_, data, err := node.Conn.ReadMessage()
		if err != nil {
			fmt.Println(err)
			return
		}
		broadMsg(data)
		fmt.Println("[ws] <<<<< ", data)
	}
}

var udpsendChan chan []byte = make(chan []byte, 1024)

func broadMsg(data []byte) {
	udpsendChan <- data
}

func init() {
	go udpSendProc()
	go udpRecvProc()
}

//完成udp数据发送协程
func udpSendProc() {
	con, err := net.DialUDP("udp", nil, &net.UDPAddr{
		IP:   net.IPv4(192, 168, 0, 255),
		Port: 3000,
	})
	defer con.Close()
	if err != nil {
		fmt.Println(err)
	}
	for {
		select {
		case data := <-udpsendChan:
			_, err := con.Write(data)
			if err != nil {
				fmt.Println(err)
				return
			}
		}
	}

}

//完成udp数据接收协程
func udpRecvProc() {
	con, err := net.ListenUDP("udp", &net.UDPAddr{
		IP:   net.IPv4zero,
		Port: 3000,
	})
	if err != nil {
		fmt.Println(err)
	}
	defer con.Close()
	for {
		var buf [512]byte
		n, err := con.Read(buf[0:])
		if err != nil {
			fmt.Println(err)
			return
		}
		dispatch(buf[0:n])
	}
}

//后端调度逻辑处理
func dispatch(data []byte) {
	msg := Message{}
	err := json.Unmarshal(data, &msg)
	if err != nil {
		fmt.Println(err)
		return
	}
	switch msg.Type {
	case 1: //私信
		sendMsg(msg.TargetId, data)
		// case 2:  //群发
		// 	sendGroupMsg()
		// case 3://广播
		// 	sendAllMsg()
		//case 4:
		//
	}
}

func sendMsg(userId int64, msg []byte) {
	rwLocker.RLock()
	node, ok := clientMap[userId]
	rwLocker.RUnlock()
	if ok {
		node.DataQueue <- msg
	}
}

集成html 登录和注册

//app.go  加入 
	//首页
	r.GET("/", service.GetIndex)
	r.GET("/index", service.GetIndex)
	r.GET("/toRegister", service.ToRegister)


// index.go
package service

import (
	"text/template"

	"github.com/gin-gonic/gin"
)

// GetIndex
// @Tags 首页
// @Success 200 {string} welcome
// @Router /index [get]
func GetIndex(c *gin.Context) {
	ind, err := template.ParseFiles("index.html", "views/chat/head.html")
	if err != nil {
		panic(err)
	}
	ind.Execute(c.Writer, "index")
	// c.JSON(200, gin.H{
	// 	"message": "welcome !!  ",
	// })
}

func ToRegister(c *gin.Context) {
	ind, err := template.ParseFiles("views/user/register.html")
	if err != nil {
		panic(err)
	}
	ind.Execute(c.Writer, "register")
	// c.JSON(200, gin.H{
	// 	"message": "welcome !!  ",
	// })
}

然后页面 ：

<!DOCTYPE html>
<html>

<head>
    <!--js include-->
    {
  {template "/chat/head.shtml"}}
</head>
<body>

<header class="mui-bar mui-bar-nav">
    <h1 class="mui-title">登录</h1>
</header>
{
  {.}}
<div class
最低0.47元/天 解锁文章
申专
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
马士兵百万级并发IM即时消息系统
08-31
马士兵百万级并发IM即时消息系统
腾讯IM实战：低代码超快实现即时通讯录
黑马程序员官方博客
07-20 2144
腾讯im是一套完整的即时通讯产品，说白了就是别人写好的可以做类似于qq聊天这样功能的代码包，底层是qq的sdk支持，功能强大。
IM即时通讯项目框架分析
qq_46118239的博客
02-19 6917
推荐一个零声学院免费公开课程，个人觉得老师讲得不错，分享给大家：Linux，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK等技术内容，立即学习 1 IM即时通讯项目框架分析和部署 1. 即时通讯框架分析和部署 2. 登录服务器和消息服务器设计 3. 路由服务器设计 4. 数据库代理服务器设计 5. 文件服务器和docker部署 6. 性能测试和k8s上云发布 1.1 即时通讯应用场景 即时通讯
百万消息量IM系统技术要点分享
蔚可云的博客
06-23 485
我们仔细观察就能发现，生活中的任何类型互联网服务都有 IM 系统的存在。比如： 1）基础性服务类-腾讯新闻（评论消息）； 2）商务应用类-钉钉（审批工作流通知）； 3）交流娱乐类-QQ/微信（私聊群聊 &讨论组 &朋友圈）； 4）互联网自媒体-抖音快手（点赞打赏通知）。 在这些林林总总的互联网生态产品里，即时消息系统作为底层能力，在确保业务正常与用户体验优化上，始终扮演了至关重要的角色。所以，现如今的互联网产品中，即时通讯技术已经不仅限于传统IM聊天工具本身，它早已通过有形或无形的方
golang im实战入门
qq_18447271的博客
10-27 1690
学了这篇文章，搞定im不成问题
基于gin + websocket单台机器支持百万连接分布式聊天(IM)系统
JineD的博客
11-30 6815
本文将介绍如何实现一个基于websocket分布式聊天(IM)系统。 使用golang实现websocket通讯，单机可以支持百万连接，使用gin框架、nginx负载、可以水平部署、程序内部相互通讯、使用grpc通讯协议。 本文内容比较长，如果直接想clone项目体验直接进入项目体验 goWebSocket项目下载 ,文本从介绍webSocket是什么开始，然后开始介绍这个项目，以及在Nginx中配置域名做webSocket的转发，然后介绍如何搭建一个分布式系统。 1、项目说明 一般项目中web.
IM 即时通讯实战：环信Web IM极速集成
huan132456765的博客
02-20 1077
利用环信 IM Web 端 SDK 快速实现在 Vue.js 中发送出一条 Hello World!
IM即时聊天项目
潆勖的博客
09-02 401
IM即时聊天实战，基于 WebSocket + MongoDB + MySQL + Redis
收藏-即时通讯(IM)开源项目OpenIM-功能手册
OpenIM的博客
08-03 4280
收藏-即时通讯(IM)开源项目OpenIM-功能手册
百万级并发IM即时消息系统（1）前期准备
m0_50973548的博客
08-31 320
Gin是目前golang使用最广泛的Web架构之一。web开发框架，通合api接口、微服务开发，相较于其他框架(iris、 beego)更轻量级和更好的性能。其路由功能很强大提供分组功能，非常适合做api开发。
62-Java并发编程实战
10-10
62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java...
Python网络爬虫项目开发实战_并发下载_编程案例解析实例详解课程教程.pdf
05-03
在之前，我们的爬虫都是串行下载网页的，只有前一次下载完成之后才会启动新下载。在爬取规模较小的示例网站时，串行下载尚可应对，一但面对大型网站时就会显得捉襟见肘了。 在爬取拥有100万网页的大型网站时，假设...
WebServer-master 牛客C++实战项目 高并发服务器（源码+注释）
11-12
牛客C++实战项目 高并发服务器（源码+注释） WebServer-master
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码）
02-24
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码） 技术框架： 1. 线程池 + 非阻塞 socket + epoll + 事件处理的并发模型 2. 状态机解析HTTP请求 3. 心跳机制 4. 简易日志系统 主要内容： 1. ...
IM通讯系统分析与实战
外星喵的博客
04-21 3270
### 什么是IM(即时通讯)? 即时通信(instant message，IM)是指能够即时发送和接收互联网消息等的业务，通常集成了电子邮件、博客、音乐、电视、游戏和搜索等多种功能。 即时通信已经发展成集交流、资讯、娱乐、搜索、电子商务、办公协作和企业客户服务等为一体的综合化信息平台。微软、腾讯、AOL、Yahoo等重要即时通信提供商都提供通过手机接入互联网即时通信的业务，国内最常用的即时通讯软件如QQ、微信、百度hi、网易泡泡、淘宝旺旺等等。用户可以通过手机与其他已经安装了相应客户端软件的手机或电脑收
【IM】即时消息技术剖析与实战
michaelwoshi的博客
05-05 1957
即时消息技术剖析与实战：10周精通IM后端架构技术点 https://time.geekbang.org/column/intro/225 目前有没有什么不错的开源IM项目可以学习和研究？ 可以看看mqtt的github项目，另外国内应该蘑菇街开源了一款叫teamtalk的im软件，也可以看看。 有用到哪些技术以及编程语言可以先说明下？ 即时消息技术实际上是众多前后端技术的组合，包括但不限于：网络，分布式应用，DB，缓存，安全，服务高可用等等，专栏会用java完成一个简单im系统的..
IM实战：Android接入环信 IM SDK
huan132456765的博客
03-21 1869
为开发者提供基于移动互联网的即时通讯能力，如单聊、群聊、发语音、发图片、发位置等，让开发者摆脱繁重的移动IM通讯底层开发，24小时即可让App拥有内置IM能力。相信以各位小伙伴的能力接着的优化完全不是问题，当然也说不定有些奇葩问题搞不定，建议可以去环信官网联系官方技术支持，快速帮你解决遇到的问题～～实现了个人与个人，群组，聊天室发消息，发语音，发图片，发位置等功能，提供了一套供开发者拿来即用的EaseIMKit的ui库；chatType——聊天类型，整型，分别为单聊（1）、群聊（2）和聊天室（3）；
IM开源项目OpenIM部署文档-从准备工作到nginx配置
OpenIM的博客
11-15 5078
openim
Spring Boot接口实现百万并发
热门推荐
果酱 の 博客
06-26 1万+
随着互联网的发展，越来越多的应用需要支持高并发。在这种情况下，如何实现高并发成为了一个重要的问题。Spring Boot是一个非常流行的Java框架，它提供了很多方便的功能来支持高并发。本文将介绍如何使用Spring Boot来实现百万并发。Spring Boot是一个基于Spring框架的快速开发框架，它可以帮助开发人员快速构建Spring应用程序。Spring Boot提供了很多默认的配置，可以减少开发人员的工作量。同时，Spring Boot也提供了很多扩展功能，可以帮助开发人员更好地处理业务逻辑。
netty承受百万级并发
最新发布
11-25
Netty是一个高性能、异步事件驱动的网络应用程序框架，它可以轻松地承受百万级并发。它的高性能主要得益于以下几个方面： 1. 异步非阻塞IO模型：Netty使用了异步非阻塞IO模型，这意味着它可以在单线程上处理大量的并发连接，而不会因为阻塞而导致线程挂起。 2. 零拷贝技术：Netty使用了零拷贝技术，这意味着它可以在数据传输时避免将数据从内核空间复制到用户空间，从而提高了数据传输的效率。 3. 内存池技术：Netty使用了内存池技术，这意味着它可以重复利用已经分配的内存，从而减少了内存分配和回收的开销。 4. 多Reactor线程模型：Netty使用了多Reactor线程模型，这意味着它可以将连接的建立和数据的读写分别交给不同的线程处理，从而提高了并发处理能力。 因此，Netty可以轻松地承受百万级并发。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值