tio对接天眼tcp协议记录

已于 2022-07-11 08:34:10 修改
阅读量8.8w 收藏 3
点赞数 1
分类专栏： tio tcp 文章标签： tcp/ip tio 天眼
于 2021-08-31 17:05:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenxingchen/article/details/120021999
版权
tio 同时被 2 个专栏收录
4 篇文章 0 订阅
订阅专栏
tcp
4 篇文章 2 订阅
订阅专栏

依赖

<dependency>
            <groupId>org.t-io</groupId>
            <artifactId>tio-core</artifactId>
            <version>3.7.4.v20210808-RELEASE</version>
        </dependency>

Packet

import cn.hutool.core.util.HexUtil;
import com.demo.socket.util.HexStrUtil;
import lombok.Getter;
import lombok.Setter;
import org.tio.core.intf.Packet;

import java.io.UnsupportedEncodingException;

/**
 * @author Lenovo 消息体
 */
@Setter
@Getter
public class MindPackage extends Packet {
    private static final long serialVersionUID = -172060606924066412L;
    /**
     * 包头长度
     */
    public static final Integer HEADER = 4;
    /**
     * 记录包长度的长度
     */
    public static final Integer LENGTH = 4;
    /**
     * 登录ID长度
     */
    public static final Integer LOGIN_ID = 4;
    /**
     * 命令码长度
     */
    public static final Integer COMMAND_CODE = 2;
    /**
     * 命令ID长度
     */
    public static final Integer COMMAND_ID = 4;
    /**
     * 命令ID长度 0正常1非正常；数据前 8 字节是错误码，之后是 UTF8 编码的错误信息
     */
    public static final Integer RESULT = 1;
    /**
     * 加密方式0未加密长度
     */
    public static final Integer SECRET = 1;
    /**
     * 压缩方式长度；0=无压缩，1=gzip；
     */
    public static final Integer ZIP = 1;
    /**
     * 数据长度
     */
    public static final Integer DATA = null;
    /**
     * 包尾长度
     */
    public static final Integer LAST = 4;
    /**
     * 编码
     */
    public static final String CHARSET = "utf-8";
    /**
     * 字节数组：包头
     */
    private byte[] head = HexStrUtil.hexStrToBinaryStr("3C 43 6D 64");
    /**
     * 字节数组：包长度 【null都要初始化一下，否则发送心跳包计算长度的时候会空指针】
     */
    private byte[] length = new byte[4];
    /**
     * 字节数组：登录ID
     */
    private byte[] loginId = new byte[4];
    /**
     * 字节数组：命令码
     */
    private byte[] commandCode = new byte[2];
    /**
     * 字节数组：命令ID 自定义
     */
    private byte[] commandId = new byte[4];
    /**
     * 字节数组：访问结果
     */
    private byte[] result = HexUtil.decodeHex("00");
    /**
     * 字节数组：加密方式
     */
    private byte[] secret = HexStrUtil.hexStrToBinaryStr("00");
    /**
     * 字节数组：压缩方式
     */
    private byte[] zip = HexStrUtil.hexStrToBinaryStr("00");
    /**
     * 字节数组：数据
     */
    private byte[] data = new byte[0];
    /**
     * 字节数组：包尾
     */
    private byte[] last = HexStrUtil.hexStrToBinaryStr("63 6D 44 3E");

    /**
     * 计算出包长度字节4byte
     */
    public byte[] getReqLengthByCount() {
        int number = loginId.length
                + commandCode.length
                + commandId.length
                + secret.length
                + zip.length
                + data.length;
        //先转16进制字符串，再转bytes
        byte[] bytes = new byte[4];
        byte[] temp = HexUtil.decodeHex(Integer.toHexString(number));
        //固定占4个字节，所以这里找个容器转一道
        System.arraycopy(temp, 0, bytes, 0, temp.length);
        return bytes;
    }

    /**
     * 计算出包长度字节4byte
     */
    public byte[] getResLengthByCount() {
        int number = loginId.length
                + commandCode.length
                + commandId.length
                + secret.length
                + result.length
                + zip.length
                + data.length;
        //先转16进制字符串，再转bytes
        byte[] bytes = new byte[4];
        byte[] temp = HexUtil.decodeHex(Integer.toHexString(number));
        //固定占4个字节，所以这里找个容器转一道
        System.arraycopy(temp, 0, bytes, 0, temp.length);
        return bytes;
    }

    /**
     * 获取字符串数据
     */
    public String getStringData() throws UnsupportedEncodingException {
        return new String(this.data, CHARSET);
    }

    /**
     * 设置字符串数据
     */
    public void setStringData(String data) {
        //先转16进制字符串，再转bytes
        String data16 = HexUtil.encodeHexStr(data).toUpperCase();
        this.data = HexUtil.decodeHex(data16);
    }
}

客户端处理器实现

import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.HexUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.alibaba.fastjson.JSON;
import com.demo.socket.entity.Response;
import com.demo.socket.service.IResponseService;
import com.demo.socket.socketplus.Remark;
import com.demo.socket.util.HexStrUtil;
import org.tio.client.intf.ClientAioHandler;
import org.tio.core.ChannelContext;
import org.tio.core.TioConfig;
import org.tio.core.exception.TioDecodeException;
import org.tio.core.intf.Packet;

