netty 809协议

最新推荐文章于 2024-08-15 09:36:27 发布
最新推荐文章于 2024-08-15 09:36:27 发布
阅读量644 收藏
点赞数
分类专栏： Netty 文章标签： 网络 服务器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiamaocheng/article/details/131972258
版权
该文章详细介绍了Netty809协议的解码过程，包括接收到数据包后如何进行16进制转换、数据转义、数据校验以及数据解析。在服务端，数据包首先被转换成16进制，然后进行转义处理，接着检查数据包的有效性并进行解析。代码示例展示了如何处理接收到的ByteBuf数据，并进行解码操作。
摘要由CSDN通过智能技术生成

netty 809协议

Survive by day and develop by night.
talk for import biz , show your perfect code,full busy，skip hardness,make a better result,wait for change,challenge Survive.
happy for hardess to solve denpendies.

目录

在这里插入图片描述

概述

netty 809协议

需求：

netty 809协议

设计思路

实现思路分析

1.netty 809 协议

2.概念

1.先一个数据头，

消息体内容是： 对应的byte 位的了。

我们来看一下message 包体的内容。看下是如何组件的？

组装的时候套上对应的数据头，数据体，CRC，报文头尾等。
在这里组装对应的信息，配置上对应的报文头，数据体，CRC，报文尾就可以发送了。

内部传输的是十六进制2二进制数据。

判断的时候是根据十六进制判断。

转成2进制，对byte 位进行判断。 打包发送。

这个vo 貌似就没有用到。
将重要信息转成二进制数据即可。
组装这个messsageBody.会将vo 去掉。

这是因为java中的byte是有符号位的byte，
这点和c++不一样，因此可表示的数据为-127~127（最高位为符号位）。
知道了原因，剩下的就是问题的解决了。

服务端：
1.服务端接收以后，在计算机中bytes 传送的，首先将接收到数据包转成对应的16进制，
2.检测是有否转义含义
3.最后解析部分数据：

代码

package cn.com.onlinetool.jt809.decoder;


import cn.com.onlinetool.jt809.constants.JT809MessageConstants;
import cn.com.onlinetool.jt809.decoderDemo.JT809Packet0x1202Decoder;
import cn.com.onlinetool.jt809.util.ByteArrayUtil;
import cn.com.onlinetool.jt809.util.PacketUtil;
import cn.com.onlinetool.jt809.util.ParseUtil;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.internal.StringUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;

/**
 * @author choice
 * @description: 消息解码
 * @date 2018-12-27 14:39
 */
@Slf4j
@Service
public class Byte2MessageDecoder {
    private static Map<String, byte[]> cache = new HashMap<String, byte[]>();

