javaudp发送接收

❶ java udp如何通过一个对象完成接收和发送数据

//注意,本地ip以及端口,广播Ip以及端口,可根据自己的电脑实际情况定.我的三段是2
//思路:我用的udp启动服务端,进行侦听,如果有消息,就该频段广播一次..
//客户端使用多线程,一个发送服务端,一个接受广播..就当我复习了一次...!
importjava.io.IOException;
importjava.net.DatagramPacket;
importjava.net.DatagramSocket;
importjava.net.InetAddress;
importjava.net.InetSocketAddress;
importjava.net.SocketAddress;
importjava.util.Scanner;
publicclassUdpTest{
	classSendTest{
		privateintcount=1;
		privateScannersc;
		privatebyte[]by,by2;
		privateInetAddressip;
		privateSocketAddresssd1,sd2;
		privateDatagramSocketds,ds2;
		privateDatagramPacketdp,dp2;
		SendTest(StringipName,intport)throwsException{
			sc=newScanner(System.in);
			ip=InetAddress.getByName(ipName);
			sd1=newInetSocketAddress(ip,port);//发送的目标:ip+端口
			sd2=newInetSocketAddress(19823);//己方,省略ip,默认自己本地地址
			ds=newDatagramSocket();//参数为自己的标识
			//接受
			by2=newbyte[1024];
			ds2=newDatagramSocket(sd2);
			send();
		}
		privatevoidsend()throwsIOException{
			newThread(){
				publicvoidrun(){
					while(true){
						by=sc.nextLine().getBytes();
						dp=newDatagramPacket(by,by.length,sd1);//数组,数组长度,目标ip+端口
						try{
							ds.send(dp);
						}catch(IOExceptione){
							e.printStackTrace();
						}//推送服务;
						System.out.println("老马第:"+count+++"条信息发送完成!");
					}
				}
			}.start();
			newThread(){
				publicvoidrun(){
					while(true){
						dp2=newDatagramPacket(by2,by2.length);
						try{
							ds2.receive(dp2);
							System.out.println("老马接受到一条广播可能来自老宋:"+newString(by2,0,dp2.getLength()));
						}catch(IOExceptione){
							e.printStackTrace();
						}
					}
				}
			}.start();
		}
	}
	classAccepTest{
		privatebyte[]by;
		privateSocketAddresssd1,sd2;
		privateDatagramSocketds;
		privateDatagramPacketdp;
		privateintcount=0;
		AccepTest()throwsException{
			by=newbyte[1024];
			sd1=newInetSocketAddress("192.168.2.255",19823);//广播
			sd2=newInetSocketAddress(19822);//己方,省略ip,默认自己本地地址
			ds=newDatagramSocket(sd2);//参数为自己的标识,这是用来接受的.....
			accepts();
		}
		privatevoidaccepts()throwsIOException{
			while(true){
				count++;
				System.out.println("老宋的服务器接受第:"+count+"次数据:...");
				dp=newDatagramPacket(by,by.length);//数组,数组长度,仅仅用来接收;
				ds.receive(dp);//接受服务;
				Stringstr=newString(by,0,dp.getLength());
				System.out.println("老宋接受到数据--------->"+str);
				System.out.println();
				//广播..
				by=("插个广播:"+str+"....谁发的??").getBytes();
				dp=newDatagramPacket(by,by.length,sd1);
				ds.send(dp);
			}
		}
	}
	publicstaticvoidmain(String[]args)throwsException{
		newThread(){
			publicvoidrun(){
				try{
					newUdpTest().newAccepTest();
				}catch(Exceptione){
					e.printStackTrace();
				}
			}
		}.start();
		newThread(){
			publicvoidrun(){
				try{
					newUdpTest().newSendTest("127.0.0.1",19822);
				}catch(Exceptione){
					e.printStackTrace();
				}
			}
		}.start();
	}
}

❷ 请教一个JAVA UDP程序问题。我编了一个UDP通信程序，实现客户端向服务器端发送信息。

正如你所说
，UDP不需要实时连接，客户端只负责发送，不保证成功，服务端也只接收正确到达的数据包，你没有起服务端之前的客户端所发送的UDP数据包都属于
丢包
，就像我们玩一些网游，如果网络不好，会出现一卡一卡的，本来在这
下一秒
突然移动到
另一个地方
，中间移动的过程没有出现，这就属于丢包了。

❸ JAVA用udp从本地网络穿透到公网之后，从其他网络作为客户端发送udp包到服务器正常接收。

你说的还不清楚。Java网络编程使用Socket，同为一个网络下的主机时是肯定没问题的，不论同一局域网或广域网。如果内网跨越网关，我没做过试验，按我的理解，内网主机做客户端，独立主机做服务器应该可行，反之不行。

❹ 关于java UDP文件传输的问题

