java Socket 之 Datagram socket（UDP）

 Datagram socket

Datagram socket使用UDP来实现数据通讯，因此它不能保证数据能够到达目的地，但是由于它不需要专用的网络链接，所以它所需的资源相对少的多。

Datagram以包的方式发送数据，但它不能保证这些数据包以特定的顺序到达目的，因此包中往往需要包含序列号的信息，接收方可以根据序列号的信息决定是否所有的包都已收到，并按正常顺序重组这些包。

Java通过两个类DatagramSocket和DatagramPacket来支持Datagram socket。DatagramSocket实现了Datagram socket的基本功能，而DatagramPacket则提供了对包的一些支持。

DatagramSocket的几个重要方法：

（1） DatagramSocket()：随机绑定一个有效的端口；

（2） DatagramSocket(int port)：绑定指定的端口；

（3） Void send(DatagramPacket p)：发送数据报，由于目的地的地址信息已包含在数据报中，所以不需要在本函数中提供地址信息；

（4） synchronized void receive(DatagramPacket p)：接收数据包，线程安全；

（5） synchronized void close()：关闭socket；

在DatagramSocket中并不区分ServerSocket和ClientSocket，如果一定要区分，那么发送的是client，而接收的是server。

DatagramPacket有以几个重要的方法：

（1） DatagramPacket(byte ibuf[], int ilength)：用于接收数据报；

（2） DatagramPacket(byte ibuf[], int ilength, InetAddress iaddr, int iport)：用于发送的数据报；

（3） byte[] getData()；

（4） int getLength()

 

以下是完整的Datagram Socket的例子：

接收端，Server端代码：

import java.io.*; 
import java.net.*; 
class FortuneServer1 extends Thread 
{ 
 DatagramSocket ServerSocket; 
 public FortuneServer1() 
 {  
  super("FortuneServer1"); 
  try
  { 
   ServerSocket = new DatagramSocket(1114); 
   System.out.println("FortuneServer up and running..."); 
  } 
  catch (SocketException e) 
  {
   System.err.println("Exception: couldn't create datagram socket"); 
   System.exit(1); 
  }
 }

 public static void main(String[] args) 
 { 
  FortuneServer1 server = new FortuneServer1(); 
  server.start(); 
 }

 public void run() 
 { 
  if (ServerSocket == null) 
   return; 
  while (true) 
  {
   try 
   { 
    InetAddress address; 
    int port;
    DatagramPacket packet; 
    byte[] data = new byte[128]; 
    packet = new DatagramPacket(data, data.length);     
    ServerSocket.receive(packet); 
                   //如果1114端口没有请求到数据，就一直停留在这里等待数据接收
                   //如果接收到数据，则将数据包放在packet对象中，并在下面对其解析
    address = packet.getAddress(); 
    port = packet.getPort(); 
    
    FileWriter fw = new FileWriter("Fortunes.txt");//创建新文件
             PrintWriter out = new PrintWriter(fw);    
             for(int i=0;i<data.length;i++){ 
        out.print(data[i]+"  ");
       }
    out.close();
             System.out.println("Data has been writen to destination!");
    
    //再次创建数据包，发送到接收的数据的端口
    packet = new DatagramPacket(data, data.length, address, port); 
    ServerSocket.send(packet);
    System.out.println("Respond has been made!");
   } 
   catch (Exception e) 
   { 
    System.err.println("Exception: " + e); 
    e.printStackTrace(); 
   }
  } 
 } 
} 

说明：

（1） 这个例子中接收端的socket使用了多线程；

（2） 在构造函数中创建了DatagramSocket，并且使用了1114这个端口；

（3） 本例子的关键函数是run，它使用了死循环，在循环中使用了receive这方法来临听1114端口，如果1114端口没有请求数据到来，那么这个程序就一直停留在receive这个位置，不再往下执行；

（4） 当1114端有数据时，receive方法将接收到的DatagramPacket数据包放在packet这个对象中，然后解析其中的数据，获取发送方的地址信息；

（5） 然后再创建DatagramPacket包，并填充数据，发送到原接收端。

 

以下是发送端的代码：

import java.net.*;

class FortuneClient 
{ 
 public static void main(String args[]) 
 { 
  FortuneClient client = new FortuneClient();
  System.out.println(client.getMessage()); 
 }

 public String getMessage() 
 { 
  String fortune; 
  try { 
   DatagramSocket socket; 
   DatagramPacket packet;
   byte[] data = new byte[128];
   
   for(int i=0;i<data.length;i++){
    Integer integer=new Integer(i);
    data[i]=integer.byteValue();
   }
   
   socket = new DatagramSocket(); 
   //packet = new DatagramPacket(data, data.length,InetAddress.getByName("127.0.0.1"), 1114); 
   packet = new DatagramPacket(data, data.length,InetAddress.getLocalHost(), 1114);
   socket.send(packet); 
   
   packet = new DatagramPacket(data, data.length); 
   socket.receive(packet); 
   fortune = new String(packet.getData()); 
   socket.close();
  } 
  catch (UnknownHostException e) { 
   System.err.println("Exception: host could not be found"); 
   return null; 
  } 
  catch (Exception e) {
   System.err.println("Exception: " + e); 
   e.printStackTrace(); 
   return null; 
  } 
  return fortune; 
 } 
} 

客户端的代码与服务器端的代码基本相同，只是没有了循环，并且处理步骤与服务器端的基本相反。这也说明了Datagram Socket不真正区分Server和Client。