    public void decode(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        String channelKey = ctx.channel().remoteAddress().toString();

        //判断是否有可读的字节
        if (msg.readableBytes() <= 0) {
            return;
        }

        //读取缓冲区数据
        byte[] readDatas = new byte[msg.readableBytes()];
        msg.readBytes(readDatas);
        log.info("接收到数据包, packetLen : {}, packet : {}", readDatas.length, ByteArrayUtil.bytes2HexStr(readDatas));

        //拼接缓存数据
        byte[] cacheDatas = cache.get(channelKey);
        if (null != cacheDatas) {
            readDatas = ByteArrayUtil.append(cacheDatas, readDatas);
            cache.remove(channelKey);
            log.info("拼接后的数据包：{}", ByteArrayUtil.bytes2HexStr(readDatas));
        }

        //校验数据头
//        if (!PacketUtil.checkHeadFlag(readDatas)) {
//            //防止极端情况，请求头校验不通过的情况 丢掉本包数据 同时 丢掉上一包缓存的剩余数据
//            //防止上一包剩余数据不包含数据起始符 会导致拼接后的数据包一直校验不通过
//            cache.remove(channelKey);
//            log.warn("数据包标识符验证失败 : {}", ByteArrayUtil.bytes2HexStr(readDatas));
//            return;
//        }

        //数据转义
        String dataStr = ByteArrayUtil.bytes2FullHexStr(readDatas);
        dataStr = dataStr.replaceAll("0x5a0x01", "0x5b");
        dataStr = dataStr.replaceAll("0x5a0x02", "0x5a");
        dataStr = dataStr.replaceAll("0x5e0x01", "0x5d");
        dataStr = dataStr.replaceAll("0x5e0x02", "0x5e");
        readDatas = ByteArrayUtil.fullHexStr2Bytes(dataStr);
        log.info("转义后的数据包：{}", ByteArrayUtil.bytes2HexStr(readDatas));

        //如果数据小于一整包数据的最小长度
//        if (readDatas.length < JT809MessageConstants.MSG_MIN_LEN) {
//            log.warn("数据长度小于整包数据最小长度，缓存数据：{}", ByteArrayUtil.bytes2HexStr(readDatas));
//            cache.put(channelKey, readDatas);
//            return;
//        }
//
//        //判断是否有完整数据包，没有直接缓存
//        int packetLen = PacketUtil.getPacketLen(readDatas);
//        if (readDatas.length < packetLen) {
//            log.warn("数据长度小于整包数据长度，缓存数据：{}", ByteArrayUtil.bytes2HexStr(readDatas));
//            cache.put(channelKey, readDatas);
//            return;
//        }

        //解析数据
        this.parseAndPushData(ctx, channelKey, 0, readDatas);

    }


    /**
     * 解析并返回数据
     *
     * @param channelKey
     * @param readDatas
     */
    private void parseAndPushData(ChannelHandlerContext ctx, String channelKey, int index, byte[] readDatas) throws Exception {

        byte[] data = ByteArrayUtil.subBytes(readDatas, index, readDatas.length - index);

//        //整包长度
//        int packetLen = PacketUtil.getPacketLen(data);
//        index += packetLen;
//
//        //一个完整包
//        byte[] fullPacket = ByteArrayUtil.subBytes(data, 0, packetLen);
//        log.info("拆包后的单包数据 --> fullPacket : {}", ByteArrayUtil.bytes2HexStr(fullPacket));

        log.info("拆包后的单包数据 --> fullPacket : {}", ByteArrayUtil.bytes2HexStr(data));

//        //验证数据包有效性
//        if (!PacketUtil.checkPacket(fullPacket)) {
//            cache.remove(channelKey);
//            log.info("数据校验失败 --> fullPacket : {}", ByteArrayUtil.bytes2HexStr(fullPacket));
//            return;
//        }
//        ctx.fireChannelRead(PacketUtil.bytes2Message(fullPacket));
//
//        //剩余长度
//        int remainingLen = data.length - packetLen;

        //没有数据，结束
//        if (remainingLen < 1) {
//            return;
//        }
//
//        //剩余数据长度小于一包数据的最小长度，缓存数据
//        if (remainingLen < JT809MessageConstants.MSG_MIN_LEN) {
//            log.warn("剩余数据长度小于整包数据最小长度，缓存数据：{}", ByteArrayUtil.bytes2HexStr(ByteArrayUtil.subBytes(data, data.length - remainingLen, remainingLen)));
//            cache.put(channelKey, ByteArrayUtil.subBytes(data, data.length - remainingLen, remainingLen));
//            return;
//        }
//
//        //下一包数据的总长度
//        packetLen = PacketUtil.getPacketLen(ByteArrayUtil.subBytes(data,data.length - remainingLen, remainingLen));
//        //剩余数据长度小于整包数据长度
//        if (remainingLen < packetLen) {
//            log.warn("剩余数据长度小于整包数据长度，缓存数据：{}", ByteArrayUtil.bytes2HexStr(ByteArrayUtil.subBytes(data, data.length - remainingLen, remainingLen)));
//            cache.put(channelKey, ByteArrayUtil.subBytes(data, data.length - remainingLen, remainingLen));
//            return;
//        }

        //还有完整数据包 递归调用
//        this.parseAndPushData(ctx, channelKey, index, readDatas);


        JT809Packet0x1202Decoder jt809Packet0x1202Decoder=new JT809Packet0x1202Decoder();
        jt809Packet0x1202Decoder.decoder(data);
//        parsePkt(data);



    }

