Socket UDP学习案例

一. UDP协议定义

UDP协议的全称是用户数据报，在网络中它与TCP协议一样用于处理数据包。在OSI模型中，在第四层——传输层，与TCP处于同一层。UDP有不提供数据报分组、组装和不能对数据包的排序的缺点，也就是说，当报文发送之后，是无法得知其是否安全完整到达的。

 

二. 使用UDP的原因
它不属于连接型协议，因而具有资源消耗小，处理速度快的优点，所以通常音频、视频和普通数据在传送时使用UDP较多，因为它们即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。比如我们聊天用的ICQ和OICQ就是使用的UDP协议。在选择使用协议的时候，选择UDP必须要谨慎。在网络质量令人不十分满意的环境下，UDP协议数据包丢失会比较严重。

三. 在Java中使用UDP协议编程的相关类
1. InetAddress
用于描述和包装一个Internet IP地址。有如下方法返回实例：
getLocalhost()：返回封装本地地址的实例。

 

getAllByName(String host)：返回封装Host地址的InetAddress实例数组。

getByName(String host)：返回一个封装Host地址的实例。其中，Host可以是域名或者是一个合法的IP地址。
InetAddress.getByAddress(addr)：根据地址串返回InetAddress实例。
InetAddress.getByAddress(host, addr)：根据主机地符串和地址串返回InetAddress实例。

2. DatagramSocket
用于接收和发送UDP的Socket实例。该类有3个构造函数：
DatagramSocket()：通常用于客户端编程，它并没有特定监听的端口，仅仅使用一个临时的。程序会让操作系统分配一个可用的端口。
DatagramSocket(int port)：创建实例，并固定监听Port端口的报文。通常用于服务端

DatagramSocket(int port, InetAddress localAddr)：这是个非常有用的构建器，当一台机器拥有多于一个IP地址的时候，由它创建的实例仅仅接收来自LocalAddr的报文。
DatagramSocket具有的主要方法如下：
1）receive(DatagramPacket d)：接收数据报文到d中。receive方法产生一个“阻塞”。“阻塞”是一个专业名词，它会产生一个内部循环，使程序暂停在这个地方，直到一个条件触发。

2）send(DatagramPacket dp)：发送报文dp到目的地。

3）setSoTimeout(int timeout)：设置超时时间，单位为毫秒。

4）close()：关闭DatagramSocket。在应用程序退出的时候，通常会主动释放资源，关闭Socket，但是由于异常地退出可能造成资源无法回收。所以，应该在程序完成时，主动使用此方法关闭Socket，或在捕获到异常抛出后关闭Socket。

3. DatagramPacket
用于处理报文，它将Byte数组、目标地址、目标端口等数据包装成报文或者将报文拆卸成Byte数组。应用程序在产生数据包是应该注意，TCP/IP规定数据报文大小最多包含65507个，通常主机接收548个字节，但大多数平台能够支持8192字节大小的报文。DatagramPacket类的构建器共有4个：
DatagramPacket(byte[] buf, int length)：将数据包中Length长的数据装进Buf数组，一般用来接收客户端发送的数据。
DatagramPacket(byte[] buf, int offset, int length)：将数据包中从Offset开始、Length长的数据装进Buf数组。
DatagramPacket(byte[] buf, int length, InetAddress clientAddress, int clientPort)：从Buf数组中，取出Length长的数据创建数据包对象，目标是clientAddress地址，clientPort端口,通常用来发送数据给客户端。

DatagramPacket(byte[] buf, int offset, int length, InetAddress clientAddress, int clientPort)：从Buf数组中，取出Offset开始的、Length长的数据创建数据包对象，目标是clientAddress地址，clientPort端口，通常用来发送数据给客户端。
主要的方法如下：
1）getData(): 从实例中取得报文的Byte数组编码。
2）setDate(byte[] buf)：将byte数组放入要发送的报文中。
四. 实例解析
下面让我们来看一个UDP的服务端和客户端交互通信的例子，在本例中，服务端循环等待客户端发送的信息，并对其进行回应，客户端向服务端发送信息，并接收服务端的回应信息。代码如下：
1.UDP的服务端程序
 


 

 
 

下面是模拟QQ对话的案例

实体类（封装的传输信息）

package com.javase.socket.UDPDemo;

import java.io.Serializable;
import java.util.Map;

public class MessageInfo implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	private String username;
	private String ip;
	private Integer port;
	private Map<String,Object> map = null;
	private String info;
	public String getIp() {
		return ip;
	}
	public void setIp(String ip) {
		this.ip = ip;
	}
	public void setPort(Integer port) {
		this.port = port;
	}
	public Map<String, Object> getMap() {
		return map;
	}
	public void setMap(Map<String, Object> map) {
		this.map = map;
	}
	public String getInfo() {
		return info;
	}
	public void setInfo(String info) {
		this.info = info;
	}
	public Integer getPort() {
		return port;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
}

 

 

Servie(服务端)

 

package com.javase.socket.UDPDemo;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.util.Scanner;

public class Service extends Thread {
	//定义服务器端连接客户端的对象
    private DatagramSocket serverSocket = null;
    //初始化数据报
    private DatagramPacket  packet = null;
    //初始化服务器地址对象
    private InetSocketAddress address = null;
    //初始化客户端地址对象
    private InetSocketAddress addressClient = null;
    private Scanner scanner = null;
	/**
	 *构造方法 
	 */
	public Service(){
		
	} 
	
	/**
	 *构造方法 
	 */
	public Service(String addr,Integer port){
		try {
			init(addr,port);
		} catch (SocketException e) {
			e.printStackTrace();
		}
	} 
	
