Socket实现数据通信（3）——基于DatagramSocket实现服务器与客户端之间简单的通讯_datagramsocket = new datagramsocket

        在上一篇中，我们通过Socket基于TCP协议利用多线程技术实现了客户端与服务器之间的长连接通讯。今天，我们就来介绍Socket通讯中另一种经常使用的协议UDP。UDP协议对应于应用层封装的API是DatagramSocket。

• public class DatagramSocket
  extends Object
  implements Closeable
  

  此类表示用于发送和接收数据报数据包的套接字。

  数据报套接字是分组传送服务的发送或接收点。 在数据报套接字上发送或接收的每个数据包都被单独寻址和路由。 从一个机器发送到另一个机器的多个分组可以不同地路由，并且可以以任何顺序到达。

  在可能的情况下，新构建的DatagramSocket启用了SO_BROADCAST套接字选项，以允许广播数据报的传输。 为了接收广播数据包，DatagramSocket应该绑定到通配符地址。 在一些实现中，当DatagramSocket绑定到更具体的地址时，也可以接收广播分组。

上面是API给出介绍，这里正如在第一篇中关于Socket的基本概念描述的那样，通过UDP进行数据传输是不需要与服务器建立连接的。其构造方法有如下几个（文档内容）：

 

	DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口。
protected	DatagramSocket(DatagramSocketImpl impl) 使用指定的DatagramSocketImpl创建一个未绑定的数据报套接字。
	DatagramSocket(int port) 构造数据报套接字并将其绑定到本地主机上的指定端口。
	DatagramSocket(int port, InetAddress laddr) 创建一个数据报套接字，绑定到指定的本地地址。
	DatagramSocket(SocketAddress bindaddr) 创建一个数据报套接字，绑定到指定的本地套接字地址。

 

 

我们今天主要用到第三个（服务端）和第四个（客户端）。其对外的接口和Socket十分类似。当然和流相关的就没有了，取而代之的是对DatagramPacket的get/set。我们知道，基于UDP协议传输数据，是以数据报的方式，需要先把数据（通常是byte[]）数据封装在数据报DatagramPacket中进行传输。下面还是举一个实例看一下比较清楚，Demo功能很简单，客户端每向服务器发一条数据，服务器都会在收到的数据前加一个字符串返回给客户端。下面先看服务端代码UdpServer.java：

package hfut.edu.datagramSocket;
 
import java.net.DatagramPacket;
import java.net.DatagramSocket;
 
public class UdpServer {
 
 
	public static void main(String[] args) {
 
		try {
			DatagramSocket server = new DatagramSocket(88);
			int len = 1024;
			byte[] dataIn = new byte[len];
			byte[] dataOut;
 
			DatagramPacket dataPackageIn = new DatagramPacket(dataIn, len);
			DatagramPacket dataPackageOut = null;
            
			System.out.println("server 127.0.0.1准备接收数据...");
			for (int i = 0; i < 100; i++) {
				server.receive(dataPackageIn);// 接收client数据
				System.out.println("msg from client:" + new String(dataIn, 0, dataPackageIn.getLength()));
				dataOut = ("I am server,"+new String(dataIn, 0, dataPackageIn.getLength())).getBytes();
				dataPackageOut = new DatagramPacket(dataOut, dataOut.length, dataPackageIn.getSocketAddress());
				server.send(dataPackageOut);// 返回数据给client
			}
 
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
 
	}
}

客户端代码UdpClient.java代码：

package hfut.edu.datagramSocket;
 
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.util.Scanner;
 
public class UdpClient {
 