使用UDP协议进行文件传输不能保证正确性，很容易发生丢包的情况。建议在进行较大文件传输的时候使用TCP的Socket和ServerSocket类进行传输。在数据量小于65600字节的时候使用UDP是安全的

如果一定要使用UDP方式进行传输的话，为了提高传输的准确性，可以限制一下传输速度，方法是在发送端每次发送后sleep一下,即在发送端程序的dataSocket.send(dataPacket);一句后加上：
TimeUnit.MICROSECONDS.sleep(1);
不过这种方法也不能保证传输绝对准确，所以还是建议用TCP的方式

程序本身应该是能够达到效果的，不知道错误提示是什么。测试之前要看下发送端的filePath文件是否存在，貌似防火墙也有影响，测试之间最好关闭防火墙。下面是我的测试程序，接收端是类A1，接收端是类A2，发送端的文件filePath是D盘根目录下的a1.mkv：

接收端：
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class A1 {
public static DatagramSocket dataSocket;
public static final int PORT=7;
public static byte[] receiveByte;
public static DatagramPacket dataPacket;
public static void main(String[] args) throws IOException{
dataSocket = new DatagramSocket(PORT);
DataOutputStream fileOut = new DataOutputStream(new BufferedOutputStream(new BufferedOutputStream(new FileOutputStream("D:\\a.mkv"))));
int i = 0;
while (i == 0)// 无数据，则循环

{
receiveByte = new byte[1024];
dataPacket = new DatagramPacket(receiveByte, receiveByte.length);
dataSocket.receive(dataPacket);
i = dataPacket.getLength();
// 接收数据

if (i > 0) {
// 指定接收到数据的长度,可使接收数据正常显示,开始时很容易忽略这一点

fileOut.write(receiveByte,0,i);
fileOut.flush();
i = 0;// 循环接收
}

}
}
}

发送端：

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Inet4Address;
import java.util.Date;

public class A2 {
public static DatagramSocket dataSocket;
public static final int PORT=7;
public static byte[] sendDataByte;
public static DatagramPacket dataPacket;
public static void main(String[] args) throws IOException, InterruptedException{
String filePath="D:\\a1.mkv";
DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(filePath)));
dataSocket = new DatagramSocket(PORT+1);
sendDataByte = new byte[1024];
int read=0;
long a=new Date().getTime();
while(true){
if (fis != null) {
read = fis.read(sendDataByte);
}

if (read == -1) {
System.out.println(new Date().getTime()-a);
break;
}
dataPacket = new DatagramPacket(sendDataByte, sendDataByte.length,(Inet4Address) Inet4Address.getByName("localhost"), PORT);
dataSocket.send(dataPacket);
TimeUnit.MICROSECONDS.sleep(1);//限制传输速度
}
}
}

❺ 关于java用udp发送文件的问题...

我试了一下可以运行，错误见注释
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

import javax.swing.JFileChooser;

public class UServer {
private DatagramPacket dp; //数据报包
private DatagramSocket ds; //数据报socket
private String filename; //保存选择的文件的名字
private FileInputStream fis; //输入流，用来读取磁盘文件
private FileOutputStream fos;
private byte[] buf=new byte[10240]; //字节数组，存放读取的文件
public UServer(){
try {
ds = new DatagramSocket(4567);
fos=new FileOutputStream("tmp/temp.dat");
dp =new DatagramPacket(buf,buf.length);
while(true){
//这个地方改成我这样
if (dp.getData().length != 0) {
ds.receive(dp);
System.out.print(dp.getData().length);
fos.write(dp.getData());
fos.flush();
//你的while（true）是个死循环，虽然已经接收到了但是没法循环出去，需要一个break或者把true换成你收的文件长度不等于0
break;
}

}
} catch (Exception e) {
e.printStackTrace();
}
JFileChooser jfc=new JFileChooser();
jfc.showSaveDialog(null);
filename=jfc.getSelectedFile().getPath();
try{
fos.close();
fos=new FileOutputStream(filename);
fis=new FileInputStream("tmp/temp.dat");
int c;
while((c=fis.read(buf))!= -1){
fos.write(buf);
fos.flush();
}
fos.close();
fis.close();
}catch (IOException e1){
e1.printStackTrace();
}
}

public static void main(String args[]){
new UServer();
}
}

❻ 在javasocket网络编程中,开发基于udp协议的程序使用的套接字有哪些

Socket套接字，是由系统提供用于网络通信的技术（操作系统给应用程序提供的一组API叫做Socket API），是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程。

socket可以视为是应用层和传输层之间的通信桥梁；
传输层的核心协议有两种：TCP,UDP；socket API也有对应的两组，由于TCP和UDP协议差别很大,因此,这两组API差别也挺大。

分类：
Socket套接字主要针对传输层协议划分为如下三类：

流套接字：使用传输层TCP协议
TCP，即Transmission Control Protocol（传输控制协议），传输层协议；
TCP的特点：

