bash复制代码project.ext {
    aspectjVersion = '1.9.7'
}

buildscript {
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "gradle.plugin.de:AspectjGradlePlugin:0.0.6"
    }
}

apply plugin: "aspectj.AspectjGradlePlugin"
group 'top.ilovestudy.tools'
version 'unspecified'

dependencies {
    implementation "org.aspectj:aspectjrt:${aspectjVersion}"
    implementation "org.aspectj:aspectjweaver:${aspectjVersion}"
    implementation "org.aspectj:aspectjtools:${aspectjVersion}"
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
}
java {
    sourceCompatibility JavaVersion.VERSION_11
    targetCompatibility JavaVersion.VERSION_11
}
test {
    useJUnitPlatform()
}

less复制代码@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExecutionTime {
    ChronoUnit unit() default ChronoUnit.NANOS;
}

less复制代码@Aspect
public class ExecutionTimeAspect {

    @Pointcut("@annotation(executionTime)")
    public void callAt(ExecutionTime executionTime) {
    }


    @Around("callAt(executionTime)")
    public Object around(ProceedingJoinPoint pjp, ExecutionTime executionTime) throws Throwable {
        long start = System.nanoTime();
        Object proceed = pjp.proceed();
        long end = System.nanoTime();
        System.out.println(String.format("[%s] method [%s] execution time: %s %s",
                Thread.currentThread().getName(),
                pjp.getSignature().getName(),
                Duration.of(end - start, ChronoUnit.NANOS).get(executionTime.unit()),
                executionTime.unit().name()));
        return proceed;
    }

}

csharp复制代码    @ExecutionTime
    void add10K() {
        int idx = 0;
        while (idx++ < maxCountNum) {
            addOne();
        }
    }

less复制代码[calc7] method [add10K] execution time: 3841505 NANOS
[calc0] method [add10K] execution time: 48612486 NANOS
[calc1] method [add10K] execution time: 53342401 NANOS
[calc3] method [add10K] execution time: 55629095 NANOS
[calc5] method [add10K] execution time: 56005109 NANOS
[calc7] method [add10K] execution time: 56238950 NANOS

xml复制代码<mapper namespace="com.example.ssm.mapper.UserMapper">
    <select id="login1" resultType="integer">
        select count(*) from user where username = #{username} and password = #{password}
    </select>
    <select id="login2" resultType="integer">
        select count(*) from user where username = '${username}' and password = '${password}'
    </select>
</mapper>

bash复制代码jdbc:mysql://localhost:3306/ssm?characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false

java复制代码package org.apache.ibatis.executor.statement;
    public class RoutingStatementHandler implements StatementHandler

java复制代码package com.mysql.cj.jdbc;
       public class ConnectionImpl implements JdbcConnection, SessionEventListener, Serializable 
           public java.sql.PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException

scala复制代码package com.mysql.cj.jdbc
    public class ClientPreparedStatement extends com.mysql.cj.jdbc.StatementImpl implements JdbcPreparedStatement
        public ClientPreparedStatement(JdbcConnection conn, String sql, String db, ParseInfo cachedParseInfo) throws SQLException

arduino复制代码package com.mysql.cj
    public class ParseInfo
        public ParseInfo(String sql, Session session, String encoding, boolean buildRewriteInfo)

arduino复制代码this.staticSql = new byte[endpointList.size()][];

scala复制代码package com.mysql.cj;
    public abstract class AbstractPreparedQuery<T extends QueryBindings<?>> extends AbstractQuery implements PreparedQuery<T>
        public <M extends Message> M fillSendPacket(QueryBindings<?> bindings)

scala复制代码package com.mysql.cj;
    public class ClientPreparedQueryBindings extends AbstractQueryBindings<ClientPreparedQueryBindValue>
        public void setString(int parameterIndex, String x)

c复制代码type ParamLogin struct {
   UserName string `json:"username" binding:"required"`
   Password string `json:"password" binding:"required"`
}