    private void parsePkt(byte[] data) {
        // begin 这里提供方法可供入库使用，根据不同的业务进行字段分段截取.默认解析字段分别是业务字段的含义字段

        String parseData = ByteArrayUtil.bytes2HexStr(data);

        //比如这里增加子业务类型的字段数据：
        if(StringUtil.isNullOrEmpty(parseData)){
             log.info("数据为空");
             return;
        }else {
            //数据头
            String  head = parseData.substring(0, 2); //--头标识
            String  datalength=parseData.substring(2,10);//--数据头->数据长度
            String  dataSeqNo=parseData.substring(10,18);// --数据头->报文序列号
            String  bizdata=parseData.substring(18,22);// --数据头->业务数据类型
            String  code=parseData.substring(22,30); //--数据头->下级平台接入码，上级平台给下级平台分配唯一标识码
            String version=parseData.substring(30,36); //--数据头->协议版本号标识
            String entryFlag=parseData.substring(36,38);//--数据头->报文加密标识位
            String key=parseData.substring(38,46);//--数据头->数据加密的密匙

            //数据体
//            String chepaiHao=parseData.substring(46,50);// --数据体->车牌号
//            String color=parseData.substring(50,52); // --数据体->车辆颜色   //这2者没有
            String biz =parseData.substring(46,50); //--数据体->子业务类型标识
            String lastlength=parseData.substring(50,58);//--数据体->后续数据长度，这里的确是24 位 ，数据长度24位

            //子数据体
            String subData=parseData.substring(58,82); //参看4.5.8.1 车辆定位信息数据体

            //3.CRC
            String crc=parseData.substring(82,86);  //这个每次都变化的
            String tail=parseData.substring(86,88);





            //2.业务数据体这里调用Parse方法，可以封装对应的实体bean,供入库用，提供int ,varchar,time 三种格式进行
//            log.info("总长度是：{}"+subData);









        }


        //end
    }
}

解包代码：

package cn.com.onlinetool.jt809.decoderDemo;


import cn.com.onlinetool.jt809.jt.Decoder;
import io.netty.buffer.ByteBuf;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.Charset;
import java.time.LocalDate;
import java.time.LocalTime;



/**
 * @Author: Xiuming Lee
 * @Date: 2019/9/23 15:21
 * @Version 1.0
 * @Describe:
 */
public class JT809Packet0x1202Decoder {
    private static Logger log = LoggerFactory.getLogger(JT809Packet0x1202Decoder.class);

    public JT809BasePacket decoder(byte[] bytes) throws Exception {
        JT809Packet0x1202 jt809Packet0x1202 = new JT809Packet0x1202();
        ByteBuf byteBuf = PacketDecoderUtils.baseDecoder(bytes, jt809Packet0x1202);
        packetDecoder(byteBuf,jt809Packet0x1202);
        return jt809Packet0x1202;
    }

