java与网络（UDP）

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量137 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beeworkshop/article/details/103426621
版权
1. UDP收发的基本操作

数据报的大小限制在64K之内。

  • 报文的接收
System.out.println("接收方启动中.....");
// 1、使用DatagramSocket  指定端口 创建接收端
DatagramSocket server =new DatagramSocket(6666); //服务器端侦听的端口
// 2、准备容器 封装成DatagramPacket 包裹
byte[] container =new byte[1024*60];
DatagramPacket packet = new DatagramPacket(container,0,container.length);
// 3、阻塞式接收包裹receive​(DatagramPacket p)
server.receive(packet); //阻塞式
// 4、分析数据
//    byte[]  getData​()
//                getLength​()
 byte[]  datas =packet.getData();
 int len = packet.getLength();
 System.out.println(new String(datas,0,len));
 
// 5、释放资源
 server.close();
  • 报文的发送
System.out.println("发送方启动中.....");
 // 1、使用DatagramSocket  指定端口 创建发送端
DatagramSocket client =new DatagramSocket(8888); //发送端的源端口
 //2、准备数据 一定转成字节数组
String data = "黑夜给了我黑色的眼睛";
byte[] datas = data.getBytes("UTF8"); 
 //3、 封装成DatagramPacket 包裹，需要指定目的地
DatagramPacket packet =new DatagramPacket(datas,0,datas.length,
		new InetSocketAddress("localhost",6666)); //发送端的目的地址和端口号
//4、发送包裹send​(DatagramPacket p) * 
client.send(packet);
// 5、释放资源
client.close();
  • 如何在eclipse中开启多个console窗口

    拖动调整Console窗口的位置，然后钉住

    选择console控制台窗口
2. UDP收发基本数据类型
  • 报文的接收
System.out.println("接收方启动中.....");
// 1、使用DatagramSocket  指定端口 创建接收端
DatagramSocket server =new DatagramSocket(6666);
// 2、准备容器 封装成DatagramPacket 包裹
byte[] container =new byte[1024*60];
DatagramPacket packet = new DatagramPacket(container,0,container.length);
// 3、阻塞式接收包裹receive​(DatagramPacket p)
server.receive(packet); //阻塞式
// 4、分析数据    将字节数组还原为对应的类型
//    byte[]  getData​()
//                getLength​()
 byte[]  datas =packet.getData();
 int len = packet.getLength();		 
DataInputStream dis =new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(datas)));
//顺序与写出一致
String msg = dis.readUTF(); 
int age = dis.readInt();
boolean flag = dis.readBoolean();
char ch = dis.readChar();
System.out.println(msg+"-->"+flag);
// 5、释放资源
server.close();
  • 报文的发送
System.out.println("发送方启动中.....");
 // 1、使用DatagramSocket  指定端口 创建发送端
DatagramSocket client =new DatagramSocket(8888);
 //2、准备数据 一定转成字节数组
//写出
ByteArrayOutputStream baos =new ByteArrayOutputStream();
DataOutputStream dos =new DataOutputStream(new BufferedOutputStream(baos));
//操作数据类型 +数据
dos.writeUTF("编码辛酸泪");
dos.writeInt(18);
dos.writeBoolean(false);
dos.writeChar('a');
dos.flush();
byte[] datas =baos.toByteArray();	
 //3、 封装成DatagramPacket 包裹，需要指定目的地
DatagramPacket packet =new DatagramPacket(datas,0,datas.length,
		new InetSocketAddress("localhost",6666));
//4、发送包裹send​(DatagramPacket p) * 
client.send(packet);
// 5、释放资源
client.close();
3. UDP收发对象
  • 报文的接收
System.out.println("接收方启动中.....");
// 1、使用DatagramSocket  指定端口 创建接收端
DatagramSocket server =new DatagramSocket(6666);
// 2、准备容器 封装成DatagramPacket 包裹
byte[] container =new byte[1024*60];
DatagramPacket packet = new DatagramPacket(container,0,container.length);
// 3、阻塞式接收包裹receive​(DatagramPacket p)
server.receive(packet); //阻塞式
// 4、分析数据    将字节数组还原为对应的类型
 byte[]  datas =packet.getData();
 int len = packet.getLength();		 
//读取 -->反序列化
ObjectInputStream ois =new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(datas)));
//顺序与写出一致，对象的数据还原
Object str = ois.readObject();
Object date = ois.readObject();
Object employee = ois.readObject();