import java.nio.ByteBuffer;
import java.util.Date;

/**
 * @author Lenovo 处理器
 */
public class ClientAioHandlerImpl implements ClientAioHandler {
    /**
     * 创建心跳包
     */
    @Override
    public Packet heartbeatPacket(ChannelContext channelContext) {
        return new MindPackage();
    }

    /**
     * 根据ByteBuffer解码成业务需要的Packet对象.
     * 如果收到的数据不全，导致解码失败，请返回null，在下次消息来时框架层会自动续上前面的收到的数据
     */
    @Override
    public Packet decode(ByteBuffer buffer, int limit, int position, int readableLength, ChannelContext channelContext) throws TioDecodeException {
        MindPackage mindPackage = new MindPackage();
        //至少要知道包头和包长度
        if (readableLength < MindPackage.HEADER + MindPackage.LENGTH) {
            return null;
        }
        //包头byte
        byte[] head = new byte[4];
        buffer.get(head, 0, MindPackage.HEADER);
        mindPackage.setHead(head);
        //包长度byte
        byte[] length = new byte[4];
        buffer.get(length, 0, MindPackage.LENGTH);
        mindPackage.setLength(length);
        //位运算得出包长度
        int number = HexStrUtil.bytes2int(length);

        //一个完整的包的长度必须大于可读取的长度
        if (MindPackage.HEADER + MindPackage.LENGTH + number + MindPackage.LAST > readableLength) {
            return null;
        } else {
            //登录ID
            byte[] loginId = new byte[4];
            buffer.get(loginId, 0, 4);
            mindPackage.setLoginId(loginId);

            //命令码
            byte[] commandCode = new byte[2];
            buffer.get(commandCode, 0, 2);
            mindPackage.setCommandCode(commandCode);

            //命令ID
            byte[] commandID = new byte[4];
            buffer.get(commandID, 0, 4);
            mindPackage.setCommandId(commandID);

            //执行结果
            byte[] result = new byte[1];
            buffer.get(result, 0, 1);
            mindPackage.setResult(result);

            //加密方式
            byte[] secret = new byte[1];
            buffer.get(secret, 0, 1);
            mindPackage.setSecret(secret);

            //压缩方式
            byte[] zip = new byte[1];
            buffer.get(zip, 0, 1);
            mindPackage.setZip(zip);

            //数据
            int dataLength = number - MindPackage.HEADER
                    - MindPackage.COMMAND_CODE
                    - MindPackage.COMMAND_ID
                    - MindPackage.RESULT
                    - MindPackage.SECRET
                    - MindPackage.ZIP;
            byte[] data = new byte[dataLength];
            buffer.get(data, 0, dataLength);
            mindPackage.setData(data);

            //包尾
            byte[] last = new byte[4];
            buffer.get(last, 0, 4);
            mindPackage.setLast(last);
            return mindPackage;
        }
    }

    /**
     * 编码
     */
    @Override
    public ByteBuffer encode(Packet packet, TioConfig tioConfig, ChannelContext channelContext) {
        MindPackage mindPackage = (MindPackage) packet;

        byte[] head = mindPackage.getHead();
        byte[] length = mindPackage.getReqLengthByCount();
        byte[] loginId = mindPackage.getLoginId();
        byte[] commandCode = mindPackage.getCommandCode();
        byte[] commandId = mindPackage.getCommandId();
        byte[] secret = mindPackage.getSecret();
        byte[] zip = mindPackage.getZip();
        byte[] data = mindPackage.getData();
        byte[] last = mindPackage.getLast();
        //组建在一起
        byte[] bytes = ArrayUtil.addAll(head, length, loginId, commandCode, commandId, secret, zip, data, last);

        ByteBuffer byteBuffer = ByteBuffer.allocate(bytes.length);
        byteBuffer.order(tioConfig.getByteOrder());
        byteBuffer.put(bytes);
        return byteBuffer;
    }

    /**
     * 处理消息包
     */
    @Override
    public void handler(Packet packet, ChannelContext channelContext) throws Exception {
        System.out.println("------------------------------------------START--------------------------------------------------------");
        //处理解码后的消息
        MindPackage mindPackage = (MindPackage) packet;
        //登录
        if (Remark.LOGIN_COMMAND_ID.equals(HexUtil.encodeHexStr(mindPackage.getCommandId()))) {
            IResponseService responseService = SpringUtil.getBean(IResponseService.class);
            String hexStrCommandId = HexUtil.encodeHexStr(mindPackage.getCommandId());
            Response response = responseService.query(hexStrCommandId);
            System.out.println("result16" + HexUtil.encodeHexStr(mindPackage.getResult()));
            //是否登录成功
            if ("00".equals(HexUtil.encodeHexStr(mindPackage.getResult()))) {
                response.setJson(mindPackage.getStringData());
                response.setResponseTime(new Date());
                int i = responseService.updateData(response);
                System.out.println("试图保存登录结果response表：" + JSON.toJSONString(response) + ":::" + i);
            } else {
                response.setJson("{\"Result\":\"error\"}");
                response.setResponseTime(new Date());
                int i = responseService.updateData(response);
                System.out.println("试图保存登录错误结果response表：" + JSON.toJSONString(response) + ":::" + i);
            }
            System.out.println("登录接口结果：" + mindPackage.getStringData());

        } else {
            System.out.println("客户端最终捕获commandID："+HexUtil.encodeHexStr(mindPackage.getCommandId()));
        }
        System.out.println("--------------------------------------------END--------------------------------------------------------");
    }
}