javascript复制代码func LoginHandler(c *gin.Context) {
   p := new(models.ParamLogin)

   if err := c.ShouldBindJSON(p); err != nil {
      zap.L().Error("LoginHandler with invalid param", zap.Error(err))
      // 因为有的错误 比如json格式不对的错误 是不属于validator错误的 自然无法翻译，所以这里要做类型判断
      errs, ok := err.(validator.ValidationErrors)
      if !ok {
         c.JSON(http.StatusOK, gin.H{
            "msg": err.Error(),
         })
      } else {
         c.JSON(http.StatusOK, gin.H{
            "msg": removeTopStruct(errs.Translate(trans)),
         })
      }
      return
   }

   // 业务处理
   err := logic.Login(p)
   if err != nil {
      // 可以在日志中 看出 到底是哪些用户一直在尝试登录
      zap.L().Error("login failed", zap.String("username", p.UserName), zap.Error(err))
      c.JSON(http.StatusOK, gin.H{
         "msg": "用户名或密码不正确",
      })
      return
   }
   // 返回响应
   c.JSON(http.StatusOK, "login success")
}

go复制代码func Login(login *models.ParamLogin) error {
   user := models.User{
      Username: login.UserName,
      Password: login.Password,
   }
   return mysql.Login(&user)
}

go复制代码func Login(user *models.User) error {
   oldPassword := user.Password
   sqlStr := `select user_id,username,password from user where username=?`
   err := db.Get(user, sqlStr, user.Username)
   if err == sql.ErrNoRows {
      return errors.New("该用户不存在")
   }
   if err != nil {
      return err
   }
   if encryptPassword(oldPassword) != user.Password {
      return errors.New("密码不正确")
   }
   return nil
}

go复制代码package controllers

type ResCode int64

const (
   CodeSuccess ResCode = 1000 + iota
   CodeInvalidParam
   CodeUserExist
   CodeInvalidPassword
   CodeServerBusy
)

var codeMsgMap = map[ResCode]string{
   CodeSuccess:         "success",
   CodeInvalidParam:    "请求参数错误",
   CodeUserExist:       "用户已存在",
   CodeInvalidPassword: "用户名或密码不正确",
   CodeServerBusy:      "服务繁忙 请稍后再试",
}

func (c ResCode) Msg() string {
   msg, ok := codeMsgMap[c]
   if !ok {
      msg = codeMsgMap[CodeServerBusy]
   }
   return msg
}

go复制代码package controllers

