使用DatagramSocket发送、接收数据(Socket之UDP套接字)

  // 创建一个接收数据的DatagramPacket对象 
  
  DatagramPacket packet=new DatagramPacket(buf, 256); 
  
  // 接收数据报 
  
  socket.receive(packet); 

  // 创建一个发送数据的DatagramPacket对象 
  
  DatagramPacket packet = new DatagramPacket(buf, length, address, port); 
  
  // 发送数据报 
  
  socket.send(packet); 

  public class UdpServer 
  
  { 
  
   public static final int PORT = 30000; 
  
   // 定义每个数据报的最大大小为4KB 
  
   private static final int DATA_LEN = 4096; 
  
   // 定义接收网络数据的字节数组 
  
   byte[] inBuff = new byte[DATA_LEN]; 
  
   // 以指定字节数组创建准备接收数据的DatagramPacket对象 
  
   private DatagramPacket inPacket = 
  
   new DatagramPacket(inBuff , inBuff.length); 
  
   // 定义一个用于发送的DatagramPacket对象 
  
   private DatagramPacket outPacket; 
  
   // 定义一个字符串数组，服务器端发送该数组的元素 
  
   String[] books = new String[] 
  
   { 
  
   "疯狂Java讲义", 
  
   "轻量级Java EE企业应用实战", 
  
   "疯狂Android讲义", 
  
   "疯狂Ajax讲义" 
  
   }; 
  
   public void init()throws IOException 
  
   { 
  
   try( 
  
   // 创建DatagramSocket对象 
  
   DatagramSocket socket = new DatagramSocket(PORT)) 
  
   { 
  
   // 采用循环接收数据 
  
   for (int i = 0; i < 1000 ; i++ ) 
  
   { 
  
   // 读取Socket中的数据，读到的数据放入inPacket封装的数组里 
  
   socket.receive(inPacket); 
  
   // 判断inPacket.getData()和inBuff是否是同一个数组 
  
   System.out.println(inBuff == inPacket.getData()); 
  
   // 将接收到的内容转换成字符串后输出 
  
   System.out.println(new String(inBuff 
  
   , 0 , inPacket.getLength())); 
  
   // 从字符串数组中取出一个元素作为发送数据 
  
   byte[] sendData = books[i % 4].getBytes(); 
  
   // 以指定的字节数组作为发送数据，以刚接收到的DatagramPacket的 
  
   // 源SocketAddress作为目标SocketAddress创建DatagramPacket 
  
   outPacket = new DatagramPacket(sendData 
  
   , sendData.length , inPacket.getSocketAddress()); 
  
   // 发送数据 
  
   socket.send(outPacket); 
  
   } 
  
   } 
  
   } 
  
   public static void main(String[] args) 
  
   throws IOException 
  
   { 
  
   new UdpServer().init(); 
  
   } 
  
  } 

  public class UdpClient 
  
  { 
  
   // 定义发送数据报的目的地 
  
   public static final int DEST_PORT = 30000; 
  
   public static final String DEST_IP = "127.0.0.1"; 
  
   // 定义每个数据报的最大大小为4KB 
  
   private static final int DATA_LEN = 4096; 
  
   // 定义接收网络数据的字节数组 
  
   byte[] inBuff = new byte[DATA_LEN]; 
  
   // 以指定的字节数组创建准备接收数据的DatagramPacket对象 
  
   private DatagramPacket inPacket = 
  
   new DatagramPacket(inBuff , inBuff.length); 
  
   // 定义一个用于发送的DatagramPacket对象 
  
   private DatagramPacket outPacket = null; 
  
   public void init()throws IOException 
  
   { 
  
   try( 
  
   // 创建一个客户端DatagramSocket，使用随机端口 
  
   DatagramSocket socket = new DatagramSocket()) 
  
   { 
  
   // 初始化发送用的DatagramSocket，它包含一个长度为0的字节数组 
  
   outPacket = new DatagramPacket(new byte[0] , 0 
  
   , InetAddress.getByName(DEST_IP) , DEST_PORT); 
  
   // 创建键盘输入流 
  
   Scanner scan = new Scanner(System.in); 
  
   // 不断地读取键盘输入 
  
   while(scan.hasNextLine()) 
  
   { 
  
   // 将键盘输入的一行字符串转换成字节数组 
  
   byte[] buff = scan.nextLine().getBytes(); 
  
   // 设置发送用的DatagramPacket中的字节数据 
  
   outPacket.setData(buff); 
  
   // 发送数据报 
  
   socket.send(outPacket); 
  
   // 读取Socket中的数据，读到的数据放在inPacket所封装的字节数组中 
  
   socket.receive(inPacket); 
  
   System.out.println(new String(inBuff , 0 
  
   , inPacket.getLength())); 
  
   } 
  
   } 
  
   } 
  
   public static void main(String[] args) 
  
   throws IOException 
  
   { 
  
   new UdpClient().init(); 
  
   } 
  
  } 