客户端监听器实现

import cn.hutool.core.util.HexUtil;
import org.tio.client.intf.ClientAioListener;
import org.tio.core.ChannelContext;
import org.tio.core.Tio;
import org.tio.core.intf.Packet;

/**
 * @author Lenovo 监听器
 */
public class ClientAioListenerImpl implements ClientAioListener {

    /**
     * 建链后触发本方法，注：建链不一定成功，需要关注参数isConnected
     *
     * @param channelContext
     * @param isConnected    是否连接成功,true:表示连接成功，false:表示连接失败
     * @param isReconnect    是否是重连, true: 表示这是重新连接，false: 表示这是第一次连接
     * @throws Exception
     */
    @Override
    public void onAfterConnected(ChannelContext channelContext, boolean isConnected, boolean isReconnect) throws Exception {
        //建立（重连）连接之后需要重新登录
        if (isConnected) {
            String message = "{\"Account\":\"Account\",\"Password\":\"Password\"}";

            MindPackage mindPackage = new MindPackage();
            mindPackage.setCommandId(HexUtil.decodeHex(Remark.LOGIN_COMMAND_ID));
            mindPackage.setCommandCode(HexUtil.decodeHex(Remark.LOGIN_COMMAND_CODE));
            mindPackage.setLoginId(HexUtil.decodeHex("00 00 00 00"));
            mindPackage.setStringData(message);
            //发出登录请求
            Tio.send(channelContext, mindPackage);
        }
    }

    /**
     * 原方法名：onAfterDecoded
     * 解码成功后触发本方法
     *
     * @param channelContext
     * @param packet
     * @param packetSize
     * @throws Exception
     */
    @Override
    public void onAfterDecoded(ChannelContext channelContext, Packet packet, int packetSize) throws Exception {

    }

    /**
     * 接收到TCP层传过来的数据后
     *
     * @param channelContext
     * @param receivedBytes  本次接收了多少字节
     * @throws Exception
     */
    @Override
    public void onAfterReceivedBytes(ChannelContext channelContext, int receivedBytes) throws Exception {

    }

    /**
     * 消息包发送之后触发本方法
     *
     * @param channelContext
     * @param packet
     * @param isSentSuccess  true:发送成功，false:发送失败
     * @throws Exception
     */
    @Override
    public void onAfterSent(ChannelContext channelContext, Packet packet, boolean isSentSuccess) throws Exception {

    }

    /**
     * 处理一个消息包后
     *
     * @param channelContext
     * @param packet
     * @param cost           本次处理消息耗时，单位：毫秒
     * @throws Exception
     */
    @Override
    public void onAfterHandled(ChannelContext channelContext, Packet packet, long cost) throws Exception {

    }

    /**
     * 连接关闭前触发本方法
     *
     * @param channelContext the channelcontext
     * @param throwable      the throwable 有可能为空
     * @param remark         the remark 有可能为空
     * @param isRemove
     * @throws Exception
     */
    @Override
    public void onBeforeClose(ChannelContext channelContext, Throwable throwable, String remark, boolean isRemove) throws Exception {

    }
}

服务端处理器

import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.HexUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.tio.core.ChannelContext;
import org.tio.core.Tio;
import org.tio.core.TioConfig;
import org.tio.core.exception.TioDecodeException;
import org.tio.core.intf.Packet;
import org.tio.server.intf.ServerAioHandler;

import java.nio.ByteBuffer;
import java.util.Date;
import java.util.UUID;

/**
 * @author Lenovo 处理器
 */
@Slf4j
public class ServerAioHandlerImpl implements ServerAioHandler {

