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。