if(str instanceof String) {
	String strObj = (String) str;
	System.out.println(strObj);
}
if(date instanceof Date) {
	Date dateObj = (Date) date;
	System.out.println(dateObj);
}
if(employee instanceof Employee) {
	Employee empObj = (Employee) employee;
	System.out.println(empObj.getName()+"-->"+empObj.getSalary());
}
// 5、释放资源
 server.close();
  • 报文的发送
System.out.println("发送方启动中.....");
 // 1、使用DatagramSocket  指定端口 创建发送端
DatagramSocket client =new DatagramSocket(8888);
 //2、准备数据 一定转成字节数组
//写出
ByteArrayOutputStream baos =new ByteArrayOutputStream();
ObjectOutputStream oos =new ObjectOutputStream(new BufferedOutputStream(baos));
//对象
oos.writeObject("我却用它来寻找光明");
oos.writeObject(new Date());
Employee emp =new Employee("欧阳克",400);
oos.writeObject(emp);
oos.flush();
byte[] datas =baos.toByteArray();	

 //3、 封装成DatagramPacket 包裹，需要指定目的地
DatagramPacket packet =new DatagramPacket(datas,0,datas.length,
		new InetSocketAddress("localhost",6666));
//4、发送包裹
client.send(packet);
// 5、释放资源
client.close();
4. 传输文件（小文件）
  • 工具类