    /**
     * 根据ByteBuffer解码成业务需要的Packet对象.
     * 如果收到的数据不全，导致解码失败，请返回null，在下次消息来时框架层会自动续上前面的收到的数据
     *
     * @param buffer         参与本次希望解码的ByteBuffer
     * @param limit          ByteBuffer的limit
     * @param position       ByteBuffer的position，不一定是0哦
     * @param readableLength ByteBuffer参与本次解码的有效数据（= limit - position）
     * @param channelContext
     * @return
     * @throws
     */
    @Override
    public Packet decode(ByteBuffer buffer, int limit, int position, int readableLength, ChannelContext channelContext) throws TioDecodeException {
        if (readableLength == 1) {
            return null;
        }

        MindPackage mindPackage = new MindPackage();
        //至少要知道包头和包长度
        log.info("readableLength:" + readableLength);
        if (readableLength < MindPackage.HEADER + MindPackage.LENGTH) {
            log.info("readable太小无法解码");
            return null;
        }
        //包头byte
        byte[] head = new byte[4];
        buffer.get(head, 0, MindPackage.HEADER);
        mindPackage.setHead(head);
        //包长度byte
        byte[] length = new byte[4];
        buffer.get(length, 0, MindPackage.LENGTH);
        mindPackage.setLength(length);
        //位运算得出包长度
        int number = HexStrUtil.bytes2int(length);
        log.info("number:" + number);
        //一个完整的包的长度必须大于可读取的长度
        if (MindPackage.HEADER + MindPackage.LENGTH + number + MindPackage.LAST > readableLength) {
            log.info("包长大于readable，本次无法解码");
            return null;
        } else {
            //登录ID
            byte[] loginId = new byte[4];
            buffer.get(loginId, 0, 4);
            mindPackage.setLoginId(loginId);

            //命令码
            byte[] commandCode = new byte[2];
            buffer.get(commandCode, 0, 2);
            mindPackage.setCommandCode(commandCode);

            //命令ID
            byte[] commandID = new byte[4];
            buffer.get(commandID, 0, 4);
            mindPackage.setCommandId(commandID);

            //加密方式
            byte[] secret = new byte[1];
            buffer.get(secret, 0, 1);
            mindPackage.setSecret(secret);

            //压缩方式
            byte[] zip = new byte[1];
            buffer.get(zip, 0, 1);
            mindPackage.setZip(zip);

            //数据
            int dataLength = number - MindPackage.HEADER
                    - MindPackage.COMMAND_CODE
                    - MindPackage.COMMAND_ID
                    - MindPackage.SECRET
                    - MindPackage.ZIP;
            byte[] data = new byte[dataLength];
            buffer.get(data, 0, dataLength);
            mindPackage.setData(data);

            //包尾
            byte[] last = new byte[4];
            buffer.get(last, 0, 4);
            mindPackage.setLast(last);
            return mindPackage;
        }
    }

    /**
     * 编码
     *
     * @param packet
     * @param tioConfig
     * @param channelContext
     * @return
     */
    @Override
    public ByteBuffer encode(Packet packet, TioConfig tioConfig, ChannelContext channelContext) {
        MindPackage mindPackage = (MindPackage) packet;

        byte[] head = mindPackage.getHead();
        byte[] length = mindPackage.getResLengthByCount();
        byte[] loginId = mindPackage.getLoginId();
        byte[] commandCode = mindPackage.getCommandCode();
        byte[] commandId = mindPackage.getCommandId();
        byte[] result = mindPackage.getResult();
        byte[] secret = mindPackage.getSecret();
        byte[] zip = mindPackage.getZip();
        byte[] data = mindPackage.getData();
        byte[] last = mindPackage.getLast();
        //组建在一起
        byte[] bytes = ArrayUtil.addAll(head, length, loginId, commandCode, commandId, result, secret, zip, data, last);
        ByteBuffer byteBuffer = ByteBuffer.allocate(bytes.length);
        byteBuffer.order(tioConfig.getByteOrder());
        byteBuffer.put(bytes);
        return byteBuffer;
    }

    /**
     * 处理消息包
     *
     * @param packet
     * @param channelContext
     * @throws Exception
     */
    @Override
    public void handler(Packet packet, ChannelContext channelContext) throws Exception {
        MindPackage mindPackage = (MindPackage) packet;
        //报警照片推送
        if (Remark.PUSH_VIDEO_SUMMARY_OR_ALARM_CODE.equals(HexUtil.encodeHexStr(mindPackage.getCommandCode()))) {
            BusinessHandle.push_video_summary_or_alarm_code(mindPackage);
        } else if (Remark.LOGIN_COMMAND_CODE.equals(HexUtil.encodeHexStr(mindPackage.getCommandCode()))) {
            System.out.println("客户端正在尝试登录：" + mindPackage.getStringData());
        } else {
            System.out.println("最终捕获：" + mindPackage.getStringData());
            Request request = new Request();
            request.setOrderCode(HexUtil.encodeHexStr(mindPackage.getCommandCode()));
            request.setRequestTime(new Date());
            request.setJson(mindPackage.getStringData());
            IRequestService requestService = SpringUtil.getBean(IRequestService.class);
            requestService.add(request);
        }
        //发消息
        String account = "{\"UserId\":10145}";
        mindPackage.setStringData(account);
        mindPackage.setCommandCode(HexUtil.decodeHex("0000"));
        mindPackage.setLoginId(HexUtil.decodeHex("A1270000"));
        Tio.send(channelContext, mindPackage);
    }
}

服务端监听器实现

package com.demo.socket.socketplus.server;

import org.tio.core.ChannelContext;
import org.tio.core.intf.Packet;
import org.tio.server.intf.ServerAioListener;

/**
 * @author Lenovo 监听器
 */
public class ServerAioListenerImpl implements ServerAioListener {
    @Override
    public boolean onHeartbeatTimeout(ChannelContext channelContext, Long aLong, int i) {
        return false;
    }

    @Override
    public void onAfterConnected(ChannelContext channelContext, boolean b, boolean b1) throws Exception {

    }

    @Override
    public void onAfterDecoded(ChannelContext channelContext, Packet packet, int i) throws Exception {

    }

    @Override
    public void onAfterReceivedBytes(ChannelContext channelContext, int i) throws Exception {

    }

    @Override
    public void onAfterSent(ChannelContext channelContext, Packet packet, boolean b) throws Exception {

    }

    @Override
    public void onAfterHandled(ChannelContext channelContext, Packet packet, long l) throws Exception {

    }

    @Override
    public void onBeforeClose(ChannelContext channelContext, Throwable throwable, String s, boolean b) throws Exception {

    }
}