import (
   "net/http"

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

type Response struct {
   Code ResCode     `json:"code"`
   Msg  interface{} `json:"msg"`
   Data interface{} `json:"data"`
}

func ResponseError(c *gin.Context, code ResCode) {
   c.JSON(http.StatusOK, &Response{
      Code: code,
      Msg:  code.Msg(),
      Data: nil,
   })
}

func ResponseErrorWithMsg(c *gin.Context, code ResCode, msg interface{}) {
   c.JSON(http.StatusOK, &Response{
      Code: code,
      Msg:  msg,
      Data: nil,
   })
}

func ResponseSuccess(c *gin.Context, data interface{}) {

   c.JSON(http.StatusOK, &Response{
      Code: CodeSuccess,
      Msg:  CodeSuccess.Msg(),
      Data: data,
   })
}

go复制代码package mysql

import (
   "crypto/md5"
   "database/sql"
   "encoding/hex"
   "errors"
   "go_web_app/models"

   "go.uber.org/zap"
)

const serect = "wuyue.com"

// 定义 error的常量方便判断
var (
   UserAleadyExists = errors.New("用户已存在")
   WrongPassword    = errors.New("密码不正确")
   UserNoExists     = errors.New("用户不存在")
)

// dao层 其实就是将数据库操作 封装为函数 等待logic层 去调用她

func InsertUser(user *models.User) error {
   // 密码要加密保存
   user.Password = encryptPassword(user.Password)
   sqlstr := `insert into user(user_id,username,password) values(?,?,?)`
   _, err := db.Exec(sqlstr, user.UserId, user.Username, user.Password)
   if err != nil {
      zap.L().Error("InsertUser dn error", zap.Error(err))
      return err
   }
   return nil
}

//
func Login(user *models.User) error {
   oldPassword := user.Password
   sqlStr := `select user_id,username,password from user where username=?`
   err := db.Get(user, sqlStr, user.Username)
   if err == sql.ErrNoRows {
      return UserNoExists
   }
   if err != nil {
      return err
   }
   if encryptPassword(oldPassword) != user.Password {
      return WrongPassword
   }
   return nil
}

// CheckUserExist 检查数据库是否有该用户名
func CheckUserExist(username string) error {
   sqlstr := `select count(user_id) from user where username = ?`
   var count int
   err := db.Get(&count, sqlstr, username)
   if err != nil {
      zap.L().Error("CheckUserExist dn error", zap.Error(err))
      return err
   }
   if count > 0 {
      return UserAleadyExists
   }
   return nil
}

// 加密密码
func encryptPassword(password string) string {
   h := md5.New()
   h.Write([]byte(serect))
   return hex.EncodeToString(h.Sum([]byte(password)))
}

go复制代码package controllers

import (
   "errors"
   "go_web_app/dao/mysql"
   "go_web_app/logic"
   "go_web_app/models"

   "github.com/go-playground/validator/v10"

   "go.uber.org/zap"

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

func LoginHandler(c *gin.Context) {
   p := new(models.ParamLogin)

   if err := c.ShouldBindJSON(p); err != nil {
      zap.L().Error("LoginHandler with invalid param", zap.Error(err))
      // 因为有的错误 比如json格式不对的错误 是不属于validator错误的 自然无法翻译，所以这里要做类型判断
      errs, ok := err.(validator.ValidationErrors)
      if !ok {
         ResponseError(c, CodeInvalidParam)
      } else {
         ResponseErrorWithMsg(c, CodeInvalidParam, removeTopStruct(errs.Translate(trans)))
      }
      return
   }

   // 业务处理
   err := logic.Login(p)
   if err != nil {
      // 可以在日志中 看出 到底是哪些用户不存在
      zap.L().Error("login failed", zap.String("username", p.UserName), zap.Error(err))
      if errors.Is(err, mysql.WrongPassword) {
         ResponseError(c, CodeInvalidPassword)
      } else {
         ResponseError(c, CodeServerBusy)
      }
      return
   }
   ResponseSuccess(c, "login success")
}

func RegisterHandler(c *gin.Context) {
   // 获取参数和参数校验
   p := new(models.ParamRegister)
   // 这里只能校验下 是否是标准的json格式 之类的 比较简单
   if err := c.ShouldBindJSON(p); err != nil {
      zap.L().Error("RegisterHandler with invalid param", zap.Error(err))
      // 因为有的错误 比如json格式不对的错误 是不属于validator错误的 自然无法翻译，所以这里要做类型判断
      errs, ok := err.(validator.ValidationErrors)
      if !ok {
         ResponseError(c, CodeInvalidParam)
      } else {
         ResponseErrorWithMsg(c, CodeInvalidParam, removeTopStruct(errs.Translate(trans)))
      }
      return
   }
   // 业务处理
   err := logic.Register(p)
   if err != nil {
      zap.L().Error("register failed", zap.String("username", p.UserName), zap.Error(err))
      if errors.Is(err, mysql.UserAleadyExists) {
         ResponseError(c, CodeUserExist)
      } else {
         ResponseError(c, CodeInvalidParam)
      }
      return
   }
   // 返回响应
   ResponseSuccess(c, "register success")
}

go复制代码package jwt

import (
   "errors"
   "time"

   "github.com/golang-jwt/jwt"
)

// MyClaims 注意这里不要 存储 密码之类的敏感信息哟
type MyClaims struct {
   UserId   int64  `json:"userId"`
   UserName string `json:"userName"`
   jwt.StandardClaims
}

const TokenExpireDuration = time.Hour * 2

var mySerect = []byte("wuyue is good man")

// GenToken 生成token
func GenToken(username string, userid int64) (string, error) {
   c := MyClaims{
      UserId:   userid,
      UserName: username,
      StandardClaims: jwt.StandardClaims{
         ExpiresAt: time.Now().Add(TokenExpireDuration).UnixNano(), //过期时间
         Issuer:    "bbs-project",                                  //签发人
      },
   }
   // 加密这个token
   token := jwt.NewWithClaims(jwt.SigningMethodHS256, c)
   // 用签名来 签名这个token
   return token.SignedString(mySerect)
}

// ParseToken 解析token
func ParseToken(tokenString string) (*MyClaims, error) {

   var mc = new(MyClaims)
   token, err := jwt.ParseWithClaims(tokenString, mc, func(token *jwt.Token) (interface{}, error) {
      return mySerect, nil
   })
   if err != nil {
      return nil, err
   }
   // 校验token
   if token.Valid {
      return mc, nil
   }

   return nil, errors.New("invalid token")

}

go复制代码func Login(login *models.ParamLogin) (string, error) {
   user := models.User{
      Username: login.UserName,
      Password: login.Password,
   }
   if err := mysql.Login(&user); err != nil {
      return "", err
   }
   return jwt.GenToken(user.Username, user.UserId)
}

scss复制代码func LoginHandler(c *gin.Context) {
   p := new(models.ParamLogin)

   if err := c.ShouldBindJSON(p); err != nil {
      zap.L().Error("LoginHandler with invalid param", zap.Error(err))
      // 因为有的错误 比如json格式不对的错误 是不属于validator错误的 自然无法翻译，所以这里要做类型判断
      errs, ok := err.(validator.ValidationErrors)
      if !ok {
         ResponseError(c, CodeInvalidParam)
      } else {
         ResponseErrorWithMsg(c, CodeInvalidParam, removeTopStruct(errs.Translate(trans)))
      }
      return
   }

   // 业务处理
   token, err := logic.Login(p)
   if err != nil {
      // 可以在日志中 看出 到底是哪些用户不存在
      zap.L().Error("login failed", zap.String("username", p.UserName), zap.Error(err))
      if errors.Is(err, mysql.WrongPassword) {
         ResponseError(c, CodeInvalidPassword)
      } else {
         ResponseError(c, CodeServerBusy)
      }
      return
   }
   ResponseSuccess(c, token)
}

go复制代码//验证jwt机制
r.GET("/ping", func(context *gin.Context) {
   // 这里post man 模拟的 将token auth-token
   token := context.Request.Header.Get("auth-token")
   if token == "" {
      controllers.ResponseError(context, controllers.CodeTokenIsEmpty)
      return
   }
   parseToken, err := jwt.ParseToken(token)
   if err != nil {
      controllers.ResponseError(context, controllers.CodeTokenInvalid)
      return
   }

   zap.L().Debug("token parese", zap.String("username", parseToken.UserName))
   controllers.ResponseSuccess(context, "pong")
})

matlab复制代码[~,n]=size(x);
e=ones(1,n);
A=[x;y;e]'; %齐次化矩阵
B=A; %初始化
a1=pi/(180/a); %化为弧度制

matlab复制代码%直线的情况
if k==1
    B=A*[1 0 0;0 1 0;-min(x) -min(y) 1]...
        *[cos(a1) sin(a1) 0;-sin(a1) cos(a1) 0;0 0 1]...
        *[1 0 0;0 1 0;min(x) min(y) 1];
    C=B*[1 0 0;0 1 0;-min(x) -min(y) 1]...
        *[sx 0 0;0 sy 0;tx ty 1]...
        *[1 0 0;0 1 0;min(x) min(y) 1];
end
%圆或椭圆的情况
if k==2
    xpingyi=(max(x)+min(x))/2;ypingyi=(max(y)+min(y))/2;
    B=A*[1 0 0;0 1 0;-xpingyi -ypingyi 1]...
        *[cos(a1) sin(a1) 0;-sin(a1) cos(a1) 0;0 0 1]...
        *[1 0 0;0 1 0;xpingyi ypingyi 1];
    C=B*[1 0 0;0 1 0;-xpingyi -ypingyi 1]...
        *[sx 0 0;0 sy 0;tx ty 1]...
        *[1 0 0;0 1 0;xpingyi ypingyi 1];
end

matlab复制代码%绘制新旧图形
plot(A(:,1),A(:,2),'r-',C(:,1),C(:,2),'r-');

java复制代码ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
applicationContext.getBean("myBean");
applicationContext.getBean(MyBean.class);

xml复制代码<bean id="classA" class="ClassA" p:beanB-ref="classB"/>
<bean id="classB" class="ClassB" p:beanA-ref="classA"/>

go复制代码syntax = "proto3";
package protocol;

message Message {
    string avatar = 1;       //头像
    string fromUsername = 2; // 发送消息用户的用户名
    string from = 3;         // 发送消息用户uuid
    string to = 4;           // 发送给对端用户的uuid
    string content = 5;      // 文本消息内容
    int32 contentType = 6;   // 消息内容类型：1.文字 2.普通文件 3.图片 4.音频 5.视频 6.语音聊天 7.视频聊天
    string type = 7;         // 如果是心跳消息，该内容为heatbeat
    int32 messageType = 8;   // 消息类型，1.单聊 2.群聊
    string url = 9;          // 图片，视频，语音的路径
    string fileSuffix = 10;  // 文件后缀，如果通过二进制头不能解析文件后缀，使用该后缀
    bytes file = 11;         // 如果是图片，文件，视频等的二进制
}

shell复制代码git clone https://github.com/kone-net/go-chat

shell复制代码cd go-chat

shell复制代码go mod download

mysql复制代码CREATE DATABASE chat;

shell复制代码vim config.toml

[mysql]
host = "127.0.0.1"
name = "chat"
password = "root1234"
port = 3306
table_prefix = ""
user = "root"

修改用户名user，密码password等信息。

shell复制代码将chat.sql里面的sql语句复制到控制台创建对应的表。

shell复制代码手动添加用户。

shell复制代码go run cmd/main.go

shell复制代码git clone https://github.com/kone-net/go-chat-web

shell复制代码npm install

shell复制代码修改src/common/param/Params.jsx里面的IP_PORT

shell复制代码npm start

arduino复制代码http://127.0.0.1:3000/login

arduino复制代码├── Makefile       代码编译，打包，结构化等操作
├── README.md
├── api
│   └── v1         controller类，对外的接口，如添加好友，查找好友等。所有http请求的入口
├── bin
│   └── chat       打包的二进制文件
├── chat.sql       整个项目的SQL
├── cmd            main函数入口，程序启动
├── common     
│   ├── constant   常量
│   └── util       工具类
├── config         配置初始化类
├── config.toml    配置文件
├── dao
│   └── pool       数据库连接池
├── errors         封装的异常类
├── global
│   └── log        封装的日志类，使用时不会出现第三方的包依赖
├── go.mod
├── go.sum
├── logs           日志文件
├── model          数据库模型，和表一一对应
│   ├── request    请求的实体类
│   ├── response   响应的实体类
├── protocol       消息协议
│   ├── message.pb.go  protoc buffer自动生成的文件
│   └── message.proto  定义的protoc buffer字段
├── response       全局响应，通过http请求的，都包含code，msg，data三个字段
├── router         gin和controller类进行绑定
├── server         WebSocket中消息的接受和转发的主要逻辑
├── service        controller调用的服务类
├── static         静态文件，图片等
│   ├── img
│   └── screenshot markdown用到的截图文件
└── test           测试文件

bash复制代码make build-darwin

实际执行命令是Makefile下的
CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -o bin/chat cmd/main.go

bash复制代码make build

实际执行命令是Makefile下的
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o bin/chat cmd/main.go

bash复制代码make proto

实际执行命令是Makefile下的
protoc --gogo_out=. protocol/*.proto

bash复制代码go get github.com/golang/protobuf/proto

bash复制代码go get github.com/gogo/protobuf/protoc-gen-gogo

bash复制代码go get github.com/gogo/protobuf/proto

bash复制代码protoc --gogo_out=. protocol/*.proto

bash复制代码npm install protobufjs

bash复制代码npx pbjs -t json-module -w commonjs -o src/chat/proto/proto.js  src/chat/proto/*.proto

src/chat/proto/proto.js 是生成的文件的目录路径及其文件名称
src/chat/proto/*.proto  是自己写的字段等

go复制代码// router/router.go
func NewRouter() *gin.Engine {
	gin.SetMode(gin.ReleaseMode)

	server := gin.Default()
	server.Use(Cors())
	server.Use(Recovery)

	socket := RunSocekt

	group := server.Group("")
	{
        ...

		group.GET("/socket.io", socket)
	}
	return server
}

go复制代码// router/socket.go
var upGrader = websocket.Upgrader{
	CheckOrigin: func(r *http.Request) bool {
		return true
	},
}

func RunSocekt(c *gin.Context) {
	user := c.Query("user")
	if user == "" {
		return
	}
	log.Info("newUser", zap.String("newUser", user))
	ws, err := upGrader.Upgrade(c.Writer, c.Request, nil) //升级协议为WebSocket
	if err != nil {
		return
	}

	client := &server.Client{
		Name: user,
		Conn: ws,
		Send: make(chan []byte),
	}

	server.MyServer.Register <- client
	go client.Read()
	go client.Write()
}

go复制代码// server/server.go
func (s *Server) Start() {
	log.Info("start server", log.Any("start server", "start server..."))
	for {
		select {
		case conn := <-s.Register:
			log.Info("login", log.Any("login", "new user login in"+conn.Name))
			s.Clients[conn.Name] = conn
			msg := &protocol.Message{
				From:    "System",
				To:      conn.Name,
				Content: "welcome!",
			}
			protoMsg, _ := proto.Marshal(msg)
			conn.Send <- protoMsg

		case conn := <-s.Ungister:
			log.Info("loginout", log.Any("loginout", conn.Name))
			if _, ok := s.Clients[conn.Name]; ok {
				close(conn.Send)
				delete(s.Clients, conn.Name)
			}

		case message := <-s.Broadcast:
			msg := &protocol.Message{}
			proto.Unmarshal(message, msg)
            ...
            ...
		}
	}
}

javascript复制代码bindParse = () => {
        document.getElementById("messageArea").addEventListener("paste", (e) => {
            var data = e.clipboardData
            if (!data.items) {
                return;
            }
            var items = data.items

            if (null == items || items.length <= 0) {
                return;
            }

            let item = items[0]
            if (item.kind !== 'file') {
                return;
            }
            let blob = item.getAsFile()

            let reader = new FileReader()
            reader.readAsArrayBuffer(blob)

            reader.onload = ((e) => {
                let imgData = e.target.result

                // 上传文件必须将ArrayBuffer转换为Uint8Array
                let data = {
                    fromUsername: localStorage.username,
                    from: this.state.fromUser,
                    to: this.state.toUser,
                    messageType: this.state.messageType,
                    content: this.state.value,
                    contentType: 3,
                    file: new Uint8Array(imgData)
                }
                let message = protobuf.lookup("protocol.Message")
                const messagePB = message.create(data)
                socket.send(message.encode(messagePB).finish())

                this.appendImgToPanel(imgData)
            })

        }, false)
    }

javascript复制代码/**
     * 当按下按钮时录制视频
     */
    dataChunks = [];
    recorder = null;
    startVideoRecord = (e) => {
        navigator.getUserMedia = navigator.getUserMedia ||
            navigator.webkitGetUserMedia ||
            navigator.mozGetUserMedia ||
            navigator.msGetUserMedia; //获取媒体对象（这里指摄像头）

        let preview = document.getElementById("preview");
        this.setState({
            isRecord: true
        })

        navigator.mediaDevices
            .getUserMedia({
                audio: true,
                video: true,
            }).then((stream) => {
                preview.srcObject = stream;
                this.recorder = new MediaRecorder(stream);

                this.recorder.ondataavailable = (event) => {
                    let data = event.data;
                    this.dataChunks.push(data);
                };
                this.recorder.start(1000);
            });
    }

    /**
     * 松开按钮发送视频到服务器
     * @param {事件} e 
     */
    stopVideoRecord = (e) => {
        this.setState({
            isRecord: false
        })

        let recordedBlob = new Blob(this.dataChunks, { type: "video/webm" });

        let reader = new FileReader()
        reader.readAsArrayBuffer(recordedBlob)

        reader.onload = ((e) => {
            let fileData = e.target.result

            // 上传文件必须将ArrayBuffer转换为Uint8Array
            let data = {
                fromUsername: localStorage.username,
                from: this.state.fromUser,
                to: this.state.toUser,
                messageType: this.state.messageType,
                content: this.state.value,
                contentType: 3,
                file: new Uint8Array(fileData)
            }
            let message = protobuf.lookup("protocol.Message")
            const messagePB = message.create(data)
            socket.send(message.encode(messagePB).finish())
        })

        this.setState({
            comments: [
                ...this.state.comments,
                {
                    author: localStorage.username,
                    avatar: this.state.user.avatar,
                    content: <p><video src={URL.createObjectURL(recordedBlob)} controls autoPlay={false} preload="auto" width='200px' /></p>,
                    datetime: moment().fromNow(),
                },
            ],
        }, () => {
            this.scrollToBottom()
        })
        if (this.recorder) {
            this.recorder.stop()
            this.recorder = null
        }
        let preview = document.getElementById("preview");
        preview.srcObject.getTracks().forEach((track) => track.stop());
        this.dataChunks = []
    }

java复制代码public void channelActive(ChannelHandlerContext ctx) throws Exception {
    log.debug("sending...");
    ByteBuf buffer = ctx.alloc().buffer(16);
    buffer.writeBytes(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
    ctx.writeAndFlush(buffer);
    // 使用短链接，每次发送完毕后就断开连接
    ctx.channel().close();
}

java复制代码// 约定最大长度为16
final int maxLength = 16;
// 被发送的数据
char c = 'a';
// 向服务器发送10个报文
for (int i = 0; i < 10; i++) {
    ByteBuf buffer = ctx.alloc().buffer(maxLength);
    // 定长byte数组，未使用部分会以0进行填充
    byte[] bytes = new byte[maxLength];
    // 生成长度为0~15的数据
    for (int j = 0; j < (int)(Math.random()*(maxLength-1)); j++) {
        bytes[j] = (byte) c;
    }
    buffer.writeBytes(bytes);
    c++;
    // 将数据发送给服务器
    ctx.writeAndFlush(buffer);
}

java复制代码// 通过定长解码器对粘包数据进行拆分
ch.pipeline().addLast(new FixedLengthFrameDecoder(16));
ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));

java复制代码// 约定最大长度为 64
final int maxLength = 64;
// 被发送的数据
char c = 'a';
for (int i = 0; i < 10; i++) {
    ByteBuf buffer = ctx.alloc().buffer(maxLength);
    // 生成长度为0~62的数据
    Random random = new Random();
    StringBuilder sb = new StringBuilder();
    for (int j = 0; j < (int)(random.nextInt(maxLength-2)); j++) {
        sb.append(c);
    }
    // 数据以 \n 结尾
    sb.append("\n");
    buffer.writeBytes(sb.toString().getBytes(StandardCharsets.UTF_8));
    c++;
    // 将数据发送给服务器
    ctx.writeAndFlush(buffer);
}

java复制代码// 通过行解码器对粘包数据进行拆分，以 \n 为分隔符
// 需要指定最大长度
ch.pipeline().addLast(new DelimiterBasedFrameDecoder(64));
ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));