//UDPEchoClientTimeout.java

import java.net.DatagramSocket;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.io.IOException;
import java.io.InterruptedIOException;

public class UDPEchoClientTimeout {

	private static final int TIMEOUT = 3000;   // 设置超时为3秒
	private static final int MAXTRIES = 5;     // 最大重发次数5次
	
	public static void main(String[] args) throws IOException {
	
	    if ((args.length < 2) || (args.length > 3)) { // Test for correct # of args
	      throw new IllegalArgumentException("Parameter(s): <Server> <Word> [<Port>]");
	    }
	    InetAddress serverAddress = InetAddress.getByName(args[0]); // 服务器地址
	    // Convert the argument String to bytes using the default encoding
	    //发送的信息
	    byte[] bytesToSend = args[1].getBytes();
	
	    int servPort = (args.length == 3) ? Integer.parseInt(args[2]) : 7;
	
	    DatagramSocket socket = new DatagramSocket();
	
	    socket.setSoTimeout(TIMEOUT); // 设置阻塞时间
	
	    DatagramPacket sendPacket = new DatagramPacket(bytesToSend, // 相当于将发送的信息打包
	        bytesToSend.length, serverAddress, servPort);
	
	    DatagramPacket receivePacket =                              // 相当于空的接收包
	        new DatagramPacket(new byte[bytesToSend.length], bytesToSend.length);
	
	    int tries = 0;      // Packets may be lost, so we have to keep trying
	    boolean receivedResponse = false;
	    do {
	      socket.send(sendPacket);          // 发送信息
	      try {
	        socket.receive(receivePacket); // 接收信息
	
	        if (!receivePacket.getAddress().equals(serverAddress)) {// Check source
	          throw new IOException("Received packet from an unknown source");
	        }
	        receivedResponse = true;
	      } catch (InterruptedIOException e) { // 当receive不到信息或者receive时间超过3秒时，就向服务器重发请求
	        tries += 1;
	        System.out.println("Timed out, " + (MAXTRIES - tries) + " more tries...");
	      }
	    } while ((!receivedResponse) && (tries < MAXTRIES));
	
	    if (receivedResponse) {
	      System.out.println("Received: " + new String(receivePacket.getData()));
	    } else {
	      System.out.println("No response -- giving up.");
	    }
	    socket.close();
	}
}

//UDPEchoServer.java
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDPEchoServer {

	private static final int ECHOMAX = 255; // 发送或接收的信息最大字节数
	
	public static void main(String[] args) throws IOException {
	
	    if (args.length != 1) { // Test for correct argument list
	      throw new IllegalArgumentException("Parameter(s): <Port>");
	    }
	
	    int servPort = Integer.parseInt(args[0]);
	
	    DatagramSocket socket = new DatagramSocket(servPort);
	    DatagramPacket packet = new DatagramPacket(new byte[ECHOMAX], ECHOMAX);
	
	    while (true) { // 不断接收来自客户端的信息及作出相应的相应
	      socket.receive(packet); // Receive packet from client
	      System.out.println("Handling client at " + packet.getAddress().getHostAddress() + " on port " + packet.getPort());
	      socket.send(packet); // 将客户端发送来的信息返回给客户端
	      packet.setLength(ECHOMAX); 
		 // 重置packet的内部长度，因为处理了接收到的信息后，数据包的内部长度将被                                                       
		 //设置为刚处理过的信息的长度，而这个长度可能比缓冲区的原始长度还要短，
		 //如果不重置，而且接收到的新信息长于这个内部长度，则超出长度的部分将会被截断，所以这点必须注意到。
	    }
	    /* NOT REACHED */
	}
}