Zinx-Golang轻量级TCP服务器框架（1）

已于 2023-12-23 13:32:16 修改
阅读量512 收藏 7
点赞数 10
分类专栏： Zinx框架 文章标签： golang tcp/ip 服务器
于 2023-12-22 17:16:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TTT_ZY/article/details/135151139
版权

在这里插入图片描述

Server

抽象层

// 定义一个服务器接口
type IServer interface {
	//启动服务器
	Start()
	//停止服务器
	Stop()
	//运行服务器
	Server()
	//路由功能：给当前服务注册一个路由方法，供客户端的连接处理使用
	AddRouter(msgID uint32, router IRouter)
	//获取当前server的连接管理器
	GetConnMgr() IConnManager
	//注册OnConnStart 钩子函数的方法
	SetOnConnStart(func(connection IConnection))
	//注册OnConnStop 钩子函数的方法
	SetOnConnStop(func(connection IConnection))
	//调用OnConnStart 钩子函数的方法
	CallOnConnStart(connection IConnection)
	//调用OnConnStop 钩子函数的方法
	CallOnConnStop(connection IConnection)
}

实现层

// IServer的接口实现，定义一个Server的服务器模块
type Server struct {
	//服务器的名称
	Name string
	//服务器绑定的ip版本
	IPVersion string
	//服务器监听的IP
	IP string
	//服务器监听的接口
	Port int
	//当前server的消息管理模块，用来绑定MsgID和对应的处理业务API关系
	MsgHandler ziface.IMsgHandle
	//该server的连接管理器
	ConnMgr ziface.IConnManager
	//该Server创建链接后自动调用Hook函数--OnConnStart
	OnConnStart func(conn ziface.IConnection)
	//该Server销毁链接前自动调用Hook函数--OnConnStop
	OnConnStop func(conn ziface.IConnection)
}

//func CallBackToClient(conn *net.TCPConn, data []byte, cnt int) error {
//	//回显业务
//	fmt.Println("[Conn Handle] CallBackToClient...")
//	if _, err := conn.Write(data[:cnt]); err != nil {
//		fmt.Println("write back buf err", err)
//		return errors.New("CallBackToClient error")
//	}
//	return nil
//}

func (s *Server) Start() {
	fmt.Printf("[Zinx] Server Name : %s, listenner at IP : %s, Port:%d is starting\n",
		utils.GlobalObject.Name, utils.GlobalObject.Host, utils.GlobalObject.TcpPort)
	fmt.Printf("[Zinx] Version %s, MaxConn %d, MaxPackageSize %d\n",
		utils.GlobalObject.Version, utils.GlobalObject.MaxConn, utils.GlobalObject.MaxPackageSize)
	//1 获取一个TCP的Addr
	go func() {
		//开启工作池
		s.MsgHandler.StartWorkerPool()

		addr, err := net.ResolveTCPAddr(s.IPVersion, fmt.Sprintf("%s:%d", s.IP, s.Port))
		if err != nil {
			fmt.Println("resolve tcp addr error : ", err)
			return
		}
		//2 监听服务器的地址
		listenner, err := net.ListenTCP(s.IPVersion, addr)
		if err != nil {
			fmt.Println("listen : ", s.IPVersion, "err : ", err)
			return
		}
		fmt.Println("start Zinx server success,", s.Name, " Listenning")

		var cid uint32
		cid = 0
		//3 阻塞的等待客户端连接，处理客户端连接业务
		for {
			//如果有客户端链接过来，阻塞会返回
			conn, err := listenner.AcceptTCP()
			if err != nil {
				fmt.Println("Accept err : ", err)
				continue
			}
			//判断最大连接个数
			if s.ConnMgr.Len() >= utils.GlobalObject.MaxConn {
				//TODO 给客户端响应一个超出最大连接的错误包
				fmt.Println("Too Many Conn = ", utils.GlobalObject.MaxConn)
				conn.Close()
				continue
			}
			//conn和业务方法绑定
			dealConn := NewConnection(s, conn, cid, s.MsgHandler)
			cid++

			//启动当前链接业务处理
			go dealConn.Start()
		}
	}()
}

func (s *Server) Stop() {
	//TODO 将一些服务器的资源、状态或者一些已经开辟的连接信息 停止或者回收
	fmt.Println("[STOP] Zinx server name ", s.Name)
	s.ConnMgr.ClearConn()
}

func (s *Server) Server() {
	//启动server服务功能
	s.Start()

	//TODO 做一些启动服务器之后的额外业务

	//阻塞状态
	select {}
}

func (s *Server) AddRouter(msgID uint32, router ziface.IRouter) {
	s.MsgHandler.AddRouter(msgID, router)
	fmt.Println("add router success")
}