有连接：像打电话,得先接通,才能交互数据；
可靠传输：传输过程中,发送方知道接收方有没有收到数据.（打电话就是可靠传输）；
面向字节流：以字节为单位进行传输.(非常类似于文件操作中的字节流)；
全双工：一条链路,双向通信；
有接收缓冲区，也有发送缓冲区。
大小不限
对于字节流来说，可以简单的理解为，传输数据是基于IO流，流式数据的特征就是在IO流没有关闭的情况下，是无边界的数据，可以多次发送，也可以分开多次接收。

数据报套接字：使用传输层UDP协议
UDP，即User Datagram Protocol（用户数据报协议），传输层协议。
UDP的特点：

无连接：像发微信,不需要接通,直接就能发数据；
不可靠传输：传输过程中,发送方不知道接收方有没有收到数据.（发微信就是不可靠传输）；
面向数据报：以数据报为单位进行传输(一个数据报都会明确大小)一次发送/接收必须是一个完整的数据报,不能是半个,也不能是一个半；
全双工：一条链路，双向通信；
有接收缓冲区，无发送缓冲区；
大小受限：一次最多传输64k；
对于数据报来说，可以简单的理解为，传输数据是一块一块的，发送一块数据假如100个字节，必须一次发送，接收也必须一次接收100个字节，而不能分100次，每次接收1个字节。

原始套接字
原始套接字用于自定义传输层协议，用于读写内核没有处理的IP协议数据。

二、UDP数据报套接字编程
UDPSocket中，主要涉及到两类：DatagramSocket、DatagramPacket;

DatagramSocket API
DatagramSocket 创建了一个UDP版本的Socket对象，用于发送和接收UDP数据报，代表着操作系统中的一个socket文件，（操作系统实现的功能–>）代表着网卡硬件设备的抽象体现。

DatagramSocket 构造方法:

方法签名 方法说明
DatagramSocket() 创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口（一般用于客户端）
DatagramSocket(int port) 创建一个UDP数据报套接字的Socket，绑定到本机指定的端口（一般用于服务端）
DatagramSocket 方法：

方法签名 方法说明
void receive(DatagramPacket p) 从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待）
void send(DatagramPacket p) 从此套接字发送数据报包（不会阻塞等待，直接发送）
void close() 关闭此数据报套接字
DatagramPacket API
代表了一个UDP数据报，是UDP Socket发送和接收的数据报，每次发送/接收数据报，都是在传输一个DatagramPacket对象。

DatagramPacket 构造方法：

方法签名 方法说明
DatagramPacket(byte[] buf, int length) 构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组(第一个参数buf)中，接收指定长度(第二个参数length)
DatagramPacket(byte[] buf, int offset, int length,SocketAddress address) 构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组(第一个参数buf)中，从0到指定长度(第二个参数length)。address指定目的主机的IP和端口号
DatagramPacket 方法：

方法签名 方法说明
InetAddress getAddress() 从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取接收端主机IP地址
int getPort() 从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号
byte[] getData() 获取数据报中的数据
构造UDP发送的数据报时，需要传入 SocketAddress ，该对象可以使用 InetSocketAddress 来创建。

InetSocketAddress API
InetSocketAddress （ SocketAddress 的子类 ）构造方法：

方法签名 方法说明
InetSocketAddress(InetAddress addr, int port) 创建一个Socket地址，包含IP地址和端口号
示例1：写一个简单的客户端服务程序，回显服务（EchoSever）
在这里插入图片描述
构建Socket对象有很多失败的可能：

端口号已经被占用，同一个主机的两个程序不能有相同的端口号（这就好比两个人不能拥有相同的电话号码）；
此处，多个进程不能绑定同一个端口号，但是一个进程可以绑定多个端口，（这就好比一个人可以拥有多个手机号），一个进程可以创建多个Socket对象，每个Socket都绑定自己的端口。
每个进程能够打开的文件个数是有上限的，如果进程之间已经打开了很多文件，就可能导致此时的Socket文件不能顺利打开；
在这里插入图片描述
这个长度不一定是1024，假设这里的UDP数据最长是1024，实际的数据可能不够1024.

在这里插入图片描述
这里的参数不再是一个空的字节数组了，response是刚才根据请求计算的得到的响应，是非空的，DatagramPacket 里面的数据就是String response的数据。

response.getBytes().length：这里拿到的是字节数组的长度（字节的个数），而response.length得到的是字符的长度。

五元组
一次通信是由5个核心信息描述的：源IP、 源端口、 目的IP、 目的端口、 协议类型。

站在客户端角度：

源IP:本机IP；
源端口：系统分配的端口；
目的IP：服务器的IP；
目的端口：服务器的端口；
协议类型：TCP；
站在服务器的角度：

源IP:服务器程序本机的IP；
源端口：服务器绑定的端口（此处手动指定了9090）；
目的IP：包含在收到的数据报中（客户端的IP）；
目的端口：包含在收到的数据报中（客户端的端口）；
协议类型：UDP；