    private void packetDecoder(ByteBuf byteBuf, JT809Packet0x1202 packet) throws Exception{
        ByteBuf msgBodyBuf = null;
        if (packet.getEncryptFlag() == Const.EncryptFlag.NO) {
            msgBodyBuf = PacketDecoderUtils.getMsgBodyBuf(byteBuf);
        } else {

            msgBodyBuf = null;
            return;
        }
        // 车牌号
        byte [] vehicleNoBytes = new byte[21];
        msgBodyBuf.readBytes(vehicleNoBytes);
        packet.setVehicleNo(new String(vehicleNoBytes, Charset.forName("utf-8")));
        // 车辆颜色
        packet.setVehicleColor(msgBodyBuf.readByte());
        // 子业务类型标识
        packet.setDataType(msgBodyBuf.readShort());
        // 如果不是定位的数据，抛出空指针错误,解码适配器会对空指针错误做处理。
//        if (packet.getDataType() != Const.SubBusinessDataType.UP_EXG_MSG_REAL_LOCATION ) {
//            throw new NullPointerException();
//        }
        // 后续数据长度
        packet.setDataLength(msgBodyBuf.readInt());



        // 经纬度信息是否按国标进行加密
        packet.setExcrypt(msgBodyBuf.readByte());
        if (packet.getExcrypt() == Const.EncryptFlag.YES ){

        }
        // 跳过时间
//        msgBodyBuf.skipBytes(7);
        int day = Byte.toUnsignedInt(msgBodyBuf.readByte());
        int month = Byte.toUnsignedInt(msgBodyBuf.readByte());
//        packet.setDate(LocalDate.of(msgBodyBuf.readShort(),month,day));
//        packet.setTime(LocalTime.of(Byte.toUnsignedInt(msgBodyBuf.readByte()),Byte.toUnsignedInt(msgBodyBuf.readByte()),Byte.toUnsignedInt(msgBodyBuf.readByte())));
        // 经纬度
        packet.setLon(msgBodyBuf.readInt());
        packet.setLat(msgBodyBuf.readInt());
        // 速度
        packet.setVec1(msgBodyBuf.readShort());
        // 行驶记录速度
        packet.setVec2(msgBodyBuf.readShort());
        // 车辆当前总里程数
//        packet.setVec3(msgBodyBuf.readInt());
//        // 方向
//        packet.setDirection(msgBodyBuf.readShort());
//        // 海拔
//        packet.setAltitude(msgBodyBuf.readShort());
//        // 车辆状态
//        packet.setState(msgBodyBuf.readInt());
//        // 报警状态
//        packet.setAlarm(msgBodyBuf.readInt());
    }



}

参考资料和推荐阅读

  1. 暂无

欢迎阅读，各位老铁，如果对你有帮助，点个赞加个关注呗！同时，期望各位大佬的批评指正~

