java之tcp拆包代码

最新推荐文章于 2023-06-13 09:32:14 发布
最新推荐文章于 2023-06-13 09:32:14 发布
阅读量344 收藏 1
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40351360/article/details/127710377
版权

背景

对tcp传输的数据按结尾字符*进行拆包，实际传输的内容是json格式的数据。包括测试代码，如果有错误，敬请指出，谢谢！

代码

package com.example.demo;

import com.alibaba.fastjson.JSONObject;
import com.ctc.wstx.util.StringUtil;
import org.springframework.util.StringUtils;

import java.util.UUID;

/**
 * tcp拆包
 *

 * @date 2021/9/3 11:08
 */
public class aa {
    private static String prefix = "";

    public static void main(String[] args) {
        String aa[] = new String[5];
        //1.测试数据不完整的情况，但是开头是完整的
        aa[0] = "{\"aabbcc\":\"1001\"}*{\"aabbcc\":\"1\"}*{\"clien";
        aa[1] = "tId\":\"1\"}*{\"move\":0,\"aa\":0,\"s\":0,\"bb\":0,\"id\":10,\"p\":10,\"t\":7,\"h\":70,\"lic_pressure\":0,\"timestamp\":1635325129}*";
        aa[2] = "tId\":\"1\"}*{\"move\":0,\"aa\":0,\"s\":0,\"bb\":0,\"id\":10,\"p\":10,\"t\":7,\"h\":70,\"lic_pressure\":0,\"timestamp\":1635325129}*";
        aa[3] = "{\"move\":0,\"aa\":0,\"s\":0,\"bb\":0,\"id\":10,\"p\":10,\"t\":7,\"h\":70,\"lic_pressure\":0,\"timestamp\":1635325129}*{\"move\":0,\"aa\":0,\"s\":0,\"bb\":0,\"id\":10,\"p\":10,\"t\":7,\"h\":70,\"lic";
        aa[4] = "_pressure\":0,\"timestamp\":1635325129}*{\"move\":0,\"aa\":0,\"s\":0,\"bb\":0,\"id\":10,\"p\":10,\"t\":7,\"h\":70,\"lic_pressure\":0,\"timestamp\":1635325129}*{\"aabbcc\"";
        System.out.println("=================情况1=================");
        System.out.println("预计丢失数据=================【tId\":\"1\"}】");
        test(aa);
        //2.测试数据开头不完整，需要丢掉
        aa[0] = "{\"aabbcc\":\"1*{\"aabbcc\":\"1001\"}*{\"aabbcc\":\"1\"}*{\"clien";
        aa[1] = "{\"aabbcc\":\"1001\"}*{\"aabbcc\":\"1\"}*{\"clien";
        aa[2] = "tId\":\"1\"}*{\"move\":0,\"aa\":0,\"s\":0,\"bb\":0,\"id\":10,\"p\":10,\"t\":7,\"h\":70,\"lic_pressure\":0,\"timestamp\":1635325129}*";
        aa[3] = "{\"move\":0,\"aa\":0,\"s\":0,\"bb\":0,\"id\":10,\"p\":10,\"t\":7,\"h\":70,\"lic_pressure\":0,\"timestamp\":1635325129}*{\"move\":0,\"aa\":0,\"s\":0,\"bb\":0,\"id\":10,\"p\":10,\"t\":7,\"h\":70,\"lic";
        aa[4] = "_pressure\":0,\"timestamp\":1635325129}*{\"move\":0,\"aa\":0,\"s\":0,\"bb\":0,\"id\":10,\"p\":10,\"t\":7,\"h\":70,\"lic_pressure\":0,\"timestamp\":1635325129}*{\"aabbcc\"";
        System.out.println("=================情况2=================");
        System.out.println("预计丢失数据=================【{\"aabbcc\"{\"aabbcc\":\"1】");
        test(aa);
        //3.测试完整数据
        aa[0] = "{\"aabbcc\":\"1\"}*";
        aa[1] = "{\"aabbcc\":\"1\"}*";
        aa[2] = "{\"aabbcc\":\"1\"}*";
        aa[3] = "{\"aabbcc\":\"1\"}*";
        aa[4] = "{\"aabbcc\":\"1\"}*";
        System.out.println("=================情况3=================");
        test(aa);
        //4.测试完整数据多条
        aa[0] = "{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*";
        aa[1] = "{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*";
        aa[2] = "{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*";
        aa[3] = "{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*";
        aa[4] = "{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*{\"aabbcc\":\"1\"}*";
        System.out.println("=================情况4=================");
        test(aa);


    }