启动

public static ClientChannelContext starter() throws Exception {
        ClientTioConfig clientTioConfig = new ClientTioConfig(new ClientAioHandlerImpl(), new ClientAioListenerImpl(), new ReconnConf());
        TioClient tioClient = new TioClient(clientTioConfig);
        return tioClient.connect(new Node("192.168.0.1", 8000));
    }
public static TioServer starter() throws IOException {
        ServerTioConfig serverTioConfig = new ServerTioConfig("tio-server", new ServerAioHandlerImpl(), new ServerAioListenerImpl());
        tioServer = new TioServer(serverTioConfig);
        tioServer.start(null, 8080);

        return tioServer;
    }

注意：4byte记录了包长度，低位在前。函数如下：

/**
     * 标识包长度的4byte转成int数字
     */
    public static int bytes2int(byte[] bytes) {
        Assert.isTrue(bytes.length == 4, "只支持byte[]长度为4的转换");
        String picLenStr1 = HexUtil.encodeHexStr(bytes);
        String newPicLenStr1 = picLenStr1.substring(6, 8) + picLenStr1.substring(4, 6)
                + picLenStr1.substring(2, 4) + picLenStr1.substring(0, 2);
        return Integer.parseInt(newPicLenStr1, 16);
    }

补贴几个类：

package com.demo.socket.util;

import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.HexUtil;
import org.springframework.util.StringUtils;

import java.io.*;
import java.nio.charset.StandardCharsets;

/**
 * @author xuhj
 * @description
 * @date 2021/4/28 15:37
 */
public class HexStrUtil {
    /**
     * 将十六进制的字符串转换成字节数组
     *
     * @param hexString
     * @return
     */
    public static byte[] hexStrToBinaryStr(String hexString) {

        if (StringUtils.isEmpty(hexString)) {
            return null;
        }

        hexString = hexString.replaceAll(" ", "");

        int len = hexString.length();
        int index = 0;

        byte[] bytes = new byte[len / 2];

        while (index < len) {

            String sub = hexString.substring(index, index + 2);

            bytes[index / 2] = (byte) Integer.parseInt(sub, 16);

            index += 2;
        }


        return bytes;
    }

    /**
     * 将字节数组转换成十六进制的字符串
     *
     * @return
     */
    public static String binaryToHexString(byte[] bytes, int length) {
        String hexStr = "0123456789ABCDEF";
        String result = "";
        String hex = "";
        int len = 0;
        for (byte b : bytes) {
            len++;
            hex = String.valueOf(hexStr.charAt((b & 0xF0) >> 4));
            hex += String.valueOf(hexStr.charAt(b & 0x0F));
            result += hex;
            if (len == length) {
                break;
            }
        }
        return result;
    }