执于代码
关注
专栏目录
netty发送809协议，登录，gps实时定位
qq_30495285的博客
09-09 2371
java交通809协议登录，gps定位发送，使用大端字节传输 数据结构类 Message.java import io.netty.buffer.ByteBuf; import java.io.Serializable; import java.util.Arrays; public class Message implements Serializable { privat...
trafficdataserver:基于Netty4的JT809协议（上级平台解析下级平台上传的车辆定位数据）
05-14
trafficdataserver 基于Netty4的JT809协议（上级平台解析下级平台上传的车辆定位数据）
轨迹系列7——Socket总结及实现基于TCP或UDP的809协议方法
weixin_34177064的博客
07-06 189
文章版权由作者李晓晖和博客园共有，若转载请于明显处标明出处：http://www.cnblogs.com/naaoveGIS/ 1.背景 在上一篇博客中我详细介绍了809协议的内容。809协议规范了通信的报文，通信的规则等，但是并没限制通信使用的传输协议。这里，我将分别介绍利用TCP和UDP传输协议来实现的809协议对接的方法。 2.TCP和UDP的介绍 TCP协议和UDP协议均是面向传输层的一种...
809协议-帧解析
09-26
关于809协议的帧解析，详细解析了809中各数据帧，格式统一，易懂
推荐一款实用的JT/T809-2011协议开源项目：jt809-tcp-server
最新发布
gitblog_00663的博客
08-15 910
推荐一款实用的JT/T809-2011协议开源项目：jt809-tcp-server jt809-tcp-server项目地址:https://gitcode.com/gh_mirrors/jt/jt809-tcp-server 在道路交通安全领域，JT/T809协议扮演着至关重要的角色，它规范了道路运输车辆卫星定位系统的数据交换。而现在，我们有幸向您推荐一款基于该协议的开源项目——jt809-...
809 协议相关
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
07-26 837
809 协议。
809协议
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
07-31 474
链路连接请求包：由下级平台向上级平台发起的链路连接请求，包含平台鉴权码、IP地址、端口号等信息。链路连接应答包：上级平台对下级平台发起的链路连接请求的回复，包含链路状态、鉴权结果等信息。链路断开通知包：链路异常中断时，上下级平台之间发送的链路断开通知，包含断开原因等信息。心跳包：用于保持链路的有效性，上下级平台之间定时发送的心跳包，包含链路状态信息。鉴权包：用于验证平台身份，下级平台向上级平台发起鉴权请求，上级平台回复鉴权结果。
交通部809协议源码（java开发，基于apache-mina框架）
10-06
交通部809协议源码（java开发，基于apache-mina框架）。未全部实现功能，仅实现server端主链路，从链路未做，默认链路不加密，可满足常规接入实时车辆GPS定位等功能，需实现更多业务逻辑请自行丰富MsgCallBack类。 分享出来主要就是看不惯太多做这个还收费的（收费就算了，有些还骗人，自己也不是大拿，如果有BUG可以反馈给我，我尽力改）。自己赚点积分下载其他资源用，实在没积分下载的可以留言邮箱，博主不定时发邮件。
数据传输-交通部链路809协议
01-16
这是一个交通部链路协议的文档，是基于netty传输车辆数据和平台数据的一些规范
Netty UDP协议网络打洞实例
07-17
Netty UDP协议网络打洞实例是利用Netty框架在UDP（User Datagram Protocol）协议基础上实现的一种穿透NAT（Network Address Translation）的技术。NAT技术在现代互联网中广泛使用，它允许内部网络中的设备共享一个...
交通部809协议2016版
12-22
本文档为交通部809协议2016版，为平台之间对接车辆定位数据的协议文档。网上的交通部809协议积分太贵了，故上传一下，为积分少的用户提供便利。
交通部809协议数据包分析
06-13
809协议数据包分析，包含了位置信息，数据包头解析，对照解析编码，如果数据包和我这里的对不上，就要您仔细研究协议。
809协议数据流
09-26
对809协议中的各个消息进行了数据流整理，画出了809协议的通信流程，用visio可打开
部标809协议协议组包实现
11-25
部标809协议协议组包实现
JT809-Server_809协议_
10-02
部标809协议，服务端对接代码，可以对接gps信息
netty服务器解析16进制数据
08-23
Netty 是一个高性能、异步...通过上述步骤，Netty服务器可以轻松地解析16进制数据，从而支持各种网络协议，无论它们是以16进制还是其他形式表示。理解和掌握这些概念和实践技巧对于构建高效、可靠的网络应用至关重要。
使用netty3建立的JT809处理基本工程
08-16
本项目专注于使用Netty 3来构建一个处理JT809协议的基础工程。JT809是一种广泛应用于中国交通监控系统的通信协议，主要用于车辆监控、定位以及数据交换。 首先，我们要理解Netty 3的核心概念。Netty 3基于非阻塞I/O...
基于809协议的netty服务端与客户端之间的连接的问题记录
GinChou的萌新博客
01-16 3784
工作上有转发程序，从一个客户端发送数据到转发程序再发送到另一个服务端。整个传输协议是基于交通部809协议要求的。 809协议文档：（https://download.csdn.net/download/qq_28198181/10920681） 目录 问题1：怎么关闭链路 问题2：当链路无故关闭，怎么重连 问题3：关于主从链路之间的链路保持请求 遇到的主要问题如下： 问题1：怎么关闭...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

执于代码

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

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

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

打赏作者

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

抵扣说明：

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

余额充值