	public static void main(String[] args) {
		try {
 
			InetSocketAddress address = new InetSocketAddress("127.0.0.1", 88);
			int len = 1024;
			byte[] dataIn = new byte[len];
			DatagramPacket dataPackageIn = new DatagramPacket(dataIn, len);// 接收数据
			byte[] dataOut = null;
			DatagramPacket dataPackageOut = new DatagramPacket(new byte[0], 0, address);// 发送数据需要Address;
			DatagramSocket client = new DatagramSocket();
			System.out.println("client端：");
			Scanner sc = new Scanner(System.in);
			while (sc.hasNextLine()) {
				dataOut = sc.nextLine().getBytes();
				dataPackageOut.setData(dataOut);// 获取键盘输入的数据
				client.send(dataPackageOut);// 发送数据给Server
				client.receive(dataPackageIn);// 接收客户端发来的数据
				System.out.println("msg from server:" + new String(dataIn, 0, dataPackageIn.getLength()));// 打印接收数据
			}
 
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
 
}

实现步骤：

（1）服务端创建数据发送和接收的DatagramSocket

（2）构建装载发送数据和接收数据的DatagramPacket容器

（3）调用DatagramSocket的receive()方法接收数据（阻塞式方法），接收到客户端发送数据后并响应，这里关于receive()方法的介绍我们可以简单的看一下（部分）：

/**
     * Receives a datagram packet from this socket. When this method
     * returns, the {@code DatagramPacket}'s buffer is filled with
     * the data received. The datagram packet also contains the sender's
     * IP address, and the port number on the sender's machine.
     * <p>
     * This method blocks until a datagram is received. The
     * {@code length} field of the datagram packet object contains
     * the length of the received message. If the message is longer than
     * the packet's length, the message is truncated.
     * <p>
     */

大概的意思是介绍了DatagramPacket中装载了哪些数据且明确说了这是一个阻塞式方法。客户端的实现步骤和上面差不多，主要是在创建DatagramSocket的时候传入的参数有所区别。

这里面我们只能客户端发送数据，服务端不能主动输入，那我们优化一下，修改服务端和客户端代码如下：

package hfut.edu.datagramSocket;
 
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.Scanner;
 
public class UdpCommunicateServer {
	public static void main(String[] args) {
		try {
			DatagramSocket server = new DatagramSocket(88);
			int len = 1024;
			byte[] dataIn = new byte[len];
			byte[] dataOut;
			DatagramPacket dataPackageIn = new DatagramPacket(dataIn, len);
			DatagramPacket dataPackageOut = null;
			Scanner sc = new Scanner(System.in);
			System.out.println("server 127.0.0.1准备接收数据...");
			for (int i = 0; i < 100; i++) {
				server.receive(dataPackageIn);// 接收client数据
				System.out.println("msg from client:" + new String(dataIn, 0, dataPackageIn.getLength()));
				while(sc.hasNextLine()) {
					dataOut=sc.nextLine().getBytes();
					dataPackageOut = new DatagramPacket(dataOut, dataOut.length, dataPackageIn.getSocketAddress());//获取键盘输入的数据
					server.send(dataPackageOut);// 发送数据给Server
					break;
				}
			}
 
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
 

上面的展示是一个比较友好的聊天方式，你一句我一句，下面看一个不理想的效果：

这个其实和基于TCP通讯一样的，因为receive()方法是一个阻塞式方法，结合上面的逻辑不难发现这个问题，当然，解决这个问题也是很容易的。只需要把接收和发送放在不同的线程中就可以了。下面给出最终的代码，其中服务端代码：

package hfut.edu.datagramSocket;
 
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketAddress;
import java.util.Scanner;
 
public class UdpTalkServer {
 
	public static void main(String[] args) {
		try {
			DatagramSocket server = new DatagramSocket(22222);
			int len = 1024;
			byte[] dataIn = new byte[len];
			DatagramPacket dataPackageIn = new DatagramPacket(dataIn, len);
			System.out.println("server 127.0.0.1准备接收数据...");
			for (int i = 0; i < 100; i++) {
				server.receive(dataPackageIn);// 接收client数据
				if (i == 0) {//有客户端发送数据，开启一个线程来用于响应
					new SendMsgThread(server, dataPackageIn.getSocketAddress()).start();// 在收到客户端连接后开启发送线程
				}
				System.out.println("msg from client:" + new String(dataIn, 0, dataPackageIn.getLength()));
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
 
/**
 * 发送数据线程
 * 
 */
class SendMsgThread extends Thread {
 
	DatagramSocket server;
	//直接传DatagramPacket有问题可以测试
	SocketAddress address;
	public SendMsgThread(DatagramSocket server, SocketAddress address) {
		this.server = server;
		this.address = address;
	}
 
	@Override
	public void run() {
		// TODO 监听键盘数据输入
		System.out.println("服务端发送线程已经开启...");
		try {
			byte[] dataOut = null;
			DatagramPacket dataPackageOut = null;
			Scanner sc = new Scanner(System.in);
			while (sc.hasNextLine()) {
				dataOut = sc.nextLine().getBytes();// 获取键盘输入的数据
				dataPackageOut = new DatagramPacket(dataOut, dataOut.length, address);
				server.send(dataPackageOut);// 发送数据给Server
			}
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("异常了" + e.getMessage());
		}
	}
}

客户端代码如下：

package hfut.edu.datagramSocket;
 
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.util.Scanner;
 
public class UdpTalkClient {
 
	public static void main(String[] args) {
 
		InetSocketAddress address = new InetSocketAddress("127.0.0.1", 22222);
		byte[] dataOut = null;
		DatagramPacket dataPackageOut = new DatagramPacket(new byte[0], 0, address);// 发送数据需要Address;
 
		try {
			DatagramSocket client = new DatagramSocket();
			System.out.println("client端：");
			new ReceiveMsgThread(client).start();//开启接收数据线程
			Scanner sc = new Scanner(System.in);
			while (sc.hasNextLine()) {
				dataOut = sc.nextLine().getBytes();
				dataPackageOut.setData(dataOut);// 获取键盘输入的数据
				client.send(dataPackageOut);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} // 发送数据给Server
	}
}
 
/**
 * 接收消息线程
 *
 */
class ReceiveMsgThread extends Thread {
 
	DatagramSocket client;
	public ReceiveMsgThread(DatagramSocket client) {
		this.client = client;
	}
 
	@Override
	public void run() {
		int len = 1024;
		byte[] dataIn = new byte[len];
		DatagramPacket dataPackageIn = new DatagramPacket(dataIn, len);// 接收数据
		for (int i = 0; i < 100; i++) {
			try {
				client.receive(dataPackageIn);
				System.out.println("msg from server:" + new String(dataIn, 0,
						 dataPackageIn.getLength()));// 
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

最终的效果图如下：

到这里，我们使用Socket基于UDP协议就实现了客户端与服务端之间的通讯了。其实，关于DatagramSocket的API还有很多，这里用的较少，但是基本上都是一看就懂的接口。到这里，关于Socket基于UDP的通讯介绍就结束了。

注：欢迎扫码关注