	/**
	 *初始化相关数据
	 * @throws SocketException 
	 */
	public void init(String addr,Integer port) throws SocketException{
		address = new InetSocketAddress(addr, port);
		serverSocket = new DatagramSocket(address);
		scanner= new Scanner(System.in);
	}
	/**
	 *线程的运行方法
	 */
	@Override
	public void run() {
		System.out.println("XXX聊天窗口已经启动........................");
		byte[] data = null;
		try {
		    while(true){
		    	data = new byte[1024];
		    	//接收客户端数据
				MessageInfo messageInfo = (MessageInfo) receiveRequestClient(data);
				//响应客户端数据
				//InetAddress address =  InetAddress.getByName(messageInfo.getIp());
				InetAddress address  =packet.getAddress();
				//int port = messageInfo.getPort();
				int port = packet.getPort();
				System.out.println(messageInfo.getUsername()+"说："+messageInfo.getInfo());
				//响应
				messageInfo = new MessageInfo();
				System.out.print("XXX说：");
				String info  =scanner.next();
				System.out.println();
				messageInfo.setInfo(info);
				messageInfo.setUsername("XXX");
				addressClient = new InetSocketAddress(address, port);
				ByteArrayOutputStream bs=new ByteArrayOutputStream();
			    ObjectOutputStream bo=new ObjectOutputStream(bs);
			    bo.writeObject(messageInfo);
			    byte[] dataClient = null;
			    dataClient=bs.toByteArray();    
				sendResposeClient(dataClient, addressClient);
		    }
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
	/**
	 *接收客户端的请求 (接收数据之前处于阻塞状态)
	 * @throws IOException 
	 * @throws ClassNotFoundException 
	 */
	public Object receiveRequestClient(	byte[] data) throws IOException, ClassNotFoundException{
		//初始化数据报
		packet = new DatagramPacket(data, data.length);
		//等待接收数据
		serverSocket.receive(packet);
		//将读过来的数据转换成字符串
	     ByteArrayInputStream bs=new ByteArrayInputStream(packet.getData());
         ObjectInputStream os=new ObjectInputStream(bs);
         MessageInfo message = (MessageInfo)os.readObject();
         return message;
	}
	/**
	 *响应客户端的请求 
	 * @throws IOException 
	 */
	public void sendResposeClient(byte[] data,InetSocketAddress address) throws IOException{
		//初始化一个数据报信息
		packet = new DatagramPacket(data, data.length, address);
        //发送
		serverSocket.send(packet);
	}
	/**
	 *关闭dagramSocket、
	 *
	 */
	public void closeServer(){
		
	}
	public static void main(String[] args) {
		Service service = new Service("localhost", 8091);
		service.start();
	}
}

 Client（客户端）

 

 

package com.javase.socket.UDPDemo;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Scanner;

public class Client extends Thread {
	//定义服务器端连接客户端的对象
    private DatagramSocket serverSocket = null;
    //初始化数据报
    private DatagramPacket  packet = null;
    //初始化服务器地址对象
    private InetSocketAddress address = null;
    //初始化客户端地址对象
    private InetSocketAddress addressClient = null;
    private InetAddress inetAddress = null;
    private Scanner scanner = null;
	/**
	 * 构造方法
	 */
    public Client(){
    	
    }
    /**
	 * 构造方法
	 */
    public Client(String ip,Integer port){
    	try {
			init(ip,port);
		} catch (SocketException e) {
			e.printStackTrace();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}
    }
    
    /**
	 *初始化相关数据
	 * @throws SocketException 
     * @throws UnknownHostException 
	 */
	public void init(String ip,Integer port) throws SocketException, UnknownHostException{
		serverSocket = new DatagramSocket();
		inetAddress = InetAddress.getByName(ip);
		address = new InetSocketAddress(inetAddress, port);
		scanner= new Scanner(System.in);
	}
    /**
     *线程的执行方法
     */
	@Override
	public void run() {
		System.out.println("XXX开启对话.............");
		MessageInfo message = null;
		try {
			while(true){
				System.out.print("XXX说：");
				String info = scanner.next();
				System.out.println();
				message = new MessageInfo();
				message.setIp("localhost");
				message.setPort(12581);
				message.setInfo(info);
				message.setUsername("XXX");
				byte[] data=null;
		        ByteArrayOutputStream bs=new ByteArrayOutputStream();
		        ObjectOutputStream bo=new ObjectOutputStream(bs);
		        bo.writeObject(message);
		        data=bs.toByteArray();    
				sendRequestServer(data, address);
				byte[] dataClient = new byte[1024];
				receiveResponseServer(dataClient);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 *响应客户端的请求
	 * @throws IOException 
	 * @throws ClassNotFoundException 
	 */
	public void receiveResponseServer(	byte[] data) throws IOException, ClassNotFoundException{
		//初始化数据报
		packet = new DatagramPacket(data, data.length);
		//等待接收数据
		serverSocket.receive(packet);
		ByteArrayInputStream bs=new ByteArrayInputStream(packet.getData());
	    ObjectInputStream os=new ObjectInputStream(bs);
	    MessageInfo message = (MessageInfo)os.readObject();
	    System.out.println(message.getUsername()+"说："+message.getInfo());
	}
	/**
	 *发送客户端的请求 
	 * @throws IOException 
	 */
	public void sendRequestServer(byte[] data,InetSocketAddress address) throws IOException{
		//初始化一个数据报信息
		packet = new DatagramPacket(data, data.length, address);
        //发送
		serverSocket.send(packet);
	}
	public static void main(String[] args) {
		Client client = new Client("localhost", 8091);
		client.setPriority(4);
		client.start();
	}
}