    /**
     * 16进制字符串转换为字符串
     *
     * @param s
     * @return
     */
    public static String hexStringToString(String s) {
        if (s == null || "".equals(s)) {
            return null;
        }
        s = s.replace(" ", "");
        byte[] baKeyword = new byte[s.length() / 2];
        for (int i = 0; i < baKeyword.length; i++) {
            try {
                baKeyword[i] = (byte) (0xff & Integer.parseInt(
                        s.substring(i * 2, i * 2 + 2), 16));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        try {
            s = new String(baKeyword, StandardCharsets.UTF_8);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return s;
    }

    /**
     * 字符串转为16进制字符串
     */
    public static String convertStringToHex(String str) {

        char[] chars = str.toCharArray();

        StringBuffer hex = new StringBuffer();
        for (char aChar : chars) {
            hex.append(Integer.toHexString((int) aChar));
        }

        return hex.toString().toUpperCase();
    }

    public static String txt2String(File file) {
        StringBuilder result = new StringBuilder();

        try {
            BufferedReader br = new BufferedReader(new FileReader(file));//构造一个BufferedReader类来读取文件

            String s = null;

            while ((s = br.readLine()) != null) {//使用readLine方法，一次读一行

                result.append(System.lineSeparator() + s);

            }

            br.close();

        } catch (Exception e) {
            e.printStackTrace();

        }

        return result.toString();

    }

    /**
     * 将16进制转换为二进制
     *
     * @param hexStr
     * @return
     */
    public static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr.length() < 1)
            return null;
        byte[] result = new byte[hexStr.length() / 2];
        for (int i = 0; i < hexStr.length() / 2; i++) {
            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2),
                    16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }

    public static void byteToFile(byte[] contents, String filePath) {
        BufferedInputStream bis = null;
        FileOutputStream fos = null;
        BufferedOutputStream output = null;
        try {
            ByteArrayInputStream byteInputStream = new ByteArrayInputStream(contents);
            bis = new BufferedInputStream(byteInputStream);
            File file = new File(filePath);
            // 获取文件的父路径字符串
            File path = file.getParentFile();
            if (!path.exists()) {
                boolean isCreated = path.mkdirs();
                if (!isCreated) {
                }
            }
            fos = new FileOutputStream(file);
            // 实例化OutputString 对象
            output = new BufferedOutputStream(fos);
            byte[] buffer = new byte[1024];
            int length = bis.read(buffer);
            while (length != -1) {
                output.write(buffer, 0, length);
                length = bis.read(buffer);
            }
            output.flush();
        } catch (Exception e) {
        } finally {
            try {
                bis.close();
                fos.close();
                output.close();
            } catch (IOException e0) {
            }
        }
    }

    /**
     * 标识包长度的4byte转成int数字
     */
    public static int bytes2int(byte[] bytes) {
        Assert.isTrue(bytes.length == 4, "只支持byte[]长度为4的转换");
        String picLenStr1 = HexUtil.encodeHexStr(bytes);
        String newPicLenStr1 = picLenStr1.substring(6, 8) + picLenStr1.substring(4, 6)
                + picLenStr1.substring(2, 4) + picLenStr1.substring(0, 2);
        return Integer.parseInt(newPicLenStr1, 16);
    }

    /**
     * 标识包长度的int数字转成4byte
     */
    public static byte[] int2bytes(int len) {
        String hexString = Integer.toHexString(len);
        int length = 8-hexString.length();
        for (int i = 0; i < length; i++) {
            hexString = "0" + hexString;
        }
        String newPicLenStr1 = hexString.substring(6, 8) + hexString.substring(4, 6)
                + hexString.substring(2, 4) + hexString.substring(0, 2);
        return HexUtil.decodeHex(newPicLenStr1);
    }

    /**
     * 标识包长度的int数字转成16进制字符串
     */
    public static String int2HexString(int len) {
        String hexString = Integer.toHexString(len);
        int length = 8-hexString.length();
        for (int i = 0; i < length; i++) {
            hexString = "0" + hexString;
        }
        return hexString.substring(6, 8) + hexString.substring(4, 6)
                + hexString.substring(2, 4) + hexString.substring(0, 2);
    }

    /**
     * 16进制字符串转成int数字
     */
    public static int hexString2Int(String hex) {
        String s = hex.substring(6, 8) + hex.substring(4, 6)
                + hex.substring(2, 4) + hex.substring(0, 2);
        return Integer.parseInt(s, 16);
    }

    public static void main(String[] args) {
//        System.out.println(convertStringToHex("{\"RequstId\":\"0\",\"AlarmId\":\"B16ACC7E-4AB6-4DBF-A245-9A54AEECFEBB\",\"FormatType\":1,\"PushNotice\":false}"));
        //System.out.println(Integer.toHexString(111));
        //System.out.println(hexStringToString("7B22557365724964223A31303033357D"));
        //File file = new File("C:\\Users\\xuhj\\Desktop\\新建文本文档.txt");
        //byteToFile(parseHexStr2Byte(txt2String(file).trim()), "C:\\Users\\xuhj\\Desktop\\1.mp4");
        int i = Integer.parseInt("4FD5B651", 16);
        System.out.println(i);
        String s = Integer.toHexString(15);
        System.out.println(s);
//        byte[] bytes = int2bytes(1098674434);
//        int i = bytes2int(bytes);
//        System.out.println(i);
    }
}

package com.demo.socket.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableId;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * <p>
 * 
 * </p>
 *
 * @author xuhj
 * @since 2021-05-09
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value="Response对象", description="")
public class Response implements Serializable {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "序号")
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    @ApiModelProperty(value = "命令id")
    private String orderId;

    @ApiModelProperty(value = "命令码")
    private String orderCode;

    @ApiModelProperty(value = "响应json")
    private String json;

    @ApiModelProperty(value = "响应时间")
    private Date responseTime;

    @ApiModelProperty(value = "状态0前端未获取1已获取")
    private Integer status;

    @ApiModelProperty(value = "报警id")
    private String alarmId;

    @ApiModelProperty(value = "分段id")
    private Integer partNo;
}

package com.demo.socket.socketplus;

/**
 * 请求标识16进制字符串（命令ID）
 */
public interface Remark {

    /**
     * 自定义-登录命令ID
     */
    String LOGIN_COMMAND_ID = "01 00 00 00".replaceAll(" ", "");

    /**
     * 登录命令CODE
     */
    String LOGIN_COMMAND_CODE = "01 00".replaceAll(" ", "");

    /**
     * 推送视频摘要或报警CODE
     */
    String PUSH_VIDEO_SUMMARY_OR_ALARM_CODE = "05 00".replaceAll(" ", "");

    /**
     * 自定义-请求录像传送计划ID
     */
    String REQUEST_VIDEO_TRANSMISSION_PLAN_COMMAND_ID = "01 00 00 01".replaceAll(" ", "");

    /**
     * 请求录像传送计划CODE
     */
    String REQUEST_VIDEO_TRANSMISSION_PLAN_COMMAND_CODE = "06 00".replaceAll(" ", "");

    /**
     * 请求录像片段CODE
     */
    String REQUEST_VIDEO_PART_COMMAND_CODE = "07 00".replaceAll(" ", "");

    /**
     * 请求录像传送计划下载完成CODE
     */
    String REQUEST_VIDEO_TRANSMISSION_PLAN_FINISH_COMMAND_CODE = "27 00".replaceAll(" ", "");
    /**
     * 自定义-请求录像片段ID
     */
    String REQUEST_VIDEO_CLIP_COMMAND_ID = "01 00 00 10".replaceAll(" ", "");
    /**
     * 请求录像片段CODE
     */
    String REQUEST_VIDEO_CLIP_COMMAND_CODE = "07 00".replaceAll(" ", "");

}

