java udp丢包重发_UDPDataPacker_Java数据报之失序和丢包
Java数据报之失序和丢包
习惯了TCP编程,认为UDP可以包办这些问题是错误的。一个UDP应用程序要承担可靠性方面的全部工作,包括报文的丢失、重复、时延、乱序以及连接失效等问题。
通常我们在可靠性好,传输时延小的局域网上开发测试,一些问题不容易暴露,但在大型互联网上却会出现错误。
UDP协议把递送的可靠性责任推到了上层即应用层,下面简单编写了几个类来专门处理两个问题:乱序和丢包。
四个类:DataPacket 类,PacketHeader类,PacketBody类
,DataEntry类,位于同一个文件DataPacket .java中。
DataPacket 类相当于一个门面模式,提供给外部使用,通信数据也在这个类中处理。
package com.skysoft.pcks;
import java.io.*;
import java.net.*;
import java.util.*;
public class DataPacket {
InputStream is;
OutputStream os;
PacketHeader header;
PacketBody body;
ArrayList al;
public static final int DataSwapSize =
64532;
public DataPacket() {
header = new
PacketHeader();
body = new
PacketBody();
al = new
ArrayList();
}
public DataPacket(String file) {
this();
try {
is =
new FileInputStream(file);
header.CalcHeaderInfo(is.available());
this.madeBody();
is.close();
//this.Gereratedata();
}
catch
(FileNotFoundException ex) {
ex.printStackTrace();
}
catch (IOException ex1)
{
ex1.printStackTrace();
}
}
public DataPacket(URL url) {
this();
try {
//is
= url.openStream();
URLConnection conn=url.openConnection();
is=conn.getInputStream();
int
total=conn.getContentLength();
header.CalcHeaderInfo(total);
this.madeBody();
//System.out.println(total+":"+total);
is.close();
}
catch (IOException ex)
{
ex.printStackTrace();
}
}
private void madeBody() {
al.clear();
byte[] buffer;
DataEntry de;
for (int i = 0; i
< header.fragmentcounter; i++) {
try
{
ByteArrayOutputStream bos = new
ByteArrayOutputStream();
//is.skip(i * body.BODY_BUFFER_SIZE);
header.ArrageSort(i);
de = new
DataEntry(PacketBody.BODY_BUFFER_SIZE);
de.setSn(i);
de.setStreamsize(header.getStreamsize());
de.setFragmentcounter(header.getFragmentcounter());
if (header.isWTailFragment(i)) {
buffer = new
byte[header.getMinfragment()];
is.read(buffer, 0,
buffer.length);
header.setActByteSize(header.getMinfragment());
de.setActByteSize(header.getMinfragment());
}
else {
buffer = new
byte[body.BODY_BUFFER_SIZE];
is.read(buffer, 0,
buffer.length);
}
//System.out.println("length-------"+i+"
"+body.getBody().length+" "+header.getMinfragment());
body.setBody(buffer);
//System.out.println("length:" + i + " " +
header.toString());
bos.write(header.getByte(), 0,
header.HEADER_BUFFER_SIZE);
bos.write(body.getBody(), 0,
body.getBody().length);
de.setBytes(bos.toByteArray());
al.add(de);
}
catch
(IOException ex) {
ex.printStackTrace();
}
}
}
private void madeBody1() {
al.clear();
for (int i = 0; i
< header.fragmentcounter; i++) {
try
{
if (header.isWTailFragment(i))
is.read(body.getBody(), i *
body.BODY_BUFFER_SIZE,
header.getMinfragment());
else
is.read(body.getBody(), i *
body.BODY_BUFFER_SIZE,
body.BODY_BUFFER_SIZE);
ByteArrayOutputStream bos = new
ByteArrayOutputStream();
bos.write(header.getByte(), 0,
header.HEADER_BUFFER_SIZE);
bos.write(body.getBody(),
header.HEADER_BUFFER_SIZE,
body.getBody().length);
al.add(bos);
}
catch
(IOException ex) {
ex.printStackTrace();
}
}
}
public void Add(byte[] b1) {
byte[] buffer = (byte[])
b1.clone();
handlerText(buffer);
DataEntry de = new
DataEntry(buffer, header.getActByteSize());
de.setSn(header.getSn());
de.setStreamsize(header.getStreamsize());
de.setFragmentcounter(header.getFragmentcounter());
al.add(de);
}
private void handlerText(byte[] buffer)
{
ByteArrayOutputStream
baos = new ByteArrayOutputStream();
baos.write(buffer, 0,
header.HEADER_BUFFER_SIZE);
byte[] b=new
byte[header.HEADER_BUFFER_SIZE];
System.arraycopy(buffer,0,b,0,b.length);
ByteArrayInputStream
bais = new ByteArrayInputStream(baos.toByteArray());
InputStreamReader isr =
new InputStreamReader(bais);
BufferedReader br = new
BufferedReader(isr);
try {
header = new PacketHeader(br.readLine());
}
catch (Exception ex)
{
ex.printStackTrace();
}
}
private String calFileSize(int size)
{
return size / 1024 +
"K";
}
public ArrayList getDataPackets() {
return al;
}
public boolean isFull() {
return
this.header.getSn() == this.header.getFragmentcounter() - 1 ? true
: false;
}
public boolean isZero() {
return
this.header.getSn() == 0 ? true : false;
}
private ByteArrayOutputStream
fetchDataPackets() {
ByteArrayOutputStream
bos = new ByteArrayOutputStream();
byte[] buffer =
null;
DataEntry de;
for (int i = 0; i
< al.size(); i++) {
try
{
de = this.getSnData(i);
buffer = de.getByte();
if (header.getStreamsize() ==
de.getStreamsize()) {
bos.write(de.getByte(),
header.HEADER_BUFFER_SIZE, de.getActByteSize());
System.out.println(de.toString() + " -- fetchDataPackets");
}
}
catch
(Exception ex) {
ex.printStackTrace();
}
}
return bos;
}
private ByteArrayOutputStream
fetchDataPackets_sn() {
ByteArrayOutputStream
bos = new ByteArrayOutputStream();
byte[] buffer;
DataEntry de;
for (int i = 0; i
< header.getFragmentcounter(); i++) {
try
{
de = this.getSnData(i);
if (de == null) {
de = seachDeData(i);
}
buffer = de.getByte();
//System.out.println(de.getSn() + ":" +
i);
//handlerText(buffer);
//bos.write(buffer,
header.HEADER_BUFFER_SIZE,
// buffer.length - header.HEADER_BUFFER_SIZE);
if (header.getStreamsize() ==
de.getStreamsize()) {
bos.write(de.getByte(),
header.HEADER_BUFFER_SIZE,
de.getActByteSize());
//System.out.println(de.toString());
}
}
catch
(Exception ex) {
ex.printStackTrace();
}
}
return bos;
}
private DataEntry getSnData(int sn) {
DataEntry de =
null;
for (int i = 0; i
< al.size(); i++) {
de =
(DataEntry) al.get(i);
if
(header.getStreamsize() == de.getStreamsize()) {
if (sn == de.getSn())
break;
else
de = null;
}
}
return de;
}
private DataEntry seachDeData(int sn)
{
DataEntry de =
null;
int initvalue, minvalue
= 10000;
DataEntry back, fore =
null;
for (int i = 0; i
< al.size(); i++) {
de =
(DataEntry) al.get(i);
if
(header.getStreamsize() == de.getStreamsize()) {
initvalue = Math.abs(de.getSn() - sn);
if (de.getFragmentcounter() != de.getSn()
&& initvalue <
minvalue) {
minvalue = initvalue;
fore = de;
}
}
}
return fore;
}
private DataEntry seachDeData() {
DataEntry de =
null;
for (int i = 0; i
< al.size(); i++) {
de =
(DataEntry) al.get(i);
System.out.println("sky ::::" + de.getFragmentcounter() + ":" +
de.getSn() +
":" + i);
if
(header.getStreamsize() == de.getStreamsize()) {
if (de.getFragmentcounter() != de.getSn())
{
break;
}
}
}
return de;
}
public java.awt.Image Gereratedata()
{
ByteArrayInputStream bis;
java.awt.image.BufferedImage bimage = null;
try
{
byte[] b =
fetchDataPackets_sn().toByteArray();
//fetchDataPackets_old1()
bis = new ByteArrayInputStream(b);
bimage = javax.imageio.ImageIO.read(bis);
}
catch
(Exception ex1) {
ex1.printStackTrace();
}
return
bimage;
}
public static void main(String args[])
{
DataPacket dp = new
DataPacket("e:\\nature\\14.jpg");
}
}
class DataEntry {
byte[] bytes;
int fragmentcounter, sn, actbytesize;
long streamsize;
int minfragment;
public DataEntry() {
}
public DataEntry(int size) {
this.actbytesize =
size;
}
public DataEntry(byte[] b, int i) {
this.bytes = b;
this.actbytesize =
i;
}
public byte[] getByte() {
return this.bytes;
}
public void setBytes(byte[] b) {
this.bytes = b;
}
public void setStreamsize(long size)
{
this.streamsize =
size;
}
public long getStreamsize() {
return
this.streamsize;
}
public int getMinfragment() {
return
minfragment;
}
public synchronized void setSn(int i)
{
this.sn = i;
}
public synchronized int getSn() {
return sn;
}
public synchronized int
getFragmentcounter() {
return
fragmentcounter;
}
public synchronized void
setFragmentcounter(int c) {
this.fragmentcounter =
c;
}
public void setActByteSize(int size)
{
actbytesize =
size;
}
public int getActByteSize() {
return
actbytesize;
}
public String toString() {
return this.streamsize +
"::" + this.fragmentcounter + "::" + this.sn +
"::" + this.actbytesize + " recv
DataEntry";
}
}
class PacketHeader implements Serializable{
public static final int HEADER_BUFFER_SIZE
= 1024;
int fragmentcounter, sn;
int actbytesize =
PacketBody.BODY_BUFFER_SIZE;
byte[] header; //= new
byte[HEADER_BUFFER_SIZE];
long streamsize;
int minfragment;
public PacketHeader() {
}
public PacketHeader(long l) {
this.setStreamsize(l);
}
public PacketHeader(String s) {
String[] tm =
s.split("::");
this.setActByteSize(Integer.parseInt(tm[3]));
this.setSn(Integer.parseInt(tm[2]));
this.setFragmentcounter(Integer.parseInt(tm[1]));
this.setStreamsize(Long.parseLong(tm[0]));
}
public void ArrageSort(int sn) {
this.setSn(sn);
this.setByte();
}
public void CalcHeaderInfo(long l) {
this.setStreamsize(l);
CalcHeaderInfo();
}
public void CalcHeaderInfo() {
fragmentcounter =
Math.round( (float) streamsize /
PacketBody.BODY_BUFFER_SIZE);
float critical = (float)
streamsize / PacketBody.BODY_BUFFER_SIZE;
if (critical -
fragmentcounter < 0.5
&& critical - fragmentcounter
> 0)
fragmentcounter++;
minfragment = (int)
(streamsize % PacketBody.BODY_BUFFER_SIZE);
}
public byte[] getHeader() {
Long it = new
Long(this.streamsize);
return new byte[]
{it.byteValue()};
}
public byte[] getByte() {
return header;
//this.toString().getBytes();
}
public void setByte() {
ByteArrayOutputStream
bos = new ByteArrayOutputStream();
byte[] buffer =
this.toByte();
try {
bos.write(buffer);
bos.write("\r\n".getBytes());
bos.write(new byte[PacketHeader.HEADER_BUFFER_SIZE -
buffer.length], 0,
PacketHeader.HEADER_BUFFER_SIZE - buffer.length);
header = bos.toByteArray();
}
catch (IOException ex)
{
ex.printStackTrace();
}
}
public void setStreamsize(long size)
{
this.streamsize =
size;
}
public long getStreamsize() {
return
this.streamsize;
}
public int getMinfragment() {
return
minfragment;
}
public synchronized void setSn(int i)
{
this.sn = i;
}
public int getSn() {
return sn;
}
public int getFragmentcounter() {
return
fragmentcounter;
}
public synchronized void
setFragmentcounter(int c) {
this.fragmentcounter =
c;
}
public void setActByteSize(int size)
{
actbytesize =
size;
setByte();
}
public int getActByteSize() {
return
actbytesize;
}
public String toString() {
return streamsize + "::"
+ this.fragmentcounter + "::" + this.getSn() +
"::" + this.getActByteSize();
}
public byte[] toByte() {
return
this.toString().getBytes();
}
public boolean isWTailFragment(int i)
{
return (i ==
fragmentcounter - 1) ? true : false;
}
}
class PacketBody implements Serializable{
public static final int BODY_BUFFER_SIZE =
63508; //65508
byte[] body;
public PacketBody() {
}
public void setBody(byte[] b) {
this.body = b;
}
public byte[] getBody() {
return body;
}
}
java udp丢包重发_UDPDataPacker_Java数据报之失序和丢包相关推荐
- java 丢包_Java数据报之失序和丢包
习惯了TCP编程,认为UDP可以包办这些问题是错误的.一个UDP应用程序要承担可靠性方面的全部工作,包括报文的丢失.重复.时延.乱序以及连接失效等问题. 通常我们在可靠性好,传输时延小的局域网上开发测 ...
- java从电脑接收数据丢失_网络编程:Java数据报之失序和丢包Java -电脑资料
习惯了TCP编程,认为UDP可以包办这些问题是错误的, 习惯了TCP编程,认为UDP可以包办这些问题是错误的.一个UDP应用程序要承担可靠性方面的全部工作,包括报文的丢失.重复.时延.乱序以及连接失效 ...
- FEC(Forward Error Correction)前向纠错 UDP\RTP 中使用用于改善无线等网络丢包等问题--转...
FEC(Forward Error Correction)前向纠错 UDP\RTP 中使用用于改善无线等网络丢包等问题 算法暂不介绍. 思路:FEC ENCODE 增加冗余包,当无线等网络丢包之后,接 ...
- java udp包_基于UDP协议的数据包收发程序(代码+报告)Java
[实例简介] 设计要求: 1)按照UDP协议数据包发送方式实现用户端之间的通信. 2)统计包的发送和接收数,计算数据包的丢失数. 3)设计美观易用的图形界面. [实例截图] [核心代码] 基于UDP协 ...
- java udp心跳机制,Socket心跳包机制总结
跳包之所以叫心跳包是因为:它像心跳一样每隔固定时间发一次,以此来告诉服务器,这个客户端还活着.事实上这是为了保持长连接,至于这个包的内容,是没有什么特别规定的,不过一般都是很小的包,或者只包含包头的一 ...
- 自定义Udp/Tcp协议,通信协议Socket/WebSocket,IM粘包、分包解决等(2),ProtocolBuffer
> 自定义Udp/Tcp协议/通信协议(Java/C):自定义构建和解析IM协议消息:IM自定义UDP通信协议 类似于网络通信中的TCPIP协议一般,比较可靠的通信协议往往包含有以下几个组成 ...
- JAVA UDP网络编程学习笔记
一.UDP网络编程概述 采用TCP协议通信时,客户端的Socket必须先与服务器建立连接,连接建立成功后,服务器端也会持有客户端连接的Socket,客户端的Socket与服务器端的Socket是对应的 ...
- Java抓包分析四(基于jnetpcap进行抓包)——分析Http请求数据包
在上篇文章中Java抓包分析三(基于jnetpcap进行抓包)--抓取Http请求数据包,我们讲解了TCP三次握手的过程和如何抓取Http数据包,但是我们并没有进行一个数据分析,接下来这篇文章我们将要 ...
- Java UDP Server的轻量级实现
Java UDP Server的轻量级实现 实现方法 接收线程:只处理收包,收完后之后放入工作线程 发送线程:负责发送udp包到其它的server 工作线程:解析包体,实现业务逻辑 工作线程消息处理: ...
最新文章
- c3p0 数据库连接池
- java中正则全局匹配_JS中正则表达式全局匹配模式/g用法实例
- c语言获取当前日期和时间
- 封装不同类模板的随机数生成器
- Leetcode贪心 验证回文字符串
- Oracle入门(十二E)之视图操作
- Redis 缓存 Key
- (bfs)连连看(hdu1175)
- 更改VS2010,VS2008,VS2012等指定默认浏览器操作方式
- Python3入门机器学习经典算法与应用 第3章 Jupyter Notebook基本用法 学习笔记
- SCSA网络安全----信息安全概述
- STL格式抽壳补孔洞破面修复等,Magics视频教程
- 您该选择PRINCE2 还是 PMP认证
- python机器学习 | 朴素贝叶斯算法介绍及实现
- 【LeetCode每日一题】——LCP 44.开幕式焰火
- 怎么做照片拼图?这几个方法挺靠谱
- 【Java】多人协同在线编辑Excel源代码及部署包
- [git] fatal: Exiting because of an unresolved conflict.
- matlab 的谱相减语音增强算法的研究,基于MATLAB的谱相减语音增强算法的研究
- JavaScript——实现九九乘法表
热门文章
- Python 数据结构与算法——快排
- hive 操作(四)
- 从排列与组合的python实现到生日问题的解释
- 移动端调取摄像头上面如何给出框_智能AI助力家居安防,创维小湃高清智能摄像头...
- 2021湖南永州四中高考成绩查询,2021湖南高中排名一览表 最新排名
- python怎么读写文件-一文看懂Python文件的读取写入操作,建议收藏-bak文件怎么打开...
- python培训价目表-python培训班费用在多少?
- python是干什么用的-使用Python究竟可以做什么?下面是Python的3个主要应用
- python语言-Python语言介绍
- python自动化办公要学多久-基于python实现自动化办公学习笔记