java UDP

java中UDP的实现氛围两个类:DatagramPacket 和 DatagramSocket

DatagramPacket类将数据填充到UDP包中,这称为数据报,有你来解包接受的数据报.

DatagramSocket可以收发UDP数据报,为收发送数据要将数据放到DatagramPacket中

两个参数的构造器用于接收数据报

四个参数的构造器用于发送数据报

一.客服端 

java编程思想UDP client实例

package test;
import java.net.*;
public class Dgram {
    public static DatagramPacket toDatagram(
            String s,InetAddress destIA,int destPort){
        byte[] buf = new byte[s.length() + 1];
        buf = s.getBytes();
        return new DatagramPacket(buf,buf.length,destIA,destPort);
    }
    public static String toString(DatagramPacket p){
        return new String(p.getData(),0,p.getLength());
    }
    
}

//: ChatterClient.java 
// Tests the ChatterServer by starting multiple  
// clients, each of which sends datagrams. 
package test;
import java.lang.Thread; 
import java.net.*; 
import java.io.*; 
 
public class ChatterClient extends Thread { 
  // Can listen & send on the same socket: 
  private DatagramSocket s; 
  private InetAddress hostAddress; 
  private byte[] buf = new byte[1000]; //设置数据包大小,要比发送的数据大
  private DatagramPacket dp =  
    new DatagramPacket(buf, buf.length); //
  private int id; 
 
  public ChatterClient(int identifier) { 
    id = identifier; 
    try { 
      // Auto-assign port number: 
      s = new DatagramSocket(0);//参数不填或是0的话 代表随机选择端口发送
      s.setSoTimeout(10000);//设置超时时间
      hostAddress =  
        InetAddress.getByName("106.13.46.152"); //获得连接端口
    } catch(UnknownHostException e) { 
      System.err.println("Cannot find host"); 
      System.exit(1); 
    } catch(SocketException e) { 
      System.err.println("Can't open socket"); 
      e.printStackTrace(); 
      System.exit(1); 
    }  
    System.out.println("ChatterClient starting"); 
  } 
  public void run() { 
    try { 
      for(int i = 0; i < 10; i++) { 
        String outMessage = "Client #" + 
          id + ", message #" + i; 

        // Make and send a datagram: 
        s.send(Dgram.toDatagram(outMessage, 
          hostAddress,  
          ChatterServer.INPORT)); //得到一个DatagramPacket数据包并发送
        // Block until it echoes back: 
        s.receive(dp); //接收数据报
        // Print out the echoed contents: 
        String rcvd = "Client #" + id + 
          ", rcvd from " +  
          dp.getAddress() + ", " +  
          dp.getPort() + ": " + 
          Dgram.toString(dp); 
//        String rcvd = new String(dp.getData(),0,dp.getLength(),"UTF-8");
        System.out.println(dp); 
      } 
    } catch(IOException e) { 
      e.printStackTrace(); 
      System.exit(1); 
    } 
  } 
  public static void main(String[] args) { 
    for(int i = 0; i < 10; i++) 
      new ChatterClient(i).start(); 
  } 
} ///:~

java 网络编程UDP实例

//: ChatterClient.java 
// Tests the ChatterServer by starting multiple  
// clients, each of which sends datagrams. 
package test;
import java.lang.Thread; 
import java.net.*; 
import java.io.*; 
 
public class ChatterClient extends Thread { 
  private final static int PORT = 5000;//要发送的端口
  private static final String HOSTNAME = "106.13.46.152";//要连连接的地址
  
  public static void main(String[] args){
	  try(DatagramSocket socket = new DatagramSocket(0)){//资源自动关闭
		  socket.setSoTimeout(10000);
		  InetAddress host = InetAddress.getByName(HOSTNAME);
		  DatagramPacket request = new DatagramPacket(new byte[1],1,host,PORT);//用于发送的数据报
		  DatagramPacket response = new DatagramPacket(new byte[1024],1024);//用于接收的数据报
		  socket.send(request);//发送
		  socket.receive(response);//接收
		  String result = new String(response.getData(),0,response.getLength(),"UTF-8");
		  System.out.println(result);
	  }catch(IOException e){
		 e.printStackTrace();
	  }
  }
} ///:~

　　

二.服务器

首先打开一个数据报

DatagramSocket socket = new DatagramSocket(1033) //在内Unix系统上小于1024的端口要root权限

接下来,创建一个接受请求的数据包

Datagrampacket request = new DatagramPacket(new byte[1024],0,1024) ;从0存储到1024

然后接收数据包

socket.receive(request);//这个调用将阻塞,直到接收到数据包

然后再创建一个响应数据包.包括四个部分:要发送的原始数据,待发送的原始数据的字节数,要发送到哪个主机,以及发送到该主机上哪个接口,

java网络编程示例:

package test;

import java.io.IOException;
import java.net.*;
import java.text.DateFormat;
import java.text.Format;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.logging.*;
public class DaytimeUDPServer {
    private final static int PORT = 1200;
    private final static Logger audit = Logger.getLogger("requests");
    private final static Logger errors = Logger.getLogger("errors");
    
    public static void main(String[] args){
        try(DatagramSocket socket = new DatagramSocket(PORT)){
            while(true){
                try{
                    System.out.println("start");
                    DatagramPacket requst = new DatagramPacket(new byte[1024],0,1024);
                    socket.receive(requst);
                    
                    DateFormat df = new SimpleDateFormat();
                    String daytime = df.format(new Date()).toString();
                    
                    
                    byte[] data = daytime.getBytes("UTF-8");
                    DatagramPacket send = new DatagramPacket(
                            data,data.length,requst.getAddress(),
                            requst.getPort());
                    socket.send(send);
                    audit.info(daytime + " " + requst.getAddress());
                }catch(IOException|RuntimeException e){
                    errors.log(Level.SEVERE,e.getMessage(), e);//发送错误到控制台
                }
            }
        }catch(IOException e){
              errors.log(Level.SEVERE,e.getMessage(),e);
        }
    }
}

 java 编程思想示例

package socket;
//: ChatterServer.java 
//A server that echoes datagrams 
import java.net.*; 
import java.io.*; 
import java.util.*; 

public class ChatterServer { 
static final int INPORT = 5000; 
private byte[] buf = new byte[1000]; 
private DatagramPacket dp =  
 new DatagramPacket(buf, buf.length); 
// Can listen & send on the same socket: 
private DatagramSocket socket; 

public ChatterServer() { 
 try { 
   socket = new DatagramSocket(INPORT); 
   System.out.println("Server started"); 
   while(true) { 
     // Block until a datagram appears: 
     socket.receive(dp); 
     String rcvd = Dgram.toString(dp) + 
       ", from address: " + dp.getAddress() + 
       ", port: " + dp.getPort(); 
     System.out.println(rcvd); 
     String echoString =  
       "Echoed: " + rcvd; 
     // Extract the address and port from the 
     // received datagram to find out where to 
     // send it back: 
     DatagramPacket echo =  
       Dgram.toDatagram(echoString, 
         dp.getAddress(), dp.getPort()); 
     socket.send(echo); 
   } 
 } catch(SocketException e) { 
   System.err.println("Can't open socket"); 
   System.exit(1); 
 } catch(IOException e) { 
   System.err.println("Communication error"); 
   e.printStackTrace(); 
 } 
} 
public static void main(String[] args) { 
 new ChatterServer(); 
} 
} ///:~