package com.demo.socket.service;

import com.demo.socket.entity.Response;
import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.core.metadata.IPage;

import java.util.List;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author xuhj
 * @since 2021-05-09
 */
public interface IResponseService extends IService<Response> {

    /**
     * 查询分页数据
     *
     * @param page      页码
     * @param pageCount 每页条数
     * @return IPage<Response>
     */
    IPage<Response> findListByPage(Integer page, Integer pageCount);

    Response query(String orderId);

    List<Response> findByAlarmId(String alarmId);

    List<Response> findByCodeAndAlarmId(String orderCode, String alarmId);

    /**
     * 添加
     *
     * @param response 
     * @return int
     */
    int add(Response response);

    /**
     * 删除
     *
     * @param id 主键
     * @return int
     */
    int delete(Integer id);

    /**
     * 修改
     *
     * @param response 
     * @return int
     */
    int updateData(Response response);

    /**
     * id查询数据
     *
     * @param id id
     * @return Response
     */
    Response findById(Integer id);
}

文子阳
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
工作在传输层的协议：TCP与UDP
愿你成为自己喜欢的模样，不抱怨，不将就，有自由，有光芒！
10-23 1391
传输层协议介绍 TCP和UDP协议 TCP/IP协议族的传输层协议 TCP（Transmission Control Protocol）传输控制协议 UDP（User Datagram Protocol）用户数据报协议 TCP协议 TCP是面向连接的，可靠的进程到进程通信的协议TCP提供全双工服务，即数据可在同一时间双向传输，每一个TCP都有发送缓存和接收缓存，用来临时存储数据。 UDP协议 UDP协议是无连接，不保证可靠性的传输层协议。发送端不关心发送的数据是否到达目标...
Netty实战-如何在web项目中对接第三方tcp协议
qq_35488769的博客
04-24 1449
公司有一个专门用于对接第三方停车，crm，erp等等业务系统的项目由我负责，十几个场子全都是基于Http实现的，突然有一天实施告诉我有一个基于TCP协议实现的停车系统要接入。坦白讲，最开始我是拒绝的，因为我很难接受要引入一个这么难以维护，并且很大程度上会破坏原有系统边界的玩意，架不住人家就是强势，我就是不换车厂，你爱接不接，没办法，只能硬着头皮想办法上 1.坑爹的需求 停车这玩意跟crm，erp还...
6-TCP 协议（序号和确认号）
进击的小学生
04-05 3万+
转载请注明出处：http://blog.csdn.net/q1007729991/article/details/69261780接下来的内容是学习后续内容的基础，必须先讲清楚。为了方便你回忆 TCP 首部，这里再次把这个图贴出来，以便对照。 图1 TCP 首部 1. 序号序号占用 4 字节，即 32 位。它的范围是 [0,232−1][0, 2^{32}-1]，也就是说一共有 4 294
＜网络＞TCP代码协议编写
weixin_63246064的博客
07-08 1127
这篇文章我们就主要实现一下如何使用TCP进行完整的网络通信首先我们需要了解什么事TCP，TCP是一种传输控制协议，我们暂且先记住这个。现在我们先开始，第一呢，我们要实现客户端和服务端的网络通信，两个不同的主机之间通信是通过什么？答案是每台主机的网络IP，在我们的电脑进行上网的时候，会自动给我们的电脑分配一个该局域网内的IP。好的，现在我们的两台主机相互的找到了对方，然后再看看我们要做的是什么，两台主机之间的通信对不对！
对接优某康tcp接口
bianfu2008zhi的专栏
06-22 335
项目需要对接视频接口，某康提供的是tcp接口，负责人想着把数据保存在本地落库，方便以后的统计。这事就落到了我头上，我选netty。 开始东抄西抄，终于拼了一个不成样子的东西。很多地方返回不对。 开始找支持，同事A总共帮着解决了3个大问题。 1、登录后，发送心跳返回结果不对 BufByte 写完就清空了，导致心跳不对。 2、心跳正常后，发现netty阻塞了restful请求。 开启子线程，解决了线程阻塞 3、tcp返回的包，分多次返回，网上说的粘包和拆包 使用分隔符的Handle解决。 这3
tio.rar_tio_tio聊天
09-21
6． 实现一个一对一的聊天程序。其基本过程如下：服务器首先启动，创建套接字后等待客户的连接；客户启动以后，创建套接字，然后和服务器建立连接；连接建立后，客户机和服务器可以通过建立的套接字连接进行通信。...
tio源码分析业务流程中的UML图形
08-18
2. **类图（Class Diagram）**：TIO框架的核心类如`TioServer`、`TcpAcceptor`和`TcpClient`等，可以通过类图进行展现。类图不仅揭示了类的属性和方法，还表达了类之间的关系，如继承、关联、依赖等。理解这些类的...
tio代码的相关demo运用。（包含服务端和客户端）
05-13
【tio代码的相关demo运用（包含服务端和客户端）】 t-io是一个高性能、异步事件驱动的网络通信框架，主要用于构建TCP服务器。它基于Java NIO，并提供了丰富的API和工具，便于开发者快速开发网络应用。这个资源包含...
基于tio-websocket的高级特性设计源码
最新发布
04-09
本资源提供了一套基于tio-websocket的高级特性设计源码，这是t-io官方提供的唯一tio-websocket示范教程。项目包含11个Java源文件、6个JavaScript文件、4个HTML文件、3个Java Preferences文件、3个Batch文件、3个XML...
tio-protobuf:原虫
05-26
简介本压缩包是一个maven工程, eclipse/idea均可按maven项目导入MainLauncher是入口,启动即可环境要求必须JDK8+eclipse或idea等IDE开发工具,可选配置信息位置数据库配置信息,jetty端口等配置信息,均位于src/main/...
ByteBuffer：网络编程必须要学会的数据结构
裸睡的鱼
04-29 324
引言 ByteBuffer是nio/aio编程所必须掌握的一个数据结构，也是掌握tio所必须要学会的基础知识。 设想你不懂Map，不懂List，不懂Set，那么你在编程领域将会一事无成，同样的道理，如果你不懂ByteBuffer，你无法在nio/aio编程领域立足 初识ByteBuffer 我们可以把bytebuffer理解成如下几个属性组成的一个数据结构 byte[] b...
php workerman对接云快充tcp协议
itholiday2014的博客
08-15 1549
workerman对接tcp协议
TCP网络通信协议
zwb_19970712的博客
07-14 98
1.构造代码块在构造方法前执行，.java文件编译后，会将构造代码块的内容放到构造方法的前面。 2.静态代码块，无论放在什么位置，只执行一次，在构造方法之前执行。 UDP：数据报文协议 将数据及源和目的封装成数据包中，不需要建立连接 每个数据报的大小在限制在64k内 因无连接，是不可靠协议，有差错 速度快 TCP：传输控制协议 建立连接，形成传输数据的通道，可传输大量数据 通过三次握手完成连接，可靠 必须建立连接，所以效率低 Socket就是为网络服务提供的一种机制。 通信的两端都有Socket。 网络通信
Java对接TCP接口--数据报文通信
aiguoguo000的博客
09-06 817
第一次整这东西，感谢大佬: 参考:https://www.cnblogs.com/liudalei/p/11942464.html?ivk_sa=1024320u
t-io初学
u012118123的博客
06-21 7685
1、t-io是神马？       t-io是一个网络框架，从这一点来说是有点像 netty 的，但 t-io 为常见和网络相关的业务（如 IM、消息推送、RPC、监控）提供了近乎于现成的解决方案，即丰富的编程 API，极大减少业务层的编程难度。2、怎么用？分为服务端和客户端，先看服务端！① maven引入依赖&lt;dependency&gt; &lt;groupId&gt;org.t-...
【tio-core】1、tio-study是学习t-io的第一步
热门推荐
Asurplus
10-22 20万+
网络编程很苦，用 t-io 后会很甜，tio-study 是学习 t-io 的第一步
前端性能分析探索-天眼浏览器监控
weixin_40926179的博客
03-20 1212
一、概述 天眼是中国联通IT生产运营支撑平台，对生产运营领域提供端到端、云化架构全层级的运维工具支撑，融合人工智能与大数据技术，实现传统运维向自动化生产、智慧化运营的转变，保障4亿级用户规模系统稳定运行，支撑一体化生产运营体系落地，支持“平台+应用”模式，聚焦集约、赋能省分，助力中国联通IT运营全面数字化转型。 天眼浏览器监控是为解决对一线业务受理情况掌握不足，故障感知和响应滞后的问题，采用JS埋点的方式，采集用户访问过程的性能指标，通过对Ajax请求诊断和页面加载过程的深度挖掘，实现对用户体验的实时跟
tcp协议案例
neutron129的博客
04-24 564
tcp协议理解       需要建立客户端（Socket）和服务器端（ServerSockt）。建立连接后，通过socket中io流进行数据传输。       package com.neutron.network.tcp.demo; import java.io.IOException; import java.io.OutputStream; import java.net.Sock
2022.9.07 客户端与服务端TCP方式通信创建步骤，TCP协议实现客户端与服务端的通信的源代码。
weixin_72076304的博客
09-07 1171
客户端与服务端TCP方式通信创建步骤；TCP协议实现客户端与服务端的通信的源代码；
tio encode decode Handler
07-28
tio encode decode Handler是指在tio框架中用于处理编码和解码的处理器。根据引用\[2\]中的代码，可以看出bytes2int函数是将4个字节的byte数组转换为int类型的数字。这个函数的作用是将标识包长度的4个字节按照一定的规则进行转换，得到对应的int数字。这个函数在tio框架中可能用于处理包长度的解析。而引用\[1\]中的代码是在Android应用中增加联网权限的声明，这可能与tio框架中的网络通信有关。引用\[3\]中的依赖是指在项目中引入tio-core库的版本信息。综上所述，tio encode decode Handler是在tio框架中用于处理编码和解码的处理器，其中bytes2int函数可能用于解析包长度，而引用\[1\]中的代码和引用\[3\]中的依赖可能与tio框架的网络通信相关。 #### 引用[.reference_title] - *1* [【安卓-tio】安卓集成t-io](https://blog.csdn.net/gwcgwcjava/article/details/120777186)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [tio对接天眼tcp协议记录](https://blog.csdn.net/wenxingchen/article/details/120021999)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

文子阳

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值