func (s *Server) GetConnMgr() ziface.IConnManager {
	return s.ConnMgr
}

// 初始化Server模块的方法
func NewServer(name string) ziface.IServer {
	s := &Server{
		Name:       utils.GlobalObject.Name,
		IPVersion:  "tcp4",
		IP:         utils.GlobalObject.Host,
		Port:       utils.GlobalObject.TcpPort,
		MsgHandler: NewMsgHandle(),
		ConnMgr:    NewConnManager(),
	}
	return s
}

// 注册OnConnStart 钩子函数的方法
func (s *Server) SetOnConnStart(hookFunc func(connection ziface.IConnection)) {
	s.OnConnStart = hookFunc
}

// 注册OnConnStop 钩子函数的方法
func (s *Server) SetOnConnStop(hookFunc func(connection ziface.IConnection)) {
	s.OnConnStop = hookFunc
}

// 调用OnConnStart 钩子函数的方法
func (s *Server) CallOnConnStart(conn ziface.IConnection) {
	if s.OnConnStart != nil {
		fmt.Println("----> Call OnConnStart()...")
		s.OnConnStart(conn)
	}
}

// 调用OnConnStop 钩子函数的方法
func (s *Server) CallOnConnStop(conn ziface.IConnection) {
	if s.OnConnStop != nil {
		fmt.Println("----> Call OnConnStop()...")
		s.OnConnStop(conn)
	}
}
  • Start()：开启一个阻塞的go程负责绑定、监听、端口，同时开启工作池，当服务器监听到一个新的connection，则会判断是否超过最大连接，将conn与业务方法绑定，再开启一个go程处理业务，这样充分的利用了go程的高并发性。
  • Server()：由于start是异步方法，因此server中需要阻塞。在这之间也可以做扩展工作。

Connection

抽象层

// 定义链接的抽象层
type IConnection interface {
	//启动链接 让当前链接准备开始工作
	Start()
	//停止链接 结束当前链接的工作
	Stop()
	//获取当前链接的绑定socket conn
	GetTCPConnection() *net.TCPConn
	//获取当前连接模块的链接ID
	GetConnID() uint32
	//获取远程客户端的TCP状态 IP port
	RemoteAddr() net.Addr
	//发送数据，将数据发送给远程的客户端
	SendMsg(msgId uint32, data []byte) error
	//设置链接属性
	SetProperty(key string, value interface{})
	//获取链接属性
	GetProperty(key string) (interface{}, error)
	//移除链接属性
	RemoveProperty(key string)
}

// 定义一个处理链接业务的方法
type HandleFunc func(*net.TCPConn, []byte, int) error

实现层

type Connection struct {
	//当前Conn属于哪个Server
	TcpServer ziface.IServer
	//当前链接的socket TCP套接字
	Conn *net.TCPConn
	//链接的ID
	ConnID uint32
	//当前的链接状态
	isClosed bool
	//当前的链接所绑定的处理业务方法API
	handleAPI ziface.HandleFunc
	//告知当前链接已经退出 的channel
	ExitChan chan bool
	//无缓冲管道，用于读、写goroutine之间消息通信
	msgChan chan []byte
	//当前server的消息管理模块，用来绑定MsgID和对应的处理业务API关系
	MsgHandler ziface.IMsgHandle
	//链接属性集合
	property map[string]interface{}
	//保护链接属性的锁
	propertyLock sync.RWMutex
}

// 初始化链接模块的方法
func NewConnection(server ziface.IServer, conn *net.TCPConn, connID uint32, MsgHandler ziface.IMsgHandle) *Connection {
	c := &Connection{
		TcpServer: server,
		Conn:      conn,
		ConnID:    connID,
		isClosed:  false,
		//handleAPI: callback_api,
		MsgHandler: MsgHandler,
		ExitChan:   make(chan bool, 1),
		msgChan:    make(chan []byte),
		property:   make(map[string]interface{}),
	}

	c.TcpServer.GetConnMgr().Add(c)

	return c
}