java复制代码...   
// 数据以 \c 结尾
sb.append("\\c");
buffer.writeBytes(sb.toString().getBytes(StandardCharsets.UTF_8));
...

java复制代码// 将分隔符放入ByteBuf中
ByteBuf bufSet = ch.alloc().buffer().writeBytes("\\c".getBytes(StandardCharsets.UTF_8));
// 通过行解码器对粘包数据进行拆分，以 \c 为分隔符
ch.pipeline().addLast(new DelimiterBasedFrameDecoder(64, ch.alloc().buffer().writeBytes(bufSet)));
ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));

java复制代码public LengthFieldBasedFrameDecoder(
    int maxFrameLength,
    int lengthFieldOffset, int lengthFieldLength,
    int lengthAdjustment, int initialBytesToStrip )

ini复制代码lengthFieldOffset   = 0
lengthFieldLength   = 2
lengthAdjustment    = 0
initialBytesToStrip = 0 (= do not strip header)
  
BEFORE DECODE (14 bytes)         AFTER DECODE (14 bytes)
+--------+----------------+      +--------+----------------+
| Length | Actual Content |----->| Length | Actual Content |
| 0x000C | "HELLO, WORLD" |      | 0x000C | "HELLO, WORLD" |
+--------+----------------+      +--------+----------------+