    private static void test(String[] aa) {
        int a = 1;
        for (String json : aa) {
            System.out.println("第" + a + "次数据!!");
            if ("".equals(json) || json == null) {
                return;
            }
            if ("".equals(prefix)) {
                String val[] = json.split("\\*");
                if (val[val.length - 1] != "" && val[val.length - 1] != null && !((val[val.length - 1].startsWith("{") && val[val.length - 1].endsWith("}")) || (val[val.length - 1].startsWith("[") && val[val.length - 1].endsWith("]")))) {
                    prefix = val[val.length - 1];
                    for (int i = 0; i < val.length - 1; i++) {
                        String arr = val[i];
                        if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                            System.out.println("接收数据：" + arr);
                        } else {

                            System.out.println("错误数据丢掉1：" + arr);
                        }
                    }
                } else {
                    for (String arr : val) {
                        if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                            //第一个数据完整
                            System.out.println("接收数据：" + arr);
                        } else {
                            System.out.println("错误数据丢掉2：" + arr);
                        }
                    }

                }

            } else {
                String value = prefix + json;
                String oldPrefix = prefix;
                prefix = "";

                String val[] = value.split("\\*");
                if (val[val.length - 1] != "" && val[val.length - 1] != null && !((val[val.length - 1].startsWith("{") && val[val.length - 1].endsWith("}")) || (val[val.length - 1].startsWith("[") && val[val.length - 1].endsWith("]")))) {
                    prefix = val[val.length - 1];
                    for (int i = 0; i < val.length - 1; i++) {
                        String arr = val[i];
                        if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                            try {
                                JSONObject.parseObject(arr);
                                System.out.println("接收数据：" + arr);
                            } catch (Exception e) {
                                arr = arr.substring(oldPrefix.length());
                                if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                                    System.out.println("接收数据：" + arr);
                                    System.out.println("错误数据丢掉3：" + oldPrefix);
                                } else {
                                    System.out.println("错误数据丢掉4：" + oldPrefix + arr);
                                }
                            }

                        } else {
                            try {
                                JSONObject.parseObject(arr);
                                System.out.println("接收数据：" + arr);
                            } catch (Exception e) {
                                arr = arr.substring(oldPrefix.length());
                                if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                                    System.out.println("接收数据：" + arr);
                                    System.out.println("错误数据丢掉10：" + oldPrefix);
                                } else {
                                    System.out.println("错误数据丢掉11：" + oldPrefix + arr);
                                }
                            }
                        }
                    }
                } else {
                    for (String arr : val) {
                        if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                            //第一个数据完整
                            if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                                try {
                                    JSONObject.parseObject(arr);
                                    System.out.println("接收数据：" + arr);
                                } catch (Exception e) {
                                    arr = arr.substring(oldPrefix.length());
                                    if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                                        System.out.println("接收数据：" + arr);
                                        System.out.println("错误数据丢掉6：" + oldPrefix);
                                    } else {
                                        System.out.println("错误数据丢掉7：" + oldPrefix + arr);
                                    }
                                }
                            } else {
                                System.out.println("错误数据丢掉8：" + oldPrefix + arr);
                            }
                        } else {
                            System.out.println("错误数据丢掉9：" + oldPrefix + arr);

                        }
                    }

                }
            }
            a++;
        }
        System.out.println("当前prefix值：" + prefix);
    }

    private static void unpack(String json) {
        if ("".equals(json) || json == null) {
            return;
        }
        if ("".equals(prefix)) {
            String val[] = json.split("\\*");
            if (val[val.length - 1] != "" && val[val.length - 1] != null && !((val[val.length - 1].startsWith("{") && val[val.length - 1].endsWith("}")) || (val[val.length - 1].startsWith("[") && val[val.length - 1].endsWith("]")))) {
                prefix = val[val.length - 1];
                for (int i = 0; i < val.length - 1; i++) {
                    String arr = val[i];
                    if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                        System.out.println("接收数据：" + arr);
                    } else {

                        System.out.println("错误数据丢掉1：" + arr);
                    }
                }
            } else {
                for (String arr : val) {
                    if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                        //第一个数据完整
                        System.out.println("接收数据：" + arr);
                    } else {
                        System.out.println("错误数据丢掉2：" + arr);
                    }
                }

            }

        } else {
            String value = prefix + json;
            String oldPrefix = prefix;
            prefix = "";

            String val[] = value.split("\\*");
            if (val[val.length - 1] != "" && val[val.length - 1] != null && !((val[val.length - 1].startsWith("{") && val[val.length - 1].endsWith("}")) || (val[val.length - 1].startsWith("[") && val[val.length - 1].endsWith("]")))) {
                prefix = val[val.length - 1];
                for (int i = 0; i < val.length - 1; i++) {
                    String arr = val[i];
                    if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                        try {
                            JSONObject.parseObject(arr);
                            System.out.println("接收数据：" + arr);
                        } catch (Exception e) {
                            arr = arr.substring(oldPrefix.length());
                            if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                                System.out.println("接收数据：" + arr);
                                System.out.println("错误数据丢掉3：" + oldPrefix);
                            } else {
                                System.out.println("错误数据丢掉4：" + oldPrefix + arr);
                            }
                        }

                    } else {
                        try {
                            JSONObject.parseObject(arr);
                            System.out.println("接收数据：" + arr);
                        } catch (Exception e) {
                            arr = arr.substring(oldPrefix.length());
                            if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                                System.out.println("接收数据：" + arr);
                                System.out.println("错误数据丢掉10：" + oldPrefix);
                            } else {
                                System.out.println("错误数据丢掉11：" + oldPrefix + arr);
                            }
                        }
                    }
                }
            } else {
                for (String arr : val) {
                    if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                        //第一个数据完整
                        if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                            try {
                                JSONObject.parseObject(arr);
                                System.out.println("接收数据：" + arr);
                            } catch (Exception e) {
                                arr = arr.substring(oldPrefix.length());
                                if ((arr.startsWith("{") && arr.endsWith("}")) || (arr.startsWith("[") && arr.endsWith("]"))) {
                                    System.out.println("接收数据：" + arr);
                                    System.out.println("错误数据丢掉6：" + oldPrefix);
                                } else {
                                    System.out.println("错误数据丢掉7：" + oldPrefix + arr);
                                }
                            }
                        } else {
                            System.out.println("错误数据丢掉8：" + oldPrefix + arr);
                        }
                    } else {
                        System.out.println("错误数据丢掉9：" + oldPrefix + arr);

                    }
                }

            }
        }
        System.out.println("当前prefix值：" + prefix);
    }


}
itxiaoxd2020
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用Netty解决TCP粘包和拆包问题过程详解
08-25
主要介绍了使用Netty解决TCP粘包和拆包问题过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
JSON在JAVA客户端和服务端传输
03-18
JSON在JAVA客户端和服务端传输，很详细，不清楚可以咨询
Java Socket TCP以字节数组方式，分片传输文件
沐浴阳光的小小少年
06-13 1120
思路：本端将大文件切片，并将文件名称、分片、文件大小、文件MD5、分片内容等信息，封装成一个对象，将对象转为字节数组，以字节流传输到对端；对端接收到字节数组后，转转为对象，再交给业务层处理数据；需求：两端以TCP方式建立连接，分片传输文件；接收线程：ReceiveTcpThread。
java基于TCP的socket数据包拆分方法
MOOR212的专栏
11-02 935
java基于TCP的socket数据包拆分方法 发表于129 天前 ⁄ Java ⁄ 评论数4 ⁄ 被围观 916次+ 关键字：java socket tcp 分包 粘包 好了，现在轻松许多。话说看到falcom官方的《空轨》动画时间表，又看到崩坏的人设，我表示真的非常不能接受。当然了这个咱也管不着。 好了话归正题，前不久写的socket程序，服务器是java的，客户端是flex。...
[Java网络编程基础]TCP发送和接收数据
m0_51955470的博客
06-09 83
代码如下: package ClientPack; import java.io.IOException; import java.io.OutputStream; import java.net.InetAddress; import java.net.Socket; import java.net.UnknownHostException; public class ClientDemo { public static void main(String[] args) throws IOE.
Java网络编程（7） - 什么是TCP粘包、拆包和解决？什么Netty编解码技术？主流的序列化框架有哪些？Netty的JBOSS的Marshalling详解案例？
Su_Levi_Wei的博客
06-13 363
TCP粘包、拆包问题 熟悉TCP编程的可能都知道，无论是服务端还是客户端，当进行数据读取或者发送数据的时候，都需要考虑TCP底层的粘包和拆包机制的问题。 TCP是一个流协议，流是没有界限的数据，是连成一片的，没有分界线。TCP底层并不理解上层的业务数据具体的含义，它会根据TCP缓冲区的实际情况进行包的划分，也就是说，在业务上，一个完整的包可能会被TCP分成多个包进行发送，也可能把多个小包封装成一个大的数据包发送出去，这就是所谓的TCP粘包、拆包问题。 TCP粘包和拆包 -...
netty消息拆包粘包编解码(java代码)
最新发布
10-22
在TCP协议中，由于数据的无边界特性，可能会出现“粘包”和“拆包”的问题。这两个概念在处理网络通信时至关重要，下面将详细解释它们，并提供相关的Java代码示例。 1. **粘包**：在TCP传输中，如果发送方连续发送...
基于javatcpsocket通信的拆包和装包源码-NettyTree:网状树
06-06
TCP粘包、拆包 2）编解码技术 1）Java序列化 2）业界主流的编解码框架 Thrift Protobuf 3) Websocket 5）Netty协议栈功能设计 6）Netty源码分析 ByteBuf工作原理 Channel, Unsafe ChannelPipline, ChannelHandler ...
基于javatcpsocket通信的拆包和装包源码-java-:Java-
06-06
tcp socket通信的拆包和装包源码 java总结 五片内存：寄存器，本地方法区，方法去，堆，栈 堆：数组，对象，也就是封装好的实体 栈：局部变量,堆得变量都有默认初始化 构造代码块：所有的对象进行初始化，所有的对象...
拆包粘包解决之道
07-18
在计算机网络编程中，"拆包"（Unpacking）与"粘包...在给定的文件"未考虑拆包粘包.zip"和"添加拆包粘包.zip"中，可能包含了关于如何处理拆包粘包问题的代码示例或文档，你可以解压学习，以便更好地理解和实践这些概念。
基于javatcpsocket通信的拆包和装包源码-interview:一些网络知识
06-06
基于java tcp socket通信的拆包和装包源码 TCP、UDP的区别 TCP面向连接,UDP是无连接的，即发送数据之前不需要建立连接 TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保证可靠交付 TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的，UDP没有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低 每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信 TCP首部开销20字节;UDP的首部开销小，只有8个字节 TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道 TCP协议如何保证可靠传输 TCP通过序列号、检验和、确认应答信号、重发控制、连接管理、窗口控制、流量控制、拥塞控制实现可靠性 应用数据被分割成 TCP 认为最适合发送的数据块。 TCP 给发送的每一个包进行编号，接收方对数据包进行排序，把有序数据传送给应用层。 校验和：TCP 将保持它首部和数据的检验和。这是一个端到端的检验和，目的是检测数据在传输过程中的任何变化。如
基于javatcpsocket通信的拆包和装包源码-distributed:分散式
06-06
基于java tcp socket通信的拆包和装包源码 分布式架构概述 大数据：数据分析 用户行为 兴趣爱好 活动运营用户画像 1、分布式 （任务分解、节点通信） 一个业务拆分成多个子系统，部署在不同的服务器上（相互调用）。 去IOE IBM小型机 、 Oracle Rac、 EMC存储设备 PC mysql maria db 2013年5月17号，最后一台IMB小型机下线 单机计算机的架构->分布式计算机架构 2、集群 同一个业务，部署在多个服务器上。高可用。 3、大型网站 访问量（tps每秒传输的事物处理个数、qps每秒查询率） 数据量（存储数据量） 4、读写分离 5、搜索引擎 6、缓存、限流、降级、分库、表拆分（500w~1000w） 7、解决session跨域 cookie 存sessionid，服务端Tomcat用ConcuurentMap存储 session sticky （请求落在同一个服务器上） session replication （复制） session 集中存储 db、缓存服务器 cookie （主流）保存在客户端 access token（userid/tok
基于javatcpsocket通信的拆包和装包源码-kcp:cp
06-06
基于java tcp socket通信的拆包和装包源码 KCP - A Fast and Reliable ARQ Protocol 简介 KCP是一个快速可靠协议，能以比 TCP浪费10%-20%的带宽的代价，换取平均延迟降低 30%-40%，且最大延迟降低三倍的传输效果。纯算法实现，并不负责底层协议（如UDP）的收发，需要使用者自己定义下层数据包的发送方式，以 callback的方式提供给 KCP。 连时钟都需要外部传递进来，内部不会有任何一次系统调用。 整个协议只有 ikcp.h, ikcp.c两个源文件，可以方便的集成到用户自己的协议栈中。也许你实现了一个P2P，或者某个基于 UDP的协议，而缺乏一套完善的ARQ可靠协议实现，那么简单的拷贝这两个文件到现有项目中，稍微编写两行代码，即可使用。 技术特性 TCP是为流量设计的（每秒内可以传输多少KB的数据），讲究的是充分利用带宽。而 KCP是为流速设计的（单个数据包从一端发送到一端需要多少时间），以10%-20%带宽浪费的代价换取了比 TCP快30%-40%的传输速度。TCP信道是一条流速很慢，但每秒流量很大的大运河，而KCP是水
[初级]JAVA中TCP/HTTP协议JSON数据的封装~三分钟看懂
qq_39724355的博客
08-31 2048
在日常的网络编程中，我们可以常见基础TCP/HTTP协议的一些数据的传输请求(Http协议是建立在Tcp协议基础之上的)，不过本篇文章不注重讲解网络编程部分，而是为大家提供一些封装JSON数据以用于发送的方法。TCP协议下的Json数据传输用的不是很多，日常大部分使用的还是HTTP协议下的，但是Json数据封装无非这两种格式，本文章是从便于理解的角度出发，措辞不严谨之处敬请见谅，如有错误欢迎指正。...
java 解析数据包_java - 如何在Java中正确解析TCP数据包？ - 堆栈内存溢出
weixin_27027459的博客
02-12 1568
我目前有一个简单的TCP服务器，该服务器调用一个函数，并在每个新的传入数据包上以字节数组的形式将二进制TCP有效负载传递给它，解析它的正确方法是什么？我试图通过将其切成不同的字节数组并分别进行处理来尝试执行此操作，但是我的数据包中包含一个可变长度的数据类型，无法将其与其他数据分开。 看来这不是我应该做的，而且我认为有更好的方法来做readVarInt()是一个函数，用于分析可变长度数据类型并返回...
TCP粘包|拆包和解决方案
爪哇人的博客
02-27 951
客户端发送5个Message对象，客户端每次发送一个message对象，服务器端就会每次接受一个message，分5次进行解码，每次读取到一个message，会回复一个message对象给客户端。收发两端（客户端和服务端）都要有一一成对的socket，因此，发送端为了将多个发给接收端的包，更有效的发给对方，使用了优化算法（），将许多数据量小且间隔小的数据，合并成了一个大数据块，然后进行封包，这样做虽然提升了效率，但是接收端就难于分辨出完成的数据包，因此。客户端向服务端发送10条消息，看服务端如何接受。
笔记1：一个Java传输数据(json)的简单例子
predfox的专栏
07-23 1747
用Java编写的一个简单的监听、调用小程序
【TCP】TCP 分包拆包代码
bandaoyu的note
04-06 868
void SockBox::AddBox(const char* data, const size_t size) { if (data) { m_data.SetDataSize(m_sizeBuf + size); memcpy(m_data.GetData() + m_sizeBuf, data, size); m_sizeBuf += size; } if (m_sizeBuf ...
使用JAVA 编写TCP协议分析代码
06-02
好的，下面是一个使用Java编写的TCP协议分析代码示例，仅供参考： ```java import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; public class ProtocolAnalyzerClient { public static void main(String[] args) throws IOException { String hostName = "localhost"; int portNumber = 12345; try ( Socket socket = new Socket(hostName, portNumber); OutputStream out = socket.getOutputStream(); InputStream in = socket.getInputStream(); ) { // 发送数据包 String command = "GET"; String arg1 = "/index.html"; String arg2 = "HTTP/1.1"; String data = command + "," + arg1 + "," + arg2 + "\n"; out.write(data.getBytes()); // 接收响应数据包 byte[] buffer = new byte[1024]; int bytesRead = in.read(buffer); if (bytesRead > 0) { String response = new String(buffer, 0, bytesRead); // 解析响应数据包 System.out.println("Response: " + response); } } catch (IOException e) { System.out.println("Exception caught when trying to connect to server " + hostName + " on port " + portNumber); System.out.println(e.getMessage()); } } } ``` 此示例代码假设客户端将每个数据包作为以逗号分隔的字符串发送，并且每个数据包包含三个字段：命令、参数1和参数2。在主函数中，程序创建了一个Socket对象，并将其连接到指定的主机和端口号。然后，程序使用OutputStream来发送数据包，并使用InputStream来接收响应数据包。在发送数据包时，程序将数据包的三个字段作为字符串连接并写入OutputStream。在接收响应数据包时，程序读取InputStream中的字节，并将其转换为字符串。然后，程序解析响应数据包中的数据，并将其打印到控制台上。 当然，这只是一个简单的示例，实际的TCP协议分析器需要更多的代码来处理复杂的数据包、错误处理等问题。但是，这个示例可以帮助您了解如何使用Java编写TCP协议分析代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值