tcp

README

TCP

基于底层的 tcp 封装，有 客户端和服务端，本工具的服务端和客户端封装了通用的操作，均可单独在用于各个项目。

只简化了常用的 tcp 操作

配置

实例化 tcp 的服务端和客户端的时候要传入配置，服务端和客户端配置共用同个结构体 *tcp.Config ，说明如下

// Config 配置项
type Config struct {
  Addr    string                                // tcp 地址，在客户端使用为需要连接的地址，在服务端使用为监听的地址
  Network string                                // tcp 的网络类型，可选值为 "tcp", "tcp4", "tcp6", "unix" or "unixpacket"
  Packer  func([]byte) ([]byte, error)          // tcp 数据包的封装函数，传入的数据是需要发送的业务数据，返回发送给 tcp 的数据
  Parser  func(*Conn, []byte) ([][]byte, error) // 将收到的数据包，根据私有协议转换成业务数据，在这里处理粘包,半包等数据包问题，返回处理好的数据包
  Logger  LoggerI // 打日志的实例
}

Packer 和 Parser 是 tcp 数据包的处理，是同时对等出现的。用于实现 tcp 的私有协议。

如果 Packer 和 Parser 两个都不传，会使用默认的私有协议实现，默认私有协议的数据包组成是

header[4字节标识body字节长度] + body[任意长度]

客户端 Client

tcp 的客户端封装，带有自动重连，简易的 api 封装，只关注收发数据即可

package main

import (
    "fmt"
	"github.com/go-eyas/toolkit/tcp"
)

func main() {
  client, err := tcp.NewClient(&tcp.Config{
    Network: "tcp", // 网络类型，不填默认 tcp
    // tcp 服务端地址
  	Addr:    "127.0.0.1:6600",
  
    // 私有协议实现，不传将使用默认的私有协议实现
  	// Parser: func([]byte) ([]byte, error) {},
  	// Packer: func(*Conn, []byte) ([][]byte, error){},
  })
  if err != nil {
  	panic(err)
  }
  
  // 接收数据
  ch := client.Receive()
  go func() {
    for msg := range ch {
      // msg.Data 经过 Parser 处理过的数据
      // msg.Conn tcp 连接实例 
      fmt.Println("client receive:", string(msg.Data))
    }
  }()
  
  // 发送数据，send 后将立马把数据传给 Packer 处理后，在发送到 tcp 连接
  err = client.Send([]byte("hello world1"))
}

服务端 Server

package main

import (
    "fmt"
	"github.com/go-eyas/toolkit/tcp"
)

func main() {
  server, err := tcp.NewServer(&tcp.Config{
  	Network: "tcp", // 网络类型，不填默认 tcp
    // tcp 监听地址
    Addr:    "127.0.0.1:6600",
    
    // 私有协议实现，不传将使用默认的私有协议实现
    // Parser: func([]byte) ([]byte, error) {},
    // Packer: func(*Conn, []byte) ([][]byte, error){},
  })
  
  if err != nil {
  	panic(err)
  }
  
  // 接收数据
  ch := server.Receive()
  for data := range ch {
  	fmt.Printf("server receive: %v", data.Data)
    
    // 服务器收到数据后，响应发送一条数据到客户端 
  	err := data.Response([]byte("server receive your message"))
  	if err != nil {
  		panic(err)
  	}
  }

  // 给所有连接都发送消息
  for connID, conn := range server.Sockets {
    fmt.Println("connID: ", connID)
    server.Send(conn, []byte("broadcast some message"))
    // or
    // server.SendConnID(connID, []byte("broadcast some message"))
  }
}

API

API 文档

Documentation

Index

• Variables
• func Packer(data []byte) ([]byte, error)
• func Parser() (map[uint64][]byte, func(conn *Conn, bt []byte) ([][]byte, error))
• type Client
  • func NewClient(conf *Config) (*Client, error)
  • func (c *Client) Destroy() error
  • func (c *Client) HandleClose(h connHandler)
  • func (c *Client) HandleCreate(h connHandler)
  • func (c *Client) Receive() <-chan *Message
  • func (c *Client) Send(msg []byte) error