public class IOUtils {
	/**
	 * 1、图片读取到字节数组
	 * 1)、图片到程序  FileInputStream
	 * 2)、程序到字节数组	ByteArrayOutputStream
	 */
	public static byte[] fileToByteArray(String filePath) {
		//1、创建源与目的地
		File src = new File(filePath);
		byte[] dest =null;
		//2、选择流
		InputStream  is =null;
		ByteArrayOutputStream baos =null;
		try {
			is =new FileInputStream(src);
			baos = new ByteArrayOutputStream();
			//3、操作 (分段读取)
			byte[] flush = new byte[1024*10]; //缓冲容器
			int len = -1; //接收长度
			while((len=is.read(flush))!=-1) {
				baos.write(flush,0,len);		 //写出到字节数组中			
			}		
			baos.flush();
			return baos.toByteArray();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			//4、释放资源
			try {
				if(null!=is) {
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;		
	}
	/**
	 * 2、字节数组写出到图片
	 * 1)、字节数组到程序 ByteArrayInputStream
	 * 2)、程序到文件 FileOutputStream
	 */
	public static void byteArrayToFile(byte[] src,String filePath) {
		//1、创建源
		File dest = new File(filePath);
		//2、选择流
		InputStream  is =null;
		OutputStream os =null;
		try {
			is =new ByteArrayInputStream(src);
			os = new FileOutputStream(dest);
			//3、操作 (分段读取)
			byte[] flush = new byte[5]; //缓冲容器
			int len = -1; //接收长度
			while((len=is.read(flush))!=-1) {
				os.write(flush,0,len);			//写出到文件	
			}		
			os.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			//4、释放资源
			try {
				if (null != os) {
					os.close();
				} 
			} catch (Exception e) {
			}
		}
	}
}
  • 文件的接收
System.out.println("接收方启动中.....");
// 1、使用DatagramSocket  指定端口 创建接收端
DatagramSocket server =new DatagramSocket(6666);
// 2、准备容器 封装成DatagramPacket 包裹
byte[] container =new byte[1024*60];
DatagramPacket packet = new DatagramPacket(container,0,container.length);
// 3、阻塞式接收包裹receive​(DatagramPacket p)
server.receive(packet); //阻塞式
// 4、分析数据    将字节数组还原为对应的类型
//    byte[]  getData​()
//                getLength​()
 byte[]  datas =packet.getData();
 int len = packet.getLength();		 
 IOUtils.byteArrayToFile(datas, "src/copy.png");		 
// 5、释放资源
server.close();
  • 文件的发送
System.out.println("发送方启动中.....");
 // 1、使用DatagramSocket  指定端口 创建发送端
DatagramSocket client =new DatagramSocket(8888);
 //2、准备数据 一定转成字节数组
byte[] datas =IOUtils.fileToByteArray("src/logo.png");		
 //3、 封装成DatagramPacket 包裹，需要指定目的地
DatagramPacket packet =new DatagramPacket(datas,0,datas.length,
		new InetSocketAddress("localhost",6666));
//4、发送包裹send​(DatagramPacket p) * 
client.send(packet);
// 5、释放资源
client.close();
5. 多次发送，多次接收
  • 接收端
System.out.println("接收方启动中.....");
// 1、使用DatagramSocket  指定端口 创建接收端
DatagramSocket server =new DatagramSocket(6666);

while(true) {
	// 2、准备容器 封装成DatagramPacket 包裹
	byte[] container =new byte[1024*60];
	DatagramPacket packet = new DatagramPacket(container,0,container.length);
	// 3、阻塞式接收包裹receive​(DatagramPacket p)
	server.receive(packet); //阻塞式
	// 4、分析数据
	//    byte[]  getData​()
	//                getLength​()
	 byte[]  datas =packet.getData();
	 int len = packet.getLength();
	 String data=new String(datas,0,len);
	 System.out.println(data);
	 if(data.equals("bye")) {
		 break;
	 }
}
// 5、释放资源
server.close();
  • 发送端
System.out.println("发送方启动中.....");
 // 1、使用DatagramSocket  指定端口 创建发送端
DatagramSocket client =new DatagramSocket(8888);
 //2、准备数据 一定转成字节数组
BufferedReader reader =new BufferedReader(new InputStreamReader(System.in));
while(true) {
	String data = reader.readLine();
	byte[] datas = data.getBytes();
	 //3、 封装成DatagramPacket 包裹，需要指定目的地
	DatagramPacket packet =new DatagramPacket(datas,0,datas.length,
			new InetSocketAddress("localhost",6666));
	//4、发送包裹send​(DatagramPacket p) * 
	client.send(packet);
	if(data.equals("bye")) {
		break;
	}
}
// 5、释放资源
client.close();
6. 全双工通信

引入多线程

  • 接收器
public class TalkReceive implements Runnable {
	private DatagramSocket server;
	private String from;

	public TalkReceive(int port, String from) {
		this.from = from;
		try {
			server = new DatagramSocket(port);
		} catch (SocketException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void run() {
		while (true) {
			byte[] container = new byte[1024 * 60];
			DatagramPacket packet = new DatagramPacket(container, 0, container.length);
			try {
				server.receive(packet);// 阻塞式接收
				byte[] datas = packet.getData();
				int len = packet.getLength();
				String data = new String(datas, 0, len);
				System.out.println(from + ":" + data);
				if (data.equals("bye")) {
					break;
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		server.close();
	}
}
  • 发送器
public class TalkSend implements Runnable {
	private DatagramSocket client;
	private BufferedReader reader;
	private String destIP;
	private int destPort;

	public TalkSend(int srcPort, String destIP, int destPort) {
		this.destIP = destIP;
		this.destPort = destPort;
		try {
			client = new DatagramSocket(srcPort);
			reader = new BufferedReader(new InputStreamReader(System.in));
		} catch (SocketException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void run() {
		while (true) {
			String data;
			try {
				data = reader.readLine(); // 阻塞读取控制台输入
				byte[] datas = data.getBytes();
				DatagramPacket packet = new DatagramPacket(datas, 0, datas.length,
						new InetSocketAddress(this.destIP, this.destPort));
				client.send(packet);
				if (data.equals("bye")) {
					break;
				}
			} catch (IOException e) {
				e.printStackTrace();
			}

		}
		client.close();
	}

}
  • 对等通信端（屌丝 ）
new Thread(new TalkSend(6100, "localhost", 8847)).start(); // 发送
new Thread(new TalkReceive(8848, "长腿皮裤妹")).start(); // 接收
  • 对等通信端（长腿皮裤妹）
new Thread(new TalkSend(6120, "localhost", 8848)).start(); // 发送
new Thread(new TalkReceive(8847, "屌丝")).start(); // 接收
beeworkshop
关注
专栏目录
java udp丢包_UDP丢包和无序 问题的解决方法
weixin_36122413的博客
02-21 821
最近在做一个项目,在这之前,做了个验证程序.发现客户端连续发来1000个1024字节的包,服务器端出现了丢包现象.纠其原因,是服务端在还未完全处理掉数据,客户端已经数据发送完毕且关闭了.我用过sleep(10),暂时解决这个问题,但是这不是根本解决办法,如果数据量大而多,网络情况不太好的话,还是有可能丢失.你试着用阻塞模式吧...select...我开始的时候好像也遇到过..不过改为阻塞模式后就没...
java网络编程UDP协议通信
06-14
通过java网络编程深入理解UDP协议通信，与TCP的区别等等 源码包每一行都有注释，在代码里面每一个类都有详细的注释来解释这个类的功能这个方法的功能，调用哪一个类的哪一个功能等等。 压缩包包含实验报告（实验原理...
用JAVA和UDP实现字符串的发送和接收
12-05
导入eclipse/Myeclipse就可以运行的JAVA和UDP实现先输入一串字符，在将字符发送到另一个进程。
采用UDP的网络通信客户端（Java实现）
12-16
这是本人用Java语言，采用udp协议实现的一个网络通信客户端，一个程序你只需要打开两个端口，更改下端口号就可以通信
java网络编程之UDP
asd142312的博客
02-18 124
java网络编程之UDP java网络编程基于UDP数据报，发送循环发送数据，当发送byby时终止连接，服务端等待接收，当收到byby时服务器关闭连接 Sender发送端代码： package cn.csuft.poorguy.chat; import java.io.IOException; import java.net.DatagramPacket; impor...
java udp丢包重发_UDPDataPacker_Java数据报之失序和丢包
weixin_36260323的博客
02-27 250
Java数据报之失序和丢包习惯了TCP编程，认为UDP可以包办这些问题是错误的。一个UDP应用程序要承担可靠性方面的全部工作，包括报文的丢失、重复、时延、乱序以及连接失效等问题。通常我们在可靠性好，传输时延小的局域网上开发测试，一些问题不容易暴露，但在大型互联网上却会出现错误。UDP协议把递送的可靠性责任推到了上层即应用层，下面简单编写了几个类来专门处理两个问题：乱序和丢包。四个类：DataPac...
基于java netty的udp客户端声呐数据对接
06-07
Java Netty是一个高性能、异步事件驱动的网络应用程序框架，常用于开发高效的网络服务，包括TCP、UDP等网络协议的应用。在"基于Java Netty的UDP客户端声呐数据对接"项目中，我们主要关注如何利用Netty处理UDP通信，...
JAVA编程实现UDP网络通讯的方法示例
08-29
在Java中，我们可以使用`java.net.DatagramSocket`和`java.net.DatagramPacket`这两个类来实现UDP网络通信。 `DatagramSocket`类代表一个UDP套接字，用于发送和接收数据报。创建一个`DatagramSocket`对象，通常需要...
UDP.rar_JAVA UDP服务端_UDP transfer java_UDP客户服务_java udp服务端_计算机网络
09-24
总的来说，这个UDP.rar文件提供了Java环境下UDP通信的实例，涵盖了服务端和客户端的基本操作，是学习和实践网络编程的好资料。通过对这两个文件的深入研究，开发者可以掌握如何在实际项目中使用UDP进行数据传输。
UDP.rar_UDP_java UDP聊天_udp java_udp java 服务_udp 聊天 java
09-24
描述中提到的是一个基于UDP协议实现的网络聊天系统，由客户端（UDPClient.java）和服务器端（UDPServer.java）组成。这个系统利用了Java语言的网络编程API，如Socket和DatagramPacket类，来实现数据的发送和接收。 ...
Java使用线程实现UDP收发程序
04-23
该Java程序使用Eclipse编写，完成了定时收发UDP的功能。其中体现了线程使用、Jni接口调用、精确定时、模拟鼠标串口等功能。
java使用udp协议和硬件进行数据收发处理
09-20
java使用udp协议进行数据收发处理，java使用udp协议进行数据收发处理
UDP协议方式实现双方的通信Javae clipse
05-01
UDP协议方式实现双方的通信Javae clipse UDPSend.java UDPReceive.rar
Java开发笔记（一百一十六）采用UDP协议的Socket通信
pinlantu的博客
06-24 249
前面介绍了如何通过Socket接口传输文本与文件，在示例代码中，Socket客户端得先调用connect方法连接服务端，确认双方成功连上后才能继续运行后面的代码，这种确认机制确保客户端与服务端的的确确成功连接了，因而是可靠的网络连接，并且该可靠连接属于TCP连接。为啥这么说呢？因为TCP协议（全称“Transmission Control Protocol”，传输控制协议）不仅是一种传输层的通信协...
Java—网络编程实现UDP聊天室（局域网）
余俊晖，NLP炼丹师，目前专注自然语言处理领域研究。曾获得国内外自然语言处理算法竞赛TOP奖项近二十项。
11-05 2211
** * 建立UDP接收端的思路。** * 1，建立udp socket服务,因为是要接收数据，必须要明确一个端口号。 * 2，创建数据包，用于存储接收到的数据。方便用数据包对象的方法解析这些数据. * 3，使用socket服务的receive方法将接收的数据存储到数据包中。 * 4，通过数据包的方法解析数据包中的数据。
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 351
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
Java UDP网络编程实战与JMF应用
"基于UDP的JAVA网络编程"文档深入探讨了Java网络编程中的一个重要组成部分——用户数据报协议（User Datagram Protocol, UDP）的实现和应用。文档首先介绍了UDP的基本原理，它是一种无连接的、不可靠的传输层协议，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值