Java中UDP通讯

     相对于TCP的三次握手，UDP是一个无状态的协议，发送端发送数据报文后，并不确定接收端一定能收到。由于不需要有回应，因此具有资源消耗小，反应速度快的特点。当网络稳定性较差时，UDP协议的网络通讯丢包率会比较大。以下是一个java实现的udp通讯实现：

发送端

public class UDPSender {  
    public static void main(String[] args) {
    	int i = 0;
    	int timeout = 5000;
    	/*定义报文长度*/
    	int length = 1024;
    	
    	/*无限循环，不断发送报文给客户端，并接收客户端返回的报文，当客户端没有启动时，报超时错误*/
    	while(true){
            try {
            	/*udp的发送端的ip和端口不是必须指定的*/
	        	int sendPost = 9000;
	            // 创建发送方的套接字，IP默认为本地，端口号随机  
	            DatagramSocket sendSocket = new DatagramSocket(sendPost);  
	            
	            //指定timeout时间，防止进入无限等待状态  
	            sendSocket.setSoTimeout(timeout); 	            
	  
	            //要发送的消息：  
	            String mes = "接收端，收到请回答！";  
	  
	            // 讲消息内容转换成字节数组
	            byte[] buffer = mes.getBytes();  
	  
	            // 确定发送方的IP地址及端口号，地址为本地机器地址
	            int receivePort = 8888;  
	            InetAddress ip = InetAddress.getLocalHost();  
	  
	            // 构造要发送的报文
	            DatagramPacket sendPacket = new DatagramPacket(buffer, buffer.length, ip, receivePort);  
	  
	            // 通过套接字发送数据报文：  
	            sendSocket.send(sendPacket);  
	  
	            // 确定接受反馈数据的缓冲存储器，即存储数据的字节数组  
	            byte[] getBuf = new byte[length];  
	  
	            // 创建接受类型的数据报  
	            DatagramPacket getPacket = new DatagramPacket(getBuf, getBuf.length);  
	
	            // 通过套接字接受数据  
	            sendSocket.receive(getPacket);  
	
	            // 解析反馈的消息，并打印  
	            String backMes = new String(getBuf, 0, getPacket.getLength());  
	            System.out.println("收到接收端的消息：" + backMes);  
	  
	            // 关闭套接字  
	            sendSocket.close();  	            
            } catch(SocketTimeoutException e){
            	System.out.println("接收端接收超时");
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally{
	            try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
	            
	            System.out.println("_________________i="+ i++);            	
            }
    	}  
    }  
}  

接收端

public class UDPReceive {
    public static void main(String[] args) {   
    	int j = 0;
    	/*定义报文长度*/
    	int length = 1024;
    	
    	while(true){
    		try {     		
	            // 确定接受方的IP和端口号，IP地址为本地机器地址  
	            InetAddress ip = InetAddress.getLocalHost();  
	            int port = 8888;  
	  
	            // 创建接收方的套接字,并制定端口号和IP地址  
	            DatagramSocket getSocket = new DatagramSocket(port, ip);  
	  
	            // 确定数据报接受的数据的数组大小  
	            byte[] buf = new byte[length];  
	  
	            // 创建接受类型的数据报，数据将存储在buf中  
	            DatagramPacket getPacket = new DatagramPacket(buf, buf.length);  
	  
	            // 通过套接字接收数据  
	            getSocket.receive(getPacket);  
	  
	            // 解析发送方传递的消息，并打印  
	            String getMes = new String(buf, 0, getPacket.getLength());  
	            System.out.println("发送端的消息：" + getMes);  
	  
	            // 通过数据报得到发送方的IP和端口号，并打印  
	            InetAddress sendIP = getPacket.getAddress();  
	            int sendPort = getPacket.getPort();  
	            System.out.println("发送端的IP地址是：" + sendIP.getHostAddress());  
	            System.out.println("发送端的端口号是：" + sendPort);  
	  
	            // 通过数据报得到发送方的套接字地址  
	            SocketAddress sendAddress = getPacket.getSocketAddress();  
	  
	            // 确定要反馈发送方的消息内容，并转换为字节数组  
	            String feedback = "接收端说：我收到了！";  
	            byte[] backBuf = feedback.getBytes();  
	  
	            // 创建发送类型的数据报  
	            DatagramPacket sendPacket = new DatagramPacket(backBuf,  
	                    backBuf.length, sendAddress);  
	  
	            // 通过套接字发送数据  
	            getSocket.send(sendPacket);  
	  
	            // 关闭套接字  
	            getSocket.close();  
            } catch(SocketTimeoutException e){
            	System.out.println("发送端接收超时");
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally{
	            try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
	            
	            System.out.println("_________________j="+ j++);            	
            }            
        }
    }  
}  

    以上代码实现了发送端与接收端通过UDP不间断发送接收数据通讯。