// 链接的读业务方法
func (c *Connection) StartReader() {
	fmt.Println("[Reader Goroutine is running...]")
	defer fmt.Println("connID = ", c.ConnID, "Reader is exit,remote addr is ", c.RemoteAddr().String())
	defer c.Stop()

	for {
		//buf := make([]byte, utils.GlobalObject.MaxPackageSize)
		//_, err := c.Conn.Read(buf)
		//if err != nil {
		//	fmt.Println("recv buf err,", err)
		//	continue
		//}
		//创建一个拆包对象
		dp := NewDataPack()
		//读取客户端的Msg Head 二进制流 8个字节
		headData := make([]byte, dp.GetHeadLen())
		if _, err := io.ReadFull(c.GetTCPConnection(), headData); err != nil {
			fmt.Println("read msg head error,", err)
			break
		}
		//拆包，得到msgID、msgDatalen放在msg消息中
		msg, err := dp.Unpack(headData)
		if err != nil {
			fmt.Println("unpack error", err)
			break
		}
		//根据dataLen 读取data
		var data []byte
		if msg.GetMsgLen() > 0 {
			data = make([]byte, msg.GetMsgLen())
			if _, err := io.ReadFull(c.GetTCPConnection(), data); err != nil {
				fmt.Println("read msg body error,", err)
				break
			}
		}
		msg.SetMsg(data)
		//得到当前conn数据的Request请求数据
		req := Request{
			conn: c,
			msg:  msg,
		}

		if utils.GlobalObject.WorkerPoolSize > 0 {
			c.MsgHandler.SendMsgToTaskQueue(&req)
		} else {
			go c.MsgHandler.DoMsgHandler(&req)
		}

	}
}

// 写消息goroutine，专门发消息给客户端模块
func (c *Connection) StartWriter() {
	fmt.Println("[Writer Goroutine is running...]")
	defer fmt.Println(c.RemoteAddr().String(), "[conn writer exit]")

	for {
		select {
		case data := <-c.msgChan:
			//写数据给客户端
			if _, err := c.Conn.Write(data); err != nil {
				fmt.Println("send data error , ", err)
				return
			}
		case <-c.ExitChan:
			//代表Reader已经退出，此时Writer也要退出
			return
		}
	}
}

// 启动链接 让当前链接准备开始工作
func (c *Connection) Start() {
	fmt.Println("Conn Start... ConID = ", c.ConnID)

	//启动从当前链接的读数据的业务
	go c.StartReader()
	//启动当前写业务
	go c.StartWriter()
	//按照开发者传递进来的 创建链接之后需要调用的处理业务，执行对应的Hook函数
	c.TcpServer.CallOnConnStart(c)
}

// 停止链接 结束当前链接的工作
func (c *Connection) Stop() {
	fmt.Println("Conn Stop... ConID = ", c.ConnID)

	if c.isClosed == true {
		return
	}
	c.isClosed = true

	//调用开发者注册的销毁链接之前需要执行的业务Hook函数
	c.TcpServer.CallOnConnStop(c)

	c.Conn.Close()

	c.ExitChan <- true

	c.TcpServer.GetConnMgr().Remove(c)

	close(c.ExitChan)
	close(c.msgChan)

}

// 获取当前链接的绑定socket conn
func (c *Connection) GetTCPConnection() *net.TCPConn {
	return c.Conn
}

// 获取当前连接模块的链接ID
func (c *Connection) GetConnID() uint32 {
	return c.ConnID
}

// 获取远程客户端的TCP状态 IP port
func (c *Connection) RemoteAddr() net.Addr {
	return c.Conn.RemoteAddr()
}

// 发送数据，将数据发送给远程的客户端
func (c *Connection) SendMsg(msgId uint32, data []byte) error {
	if c.isClosed == true {
		return errors.New("conn closed when send msg")
	}

	dp := NewDataPack()
	binaryMsg, err := dp.Pack(NewMsgPackage(msgId, data))
	if err != nil {
		fmt.Println("pack error msg id = ", msgId)
		return errors.New("pack error msg")
	}

	//将消息发送给管道
	c.msgChan <- binaryMsg

	return nil
}

// 设置链接属性
func (c *Connection) SetProperty(key string, value interface{}) {
	c.propertyLock.Lock()
	defer c.propertyLock.Unlock()

	c.property[key] = value
}

// 获取链接属性
func (c *Connection) GetProperty(key string) (interface{}, error) {
	c.propertyLock.RLock()
	defer c.propertyLock.RUnlock()

	if value, ok := c.property[key]; ok {
		return value, nil
	}
	return nil, errors.New("no property found")

}

// 移除链接属性
func (c *Connection) RemoveProperty(key string) {
	c.propertyLock.Lock()
	defer c.propertyLock.Unlock()

	delete(c.property, key)
}
  • 当启动Start()时，异步开启俩个go程，一个读，一个写。
  • 读go程，首先将数据进行制定格式拆包，对数据进行request封装，然后用绑定的业务函数处理。
  • 写go程，专门发消息给客户端模块。

Router

抽象层

type IRequest interface {
	GetConnection() IConnection

	GetData() []byte

	GetMsgId() uint32
}

