java UDP连接,如果要发送文件的话,你只能自己定义一系列的协议
因为TCP UDP 双方发送都是二进制数据
那么这个实现非常复杂
得不停的发送数据,写数据,建议使用http协议
❷ 如何用java实现UDP的可靠传输
我记忆中可靠的传输应该类似TCP的三次握手：
1.发送方向接收方发送一个随机数。
2.接收方收到随机数后将其+1，再回传给发送方。
3.发送方收到随机数判断其是否被+1，如果是代表双方的传递线路是通畅的，可以正式开始传送数据。
❸ JAVA udp打洞出现的问题~
建议首先在java环境下测试下你所要达到的逻辑（非android模拟器下），若成功再移植到android上，个人认为可能是模拟器监听pc端口时出现了丢包。
❹ JAVA用udp从本地网络穿透到公网之后，从其他网络作为客户端发送udp包到服务器正常接收。
你说的还不清楚。Java网络编程使用Socket，同为一个网络下的主机时是肯定没问题的，不论同一局域网或专广属域网。如果内网跨越网关，我没做过试验，按我的理解，内网主机做客户端，独立主机做服务器应该可行，反之不行。
❺ 5 java 如何使用udp协议传送文件
//发送端SocketSendFile.java
import java.io.*;
import java.net.*;
public class SocketSendFile {
public static final int SER_PORT=666;
public static final int CLI_PORT=8484;
public static final String SER_IP="192.168.0.35";
public static int bufSize = 1024;
public static byte] mess = new bytebufSize];
//建立Socket引用
public static DatagramSocket dp;
public static void main(String] args) throws Exception {
dp = new DatagramSocket(SER_PORT);
//调用构造函数SocketSendFile,并传递参数args0](所要传输的文件名)
SocketSendFile(args0]);
}
public static void SocketSendFile(String file2) throws Exception {
//定义一个计数器
int pos =0;
//设置写入流
FileInputStream fis = new FileInputStream(file2);
BufferedInputStream bis = new BufferedInputStream(fis);
DataInputStream dis = new DataInputStream(bis);
int i;
do {
i = dis.read();
int j=0;
while (j<1024 & i != -1) {
messpos++] = (byte) i;
i=dis.read();
j++;
}
dp.send(new DatagramPacket(mess,pos,InetAddress.getByName(SER_IP),CLI_PORT));
}
while (i != -1);
fis.close();
}
}
//接收端SocketReceiveFile.java
import java.net.*;
import java.io.*;
public class SocketReceiveFile {
public static int bufSize=1024;
public static byte] mess=new bytebufSize];
public static DatagramSocket dp;
public static final int SER_PORT=8484;
public static void main(String] args) throws Exception {
dp = new DatagramSocket(SER_PORT);
SocketReceiveFile(args0]);
}
public static void SocketReceiveFile(String file1) throws Exception {
FileOutputStream fos = new FileOutputStream(file1);
BufferedOutputStream bos = new BufferedOutputStream(fos);
DataOutputStream dos = new DataOutputStream(bos);
int i;
DatagramPacket p = new DatagramPacket(mess,mess.length);
while(true) {
boolean j=false;
while (p.getData().length != 0) {
dos.write(p.getData());
dp.receive(p);
j=true;
}
// System.out.println(new String(p.getData(),0,p.getLength()));
if (j)
System.out.println("文件传送完毕．");
}
// fos.close();
}
}
❻ java 中怎么使用UDP
发送步骤：
使用 DatagramSocket(int port) 建立socket（套间字）服务。
将数据打包到DatagramPacket中去
通过socket服务发送 （send()方法）
关闭资源
importjava.io.IOException;
importjava.net.*;
publicclassSend{
publicstaticvoidmain(String[]args){
DatagramSocketds=null;//建立套间字udpsocket服务
try{
ds=newDatagramSocket(8999);//实例化套间字，指定自己的port
}catch(SocketExceptione){
System.out.println("Cannotopenport!");
System.exit(1);
}
byte[]buf="Hello,Iamsender!".getBytes();//数据
InetAddressdestination=null;
try{
destination=InetAddress.getByName("192.168.1.5");//需要发送的地址
}catch(UnknownHostExceptione){
System.out.println("Cannotopenfindhost!");
System.exit(1);
}
DatagramPacketdp=
newDatagramPacket(buf,buf.length,destination,10000);
//打包到DatagramPacket类型中（DatagramSocket的send()方法接受此类，注意10000是接受地址的端口，不同于自己的端口！）
try{
ds.send(dp);//发送数据
}catch(IOExceptione){
}
ds.close();
}
}
接收步骤：
使用 DatagramSocket(int port) 建立socket（套间字）服务。（我们注意到此服务即可以接收，又可以发送），port指定监视接受端口。
定义一个数据包（DatagramPacket），储存接收到的数据，使用其中的方法提取传送的内容
通过DatagramSocket 的receive方法将接受到的数据存入上面定义的包中
使用DatagramPacket的方法，提取数据。
关闭资源。
importjava.net.*;
publicclassRec{
publicstaticvoidmain(String[]args)throwsException{
DatagramSocketds=newDatagramSocket(10000);//定义服务，监视端口上面的发送端口，注意不是send本身端口
byte[]buf=newbyte[1024];//接受内容的大小，注意不要溢出
DatagramPacketdp=newDatagramPacket(buf,0,buf.length);//定义一个接收的包
ds.receive(dp);//将接受内容封装到包中
Stringdata=newString(dp.getData(),0,dp.getLength());//利用getData()方法取出内容
System.out.println(data);//打印内容
ds.close();//关闭资源
}
}
❼ Java非局域网的udp传输问题
外网机器主动连接内网机器，需要在路由器上设置端口映射，包才能通过路由器并正确分配给目标机器。电驴有HighID和LowID的问题也是同理。
❽ NAT穿透（UDP打洞）
NAT有两大类，基本NAT和NAPT。
静态NAT：一个公网IP对应一个内部IP，一对一转换
动态NAT：N个公网IP对应M个内部IP，不固定的一对一转换关系
现在基本使用这种，又分为对称和锥型NAT。
锥型NAT ，有完全锥型、受限制锥型、端口受限制锥型三种：
对称NAT ：
把所有来自相同内部IP地址和端口号，到特定目的IP地址和端口号的请求映射到相同的外部IP地址和端口。如果同一主机使用不同的源地址和端口对，发送的目的地址不同，则使用不同的映射。只有收到了一个IP包的外部主机才能够向该内部主机发送回一个UDP包。对称的NAT不保证所有会话中的(私有地址，私有端口)和(公开IP，公开端口)之间绑定的一致性。相反，它为每个新的会话分配一个新的端口号。
对称NAT是一个请求对应一个端口，非对称NAT是多个请求对应一个端口(象锥形，所以叫Cone NAT)。
连接服务器为A，NAT检测服务器为B。
第一步：当一个接收客户端(Endpoint-Receiver ,简称 EP-R)需要接收文件信息时，在其向连接服务器发送文件请求的同时紧接着向检测服务器发送NAT检测请求。此处再次强调是“紧接着”，因为对于对称型NAT来说，这个操作可以直接算出其地址分配的增量(⊿p)。
第二步：当EP-R收到A或B的反馈信息时发现其外部地址与自身地址不同时就可以确定自己在NAT后面；否则，就是公网IP。
第三步：由服务器A向B发送其获得的EP-R的外部映射地址(IPa/Porta)，服务器B获得后进行比较，如果端口不同，则说明这是对称型NAT，同时可以直接计算出其分配增量：
⊿p=Portb-Porta
第四步：如果端口号相同，则由B向EP-R的Porta发送连接请求，如果EP-R有响应，则说明EP-R没有IP和Port的限制，属于全ConeNAT类型。
第五步：如果没有响应，则由服务器B使用其新端口b’向EP-R的Portb端口发送连接请求，如果有响应，则说明EP-R只对IP限制，属于限制性ConeNAT类型；否则就是对IP和port都限制，属于端口限制性ConeNAT类型。
通过上述五步基本可以全部检测出EP-R是否在公网，还是在某种NAT后面。
这也是一项可选配置任务，可根据需要为NAT 地址映射表配置老化时间，以控制用户对NAT 配置的使用，确保内、外网的通信安全。
配置NAT 地址映射表项老化时间的方法也很简单，只须在系统视图下使用firewall-nat session { dns | ftp | ftp-data | http | icmp | tcp | tcp-proxy | udp | sip | sip-media | rtsp |rtsp-media }aging-time time-value 命令配置即可。参数 time-value的取值范围为1～65 535的整数秒。如果要配置多个会话表项的超时时间需要分别用本命令配置。
缺省情况下，各协议的老化时间为：DNS（120 s）、ftp（120 s）、ftp-data（120 s）、HTTP（120 s）、icmp（20 s）、tcp（600 s）、tcp-proxy（10 s）、udp（120 s）、sip（1 800 s）、sip-media （ 120 s ）、rtsp （ 60 s ）、rtsp-media （ 120 s ）， 可用undo firewall-natsession { all | dns | ftp | ftp-data | http | icmp | tcp | tcp-proxy | udp | sip | sip-media | rtsp |rtsp-media } aging-time 命令恢复对应会话表项的超时时间为缺省值。
1、 中间服务器保存信息、并能发出建立UDP隧道的命令
2、 网关均要求为Cone NAT类型。Symmetric NAT不适合。
3、 完全圆锥型网关可以无需建立udp隧道，但这种情况非常少，要求双方均为这种类型网关的更少。
4、 假如X1网关为Symmetric NAT， Y1为Address Restricted Cone NAT 或Full Cone NAT型网关，各自建立隧道后，A1可通过X1发送数据报给Y1到B1(因为Y1最多只进行IP级别的甄别)，但B2发送给X1的将会被丢弃（因为发送来的数据报中端口与X1上存在会话的端口不一致，虽然IP地址一致），所以同样没有什么意义。
5、 假如双方均为Symmetric NAT的情形，新开了端口，对方可以在不知道的情况下尝试猜解，也可以达到目的，但这种情形成功率很低，且带来额外的系统开支，不是个好的解决办法。
6、 不同网关型设置的差异在于，对内会采用替换IP的方式、使用不同端口不同会话的方式，使用相同端口不同会话的方式；对外会采用什么都不限制、限制IP地址、限制IP地址及端口。
7、 这里还没有考虑同一内网不同用户同时访问同一服务器的情形，如果此时网关采用AddressRestricted Cone NAT 或Full Cone NAT型，有可能导致不同用户客户端可收到别人的数据包，这显然是不合适的。
为什么网上讲到的P2P打洞基本上都是基于UDP协议的打洞？难道TCP不可能打洞？还是TCP打洞难于实现？
假设现在有内网客户端A和内网客户端B，有公网服务端S。
如果A和B想要进行UDP通信，则必须穿透双方的NAT路由。假设为NAT-A和NAT-B。
S也和A B 分别建立了会话，由S发到NAT-A的数据包会被NAT-A直接转发给A，
由S发到NAT-B的数据包会被NAT-B直接转发给B，除了S发出的数据包之外的则会被丢弃。
所以：现在A B 都能分别和S进行全双工通讯了，但是A B之间还不能直接通讯。
并转发给A了（即B现在能访问A了）；再由S命令B向A的公网IP发送一个数据包，则
NAT-B能接收来自NAT-A的数据包并转发给B了（即A现在能访问B了）。
以上就是“打洞”的原理。
<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word;">为了保证A的路由器有与B的session，A要定时与B做心跳包，同样，B也要定时与A做心跳，这样，双方的通信通道都是通的，就可以进行任意的通信了。</pre>
API造成的。
UDP的socket允许多个socket绑定到同一个本地端口，而TCP的socket则不允许。
这是这样一个意思：A B要连接到S，肯定首先A B双方都会在本地创建一个socket，
去连接S上的socket。创建一个socket必然会绑定一个本地端口（就算应用程序里面没写
端口，实际上也是绑定了的，至少java确实如此），假设为8888，这样A和B才分别建立了到
S的通信信道。接下来就需要打洞了，打洞则需要A和B分别发送数据包到对方的公网IP。但是
问题就在这里：因为NAT设备是根据端口号来确定session，如果是UDP的socket，A B可以
分别再创建socket，然后将socket绑定到8888，这样打洞就成功了。但是如果是TCP的
socket，则不能再创建socket并绑定到8888了，这样打洞就无法成功。
**UDP打洞**的过程大致如此：
1、双方都通过UDP与服务器通讯后，网关默认就是做了一个外网IP和端口号 与你内网IP与端口号的映射，这个无需设置的，服务器也不需要知道客户的真正内网IP
2、用户A先通过服务器知道用户B的外网地址与端口
3、用户A向用户B的外网地址与端口发送消息，
4、在这一次发送中，用户B的网关会拒收这条消息，因为它的映射中并没有这条规则。
5、但是用户A的网关就会增加了一条允许规则，允许接收从B发送过来的消息
6、服务器要求用户B发送一个消息到用户A的外网IP与端口号
7、用户B发送一条消息，这时用户A就可以接收到B的消息，而且网关B也增加了允许规则
8、之后，由于网关A与网关B都增加了允许规则，所以A与B都可以向对方的外网IP和端口号发送消息。
TCP打洞 技术：
tcp打洞也需要NAT设备支持才行。
tcp的打洞流程和udp的基本一样，但tcp的api决定了tcp打洞的实现过程和udp不一样。
tcp按cs方式工作，一个端口只能用来connect或listen，所以需要使用端口重用，才能利用本地nat的端口映射关系。（设置SO_REUSEADDR，在支持SO_REUSEPORT的系统上，要设置这两个参数。）
连接过程：（以udp打洞的第2种情况为例（典型情况））
nat后的两个peer，A和B，A和B都bind自己listen的端口，向对方发起连接（connect），即使用相同的端口同时连接和等待连接。因为A和B发出连接的顺序有时间差，假设A的syn包到达B的nat时，B的syn包还没有发出，那么B的nat映射还没有建立，会导致A的连接请求失败（连接失败或无法连接，如果nat返回RST或者icmp差错，api上可能表现为被RST；有些nat不返回信息直接丢弃syn包（反而更好）），（应用程序发现失败时，不能关闭socket，closesocket（）可能会导致NAT删除端口映射；隔一段时间（1-2s）后未连接还要继续尝试）；但后发B的syn包在到达A的nat时，由于A的nat已经建立的映射关系，B的syn包会通过A的nat，被nat转给A的listen端口，从而进去三次握手，完成tcp连接。
从应用程序角度看，连接成功的过程可能有两种不同表现：（以上述假设过程为例）
1、连接建立成功表现为A的connect返回成功。即A端以TCP的同时打开流程完成连接。
2、A端通过listen的端口完成和B的握手，而connect尝试持续失败，应用程序通过accept获取到连接，最终放弃connect（这时可closesocket(conn_fd)）。
多数Linux和Windows的协议栈表现为第2种。
但有一个问题是，建立连接的client端，其connect绑定的端口号就是主机listen的端口号，或许这个peer后续还会有更多的这种socket。虽然理论上说，socket是一个五元组，端口号是一个逻辑数字，传输层能够因为五元组的不同而区分开这些socket，但是是否存在实际上的异常，还有待更多观察。
1、Windows XP SP2操作系统之前的主机，这些主机不能正确处理TCP同时开启，或者TCP套接字不支持SO_REUSEADDR的参数。需要让AB有序的发起连接才可能完成。
上述tcp连接过程，仅对NAT1、2、3有效，对NAT4（对称型）无效。
由于对称型nat通常采用规律的外部端口分配方法，对于nat4的打洞，可以采用端口预测的方式进行尝试。
ALG（应用层网关） ：它可以是一个设备或插件，用于支持SIP协议，主要类似与在网关上专门开辟一个通道，用于建立内网与外网的连接，也就是说，这是一种定制的网关。更多只适用于使用他们的应用群体内部之间。
UpnP ：它是让网关设备在进行工作时寻找一个全球共享的可路由IP来作为通道，这样避免端口造成的影响。要求设备支持且开启upnp功能，但大部分时候，这些功能处于安全考虑，是被关闭的。即时开启，实际应用效果还没经过测试。
STUN（Simple Traversalof UDP Through Network）： 这种方式即是类似于我们上面举例中服务器C的处理方式。也是目前普遍采用的方式。但具体实现要比我们描述的复杂许多，光是做网关Nat类型判断就由许多工作，RFC3489中详细描述了。
TURN(Traveral Using Relay NAT)： 该方式是将所有的数据交换都经由服务器来完成，这样NAT将没有障碍，但服务器的负载、丢包、延迟性就是很大的问题。目前很多游戏均采用该方式避开NAT的问题。这种方式不叫p2p。
ICE(Interactive Connectivity Establishment)： 是对上述各种技术的综合，但明显带来了复杂性。
❾ Java语言中如何使用UDP协议进行数据传输的
java里UDP协议传送的方式细节已经封装了到类DatagramSocket里了,只要用DatagramSocket的对象进行传输数据就可以了.
底层实现是应该依靠本地C语言程序来完成的
❿ 关于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);//限制传输速度
}
}
}