ini复制代码lengthFieldOffset   = 0
lengthFieldLength   = 2
lengthAdjustment    = 0
initialBytesToStrip = 2 (= the length of the Length field)
  
BEFORE DECODE (14 bytes)         AFTER DECODE (12 bytes)
+--------+----------------+      +----------------+
| Length | Actual Content |----->| Actual Content |
| 0x000C | "HELLO, WORLD" |      | "HELLO, WORLD" |
+--------+----------------+      +----------------+

ini复制代码lengthFieldOffset   = 2 (= the length of Header 1)
lengthFieldLength   = 3
lengthAdjustment    = 0
initialBytesToStrip = 0
  
BEFORE DECODE (17 bytes)                      AFTER DECODE (17 bytes)
+----------+----------+----------------+      +----------+----------+----------------+
| Header 1 |  Length  | Actual Content |----->| Header 1 |  Length  | Actual Content |
|  0xCAFE  | 0x00000C | "HELLO, WORLD" |      |  0xCAFE  | 0x00000C | "HELLO, WORLD" |
+----------+----------+----------------+      +----------+----------+----------------+

ini复制代码lengthFieldOffset   = 0
lengthFieldLength   = 3
lengthAdjustment    = 2 (= the length of Header 1)
initialBytesToStrip = 0
  