type IRouter interface {
	PreHandle(request IRequest)

	Handle(rqeuest IRequest)

	PostHandle(request IRequest)
}

实现层

type Request struct {
	conn ziface.IConnection

	msg ziface.IMessage
}

func (r *Request) GetConnection() ziface.IConnection {
	return r.conn
}

func (r *Request) GetData() []byte {
	return r.msg.GetMsg()
}

func (r *Request) GetMsgId() uint32 {
	return r.msg.GetMsgId()
}


type BaseRouter struct {
}

// 这里之所以BaseRouter方法都为空
// 是因为有的Router不希望有PreHandle、PostHandle这俩个业务
// 所以Router全部继承BaseRouter的好处就是，不需要实现PreHandle，PostHandle
func (br *BaseRouter) PreHandle(request ziface.IRequest) {

}

func (br *BaseRouter) Handle(request ziface.IRequest) {

}

func (br *BaseRouter) PostHandle(request ziface.IRequest) {

}
  • 定义一个抽象接口IRouter，实现一个BaseRouter实现接口中的所有方法但方法中没有实际业务，随后用户可以自定义Router继承这个BaseRouter，基于基类，用户想实现哪个方法就实现哪个方法。
  • 现在一个Server只能绑定一个Router,后续可以给个哈希表存储多个Router。

内容来自 @刘丹冰Aceld
项目 Zinx

