bl/common/socket/handler/SocketHandler_Tomee.go

package handler

import (
	"blazing/common/utils/bytearray"

	"bytes"
	"fmt"
	"reflect"

	"github.com/lunixbochs/struc"
	"github.com/panjf2000/gnet/v2"
)

// TomeeHeader 结构体字段定义
type TomeeHeader struct {
	Len     uint32 `json:"len"`
	Version string `json:"version" struc:"[1]byte"`
	CMD     uint32 `json:"cmdId" struc:"uint32"`
	UserID  uint32 `json:"userId"`
	//Error   uint32 `json:"error" struc:"[0]pad"`

	Result uint32 `json:"result"`
	Data   []byte `json:"data" struc:"skip"` //组包忽略此字段// struc:"[0]pad"
	Return []byte `struc:"[0]pad"`           //返回记录
}

func NewTomeeHeader() *TomeeHeader {

	return &TomeeHeader{
		//	Len:     0,
		Version: "7",
	}

}

type TomeeHandler struct {
	Callback func(conn gnet.Conn, data TomeeHeader)
}

func NewTomeeHandler() *TomeeHandler {
	return &TomeeHandler{}
}

// Handle entry receiver
func (h *TomeeHandler) Handle(c gnet.Conn, data []byte) { //处理接收到的数据 ,
	//fmt.Println("接收数据", data)

	header := TomeeHeader{}

	tempdata := bytearray.CreateByteArray(data)
	header.Len, _ = tempdata.ReadUInt32()
	header.Version, _ = tempdata.ReadString(1)
	header.CMD, _ = tempdata.ReadUInt32()
	//header.CMD = cmd.EnumCommandID(_CMD)
	header.UserID, _ = tempdata.ReadUInt32()

	header.Result, _ = tempdata.ReadUInt32()
	header.Data = tempdata.BytesAvailable()
	//fmt.Println("接收封包", header)
	h.Callback(c, header)
	//return header
}

// Pack 将给定的数据打包成一个字节切片。
// 该方法处理的数据类型包括指针、切片和结构体。
// 对于指针类型，会解引用以获取实际值。
// 切片类型直接转换为字节切片。
// 结构体类型使用struc库进行序列化。
// 最后，将数据长度、版本号、命令码、用户ID和结果代码一并打包进返回的字节切片中。
func (h *TomeeHeader) Pack(data any) []byte { //组包

	//t := reflect.TypeOf(data)
	tv := reflect.ValueOf(data)
	var datar []byte

	// 处理指针类型
	if tv.Kind() == reflect.Ptr {
		//tv = t.Elem()   // 获取指针指向的类型
		tv = tv.Elem() // 获取指针指向的值
	}
	//.Println(t.Kind())
	//t1 := tv.Interface()
	//fmt.Println(t1)
	switch tv.Kind() {

	case reflect.Slice:
		datar = data.([]byte)
		//p.Conn.Write(p.pack(cmd, data.([]byte))) //写入数据

	case reflect.Struct:
		var data1 bytes.Buffer
		err := struc.Pack(&data1, data)
		if err != nil {
			fmt.Println(err)
		}

		datar = data1.Bytes()

	default:
		datar = []byte{}
		//	fmt.Println(err, datar)
		//	p.Conn.Write(p.pack(cmd, data))

	}
	h.Len = uint32(len(datar) + 17)

	by := bytearray.CreateByteArray()
	by.WriteUInt32(h.Len)
	by.WriteString(h.Version)
	by.WriteUInt32(uint32(h.CMD))
	by.WriteUInt32(h.UserID)
	by.WriteUInt32(h.Result)
	by.Write(datar)

	return by.Bytes()

}
func (h *TomeeHeader) Ret() []byte { //默认返回方法

	return h.Return

}
func (h *TomeeHeader) Set(T any) []byte { //默认返回方法
	h.Return = h.Pack(T) //这里保存一下，用来给调用
	return h.Return

}

// var _ Blazingservice = (*TomeeHeader)(nil)

// type Blazingservice interface {
// 	Ret() []byte
// }

// MergeBytes 将多个字节数组合并为一个
func MergeBytes(arrays ...[]byte) []byte {
	// 计算所有数组的总长度
	totalLen := 0
	for _, arr := range arrays {
		totalLen += len(arr)
	}

	// 创建结果切片
	result := make([]byte, totalLen)

	// 逐个复制数组内容
	currentIndex := 0
	for _, arr := range arrays {
		copy(result[currentIndex:], arr)
		currentIndex += len(arr)
	}

	return result
}