BEFORE DECODE (17 bytes)                      AFTER DECODE (17 bytes)
+----------+----------+----------------+      +----------+----------+----------------+
|  Length  | Header 1 | Actual Content |----->|  Length  | Header 1 | Actual Content |
| 0x00000C |  0xCAFE  | "HELLO, WORLD" |      | 0x00000C |  0xCAFE  | "HELLO, WORLD" |
+----------+----------+----------------+      +----------+----------+----------------+

ini复制代码lengthFieldOffset   = 1 (= the length of HDR1)
lengthFieldLength   = 2
lengthAdjustment    = 1 (= the length of HDR2)
initialBytesToStrip = 3 (= the length of HDR1 + LEN)
  
BEFORE DECODE (16 bytes)                       AFTER DECODE (13 bytes)
+------+--------+------+----------------+      +------+----------------+
| HDR1 | Length | HDR2 | Actual Content |----->| HDR2 | Actual Content |
| 0xCA | 0x000C | 0xFE | "HELLO, WORLD" |      | 0xFE | "HELLO, WORLD" |
+------+--------+------+----------------+      +------+----------------+

java复制代码public class EncoderStudy {
    public static void main(String[] args) {
        // 模拟服务器
        // 使用EmbeddedChannel测试handler
        EmbeddedChannel channel = new EmbeddedChannel(
                // 数据最大长度为1KB，长度标识前后各有1个字节的附加信息，长度标识长度为4个字节（int）
                new LengthFieldBasedFrameDecoder(1024, 1, 4, 1, 0),
                new LoggingHandler(LogLevel.DEBUG)
        );

        // 模拟客户端，写入数据
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();
        send(buffer, "Hello");
        channel.writeInbound(buffer);
        send(buffer, "World");
        channel.writeInbound(buffer);
    }

    private static void send(ByteBuf buf, String msg) {
        // 得到数据的长度
        int length = msg.length();
        byte[] bytes = msg.getBytes(StandardCharsets.UTF_8);
        // 将数据信息写入buf
        // 写入长度标识前的其他信息
        buf.writeByte(0xCA);
        // 写入数据长度标识
        buf.writeInt(length);
        // 写入长度标识后的其他信息
        buf.writeByte(0xFE);
        // 写入具体的数据
        buf.writeBytes(bytes);
    }
}