TTT_ZY
关注
  • 10
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
zinx：基于Golang轻量级TCP并发服务器框架
02-04
Zinx是一个基于Golang的轻量级并发服务器框架 说明：现有的zinx已经在很多企业进行开发使用，具体的使用领域包括：串行模块的消息中转，长链接游戏服务器，Web框架中的消息处理插件等。zinx的定位是代码简洁，让更多...
zinx —— golang —— MMO游戏服务器开发对应客户端
06-01
Zinx是一个用Golang编写的轻量级网络框架，特别适合用于MMO（大型多人在线）游戏服务器的开发。Golang以其并发性能强、内存管理高效、语法简洁等特性，成为了游戏服务器开发领域的新宠。本文将深入探讨Zinx框架如何...
7-zinx基于Golang-读写分离模型
qq23001186的博客
05-27 424
目录前言一、实现思路二、项目结构三、源码修改zinx/znet/connection.go四、完整源码 前言 之前connection使用StartReader对客户端的数据 接下来我们就要对Zinx做⼀个⼩⼩的改变，就是与客户端进修数据交互的Gouroutine由⼀个变成两个，⼀个专⻔负责从客户端读取数据，⼀个专⻔负责向客户端写数据。这么设计有什么好处，当然是⽬的就是⾼内聚，模块的功能单⼀ Server依然是处理客户端的响应，主要关键的⼏个⽅法是Listen、Accept等。当建⽴与客户端的套接字后，那
Golang | Zinx学习笔记（一）
qq_40318498的博客
10-30 386
本文是go zinx的学习笔记
2024年最新Golang 框架介绍_golang框架(1)，腾讯T2手把手教你
2401_84920056的博客
05-11 863
它具有快速、高效和易用的特点，是构建高性能 RESTful API 的理想选择。Echo 是一个高性能的、极简的 Web 框架，它专注于提供快速的路由和中间件。Echo 的设计目标是简洁、易用和高效，它在性能方面表现出色，并且具有与标准库兼容的 API 接口。如果你注重性能和简洁的设计，并且在路由和中间件方面有更高的要求，Echo 是一个不错的选择。如果你需要一个全功能的框架，并且关注开发效率和可维护性，Beego 是一个不错的选择。如果你需要一个快速、高性能和易于使用的框架，Gin 是一个不错的选择。
Zinx-Golang轻量级TCP服务器框架（2）
TTT_ZY的博客
12-23 422
Zinx框架（2）
【zinx】Golang轻量级TCP服务器框架（八）—— 创建消息队列、工作池、限定Gourtine数量
一年之内毫无半点成绩，想起来做人真是没趣。
10-01 509
Golang轻量级TCP服务器框架（六）—— 创建消息队列、工作池、限定Gourtine数量1.目的2.思路3. 原作者视频地址：zinx-Golang轻量级TCP服务器框架 本人为自学整理的文档，梳理思考开发框架的基本思路，方法，以及视频中不理解的地方。 若想学习，强烈建议直接观看原作视频即可。 可在下方留言交流。 1.目的 这个东西是什么？ 客户端与server链接时候，客户端发送过来消息： 原来：①StartReader()解析消息+go 消息处理 ----> ②StartWriter()
1-zinx基于Golang-基础的server实现
qq23001186的博客
05-25 358
目录前言一、Zinx架构简介二、基础server实现思路 前言 转载作者的预雀地址：https://www.yuque.com/aceld Zinx的Github —— Git: https://github.com/aceld/zinx 码云(Gitee) —— Git: https://gitee.com/Aceld/zinx 文章主要针对Zinx框架学习的总结 一、Zinx架构简介 为什么要做Zinx：引用作者原话“我们为什么要做Zinx，Golang目前在服务器的应用框架很多，但是应用在
Golang学习笔记：Zinx框架搭建轻量级TCP服务器01
qq_43561934的博客
05-11 1170
Goland学习笔记 原作者视频地址：https://www.bilibili.com/video/BV1wE411d7th?p=1 本人为自学整理的个人理解文档
Zinx 是一个基于Golang的轻量级并发服务器框架
04-25
**Zinx：基于Golang的轻量级并发服务器框架** Zinx是一个专为Go语言设计的轻量级并发服务器框架，旨在提供高效、简洁的网络服务开发能力。它充分利用了Go语言的并发特性，如goroutines和channels，使得开发者能够...
Go-Go语言的TCP网络通信框架
08-14
Go语言的TCP网络通信框架
Go-Tao一个用golang编写的异步TCP框架
08-13
Tao一个用golang编写的异步TCP框架
Go-tcpserver-一个Go库用于快速构建Tcp服务器
08-13
tcp_server - 一个Go库用于快速构建Tcp服务器
在Go中构建并发TCP服务器
01-03
开发一个并发TCP服务器，该服务器仅使用大约65行GO代码生成随机数。 TCP和UDP服务器随处可见，通过TCP/IP网络为网络客户端提供服务。在本文中，我将在GO编程语言，返回随机数。对于来自TCP客户端的每个传入连接，TCP服务器将启动一个新的goroutine来处理该请求。 你可以找到这个项目，concTCP.go，在GitHub上。 处理TCP连接 程序的逻辑可以在handleConnection()职能，其实现方式如下： func handleConnection(c net.Conn) { fmt.Printf(Serving %s\n, c.RemoteAddr(
xtcp：自研轻量级tcp框架，一系列消息事件
02-22
xtcp介绍 xtcp是一种Golang轻量级TCP框架，以某种事件形式处理消息。作为初学者，您可以查看原始码，源码内含大量中文注释。 使用方式说明： 服务端 package main import ( "fmt" "github.com/xhyonline/xtcp" "time" ) func main () { // 建立连接 server , err := xtcp . NewServer (xtcp. Config { Host : "127.0.0.1" , Port : "8888" , }) if err != nil { panic ( err ) } // 当客户端连接时 server . OnConnect ( func ( ctx xtcp. Context ) { fmt . Printf ( "有一个客户端连接进来了,他的 I
基于 go 的轻量级并发TCP服务器框架设计与实现
最新发布
06-12
我们为什么要做Zinx，Golang目前在服务器的应用框架很多，但是应用在游戏领域或者其他长链接的领域的轻量级企业框架甚少。 设计Zinx的目的是我们可以通过Zinx框架来了解基于Golang编写一个TCP服务器的整体轮廓，让...
5-zinx基于Golang-消息封装
qq23001186的博客
05-27 499
目录前言一、创建消息类型二、消息的粘包三、封包拆包的实现1 - 接口：ziface/idatapack.go2 - 实现：znet/datapack.go3 - 单元测试：znet/datapack_test.go四、消息封装集成到Zinx框架 前言 之前我们使用Request来保存服务器的数据，很显然使用[]byte来接收数据，没有长度也没有消息类型，接下来就要针对这个消息进行封装 一、创建消息类型 消息思路：一个基本的message包，会包含消息ID、数据、数据长度三个成员，并提供基本的sette
3-zinx基于Golang-请求与路由模块实现
qq23001186的博客
05-26 420
目录前言一、IRequest消息请求抽象类1 - IRequest需求分析2 - irequest.go3 - request.go二、router路由模块1 - router模块分析2 - irouter.go3 - router.go三、源码修改四、Router模块总结1 - 总结xmind2 - 项目结构六、完整源码1 - ziface接口2 - znet实现3 - 测试类 前言 在zinxV0.2中conn链接的业务处理HandleFunc是固定写死的，接下来我们需要自定义一个conn处理业务的接
Zinx: Golang轻量级企业服务器框架教程
Zinx是一个由Golang编写的轻量级并发服务器框架，特别针对游戏服务器和其他需要长链接的企业应用设计。它的目标是通过逐步的教学过程帮助Golang开发者理解和构建TCP服务器，使初学者能够轻松上手并逐渐掌握这一领域...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值