• type Config
• type Conn
  • func (conn *Conn) Destroy() error
  • func (conn *Conn) IsClient() bool
  • func (conn *Conn) IsServer() bool
  • func (conn *Conn) Send(msg []byte) error
• type LoggerI
• type Message
  • func (m *Message) Response(data []byte) error
• type Server
  • func NewServer(conf *Config) (*Server, error)
  • func (sv *Server) HandleClose(h connHandler)
  • func (sv *Server) HandleCreate(h connHandler)
  • func (sv *Server) Receive() <-chan *Message
  • func (sv *Server) Send(conn *Conn, data []byte) error
  • func (sv *Server) SendConnID(id uint64, data []byte) error

Variables

var EmptyLogger = &l{}

Functions

func Packer

func Packer(data []byte) ([]byte, error)

打包

func Parser

func Parser() (map[uint64][]byte, func(conn *Conn, bt []byte) ([][]byte, error))

Types

type Client

type Client struct {
	Conn   *Conn
	Config *Config
	// contains filtered or unexported fields
}

Client tcp 客户端

func NewClient

func NewClient(conf *Config) (*Client, error)

实例化 tcp 客户端连接，与服务器建立 TCP 连接

func (*Client) Destroy

func (c *Client) Destroy() error

Destroy 关闭并销毁连接

func (*Client) HandleClose

func (c *Client) HandleClose(h connHandler)

HandleClose 每当连接断开后，触发函数

func (*Client) HandleCreate

func (c *Client) HandleCreate(h connHandler)

HandleCreate 每当连接建立成功后时，触发函数

func (*Client) Receive

func (c *Client) Receive() <-chan *Message

Receive 接收数据

func (*Client) Send

func (c *Client) Send(msg []byte) error

Send 往连接发送数据

type Config

type Config struct {
	Addr    string                                // tcp 地址，在客户端使用为需要连接的地址，在服务端使用为监听的地址
	Network string                                // tcp 的网络类型，可选值为 "tcp", "tcp4", "tcp6", "unix" or "unixpacket"
	Packer  func([]byte) ([]byte, error)          // tcp 数据包的封装函数，传入的数据是需要发送的业务数据，返回发送给 tcp 的数据
	Parser  func(*Conn, []byte) ([][]byte, error) // 将收到的数据包，根据私有协议转换成业务数据，在这里处理粘包,半包等数据包问题，返回处理好的数据包
	Logger  LoggerI
}

Config 配置项

type Conn

type Conn struct {
	ID   uint64
	Conn net.Conn
	// contains filtered or unexported fields
}

func (*Conn) Destroy

func (conn *Conn) Destroy() error

Destroy 关闭并销毁连接

func (*Conn) IsClient

func (conn *Conn) IsClient() bool

IsClient 当前连接是否为客户端实例

func (*Conn) IsServer

func (conn *Conn) IsServer() bool

IsServer 当前连接是否为服务器实例

func (*Conn) Send

func (conn *Conn) Send(msg []byte) error

Send 给当前连接发送数据

type LoggerI

type LoggerI interface {
	Info(...interface{})
	Infof(string, ...interface{})
	Error(...interface{})
	Errorf(string, ...interface{})
}

type Message

type Message struct {
	Data []byte
	Conn *Conn
}

func (*Message) Response

func (m *Message) Response(data []byte) error

type Server

type Server struct {
	Listener net.Listener     // 服务器监听实例
	Sockets  map[uint64]*Conn // 当前与客户端的连接实例
	Config   *Config          // 配置项
	// contains filtered or unexported fields
}

Server 服务器

func NewServer

func NewServer(conf *Config) (*Server, error)

NewServer 实例化服务器

func (*Server) HandleClose

func (sv *Server) HandleClose(h connHandler)

HandleClose 每当有连接关闭时，触发函数

func (*Server) HandleCreate

func (sv *Server) HandleCreate(h connHandler)

HandleCreate 每当有新连接建立时，触发函数

func (*Server) Receive

func (sv *Server) Receive() <-chan *Message

Receive 接收数据

func (*Server) Send

func (sv *Server) Send(conn *Conn, data []byte) error

Send 发送数据到指定连接实例

func (*Server) SendConnID

func (sv *Server) SendConnID(id uint64, data []byte) error

SendConnID 发送数据到指定连接实例ID