通过DatagramSocket实现UDP编程（十三）

原文链接：https://www.cnblogs.com/hysum/p/7533149.html

UDP通信：

• UDP协议(用户数据报协议)是无连接、不可靠、无序的。
• UDP协议以数据报作为数据传输的载体。
• 使用UDP进行数据传输时，首先需要将要传输的数据定义成数据报(Datagram),在数据报中指明所要达到的Socket(主机地址和端口号)，然后在将数据报发生出去。

相关操作类：

• DatagramPacket：表示数据报包
• DatagramSocket：进行端到端通信的类

一、DatagramPacket&DatagramSocket类的常用方法

1. DatagramPacket类

• DatagramPacket(byte[] buf,int length)//接受长度为length的数据包
• DatagramPacket(byte[] buf,int length,InetAddress address,int port)//将指定长度的字节发生到指定主机的指定端口

2. DatagramSocket类

构造方法：

• DatagramSocket();
• DatagramSocket(int port,InetAddress laddr);

常用方法：

• close();//关闭DatagramSocket
• getInetAddress();//获取地址
• getPort();//获取端口号
• send(DatagramPacket p);//从此套接字发送数据包
• recrive(DatagramPacket p);//从此套接字接收数据包

二、编程实现基于UDP的用户登录小程序

1. 服务端

• 创建DatagramSocket,指定端口号
• 创建DatagramPacket
• 接收客户端发送的数据信息
• 读取数据

public class UdpServer {
    public static void main(String[] args) throws IOException {
        try {
            /*
             * 接收客户端发送的数据
             */
            //1.创建服务器端DatagramSocket，指定端口
            DatagramSocket ds=new DatagramSocket(8080);
            //2.创建数据报DatagramPacket,用于接收客户端发送的数据
            byte[] data=new byte[1024];//创建字节数组，指定接受的数据报大小
            DatagramPacket dp=new DatagramPacket(data, data.length);
            //3.接收客户端发送的数据
            System.out.println("服务器端已启动，等待客户端发送数据...");
            ds.receive(dp);//此方法在接收到数据报之前会一直阻塞
            //4.读取数据
            //String info=Arrays.toString(data);
            String info=new String(data, 0, dp.getLength());
            System.out.println("我是服务器，客户端说："+info);
            /*
             * 响应客户端
             */
            //1.定义客户端的地址、端口号、数据
            InetAddress add=dp.getAddress();
            int port=dp.getPort();
            byte[] data2="欢迎您！".getBytes();
            //2.创建数据报，包含响应的数据信息
            DatagramPacket dp2=new DatagramPacket(data2, data2.length, add, port);
            //3.响应客户端
            ds.send(dp2);
            //4.关闭资源
            ds.close();

        } catch (SocketException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2. 客户端

• 定义发送信息
• 创建DatagramPacket：包含将要发送信息
• 创建DatagramSocket
• 发送数据

public class UdpClient {
    public static void main(String[] args) throws IOException {
        /*
         * 向服务器发送数据
         */
        //1.定义服务器的地址、端口号、数据
        InetAddress add=InetAddress.getByName("localhost");
        int port=8080;
        byte[] data="用户名：admin；密码：123".getBytes();
        //2.创建数据报,包含了发送的相关信息
        DatagramPacket ap=new DatagramPacket(data, data.length, add, port);
        //3.创建DatagramSocket对象
        DatagramSocket ds=new DatagramSocket();
        //4.向服务器端发送数据报
        ds.send(ap);
        /*
         * 接收服务器端的响应
         */
        //1.创建数据报DatagramPacket,用于接收服务器发送的数据
        byte[] data2=new byte[1024];
        DatagramPacket dp2= new DatagramPacket(data2, data2.length);
        //2.接收响应
        ds.receive(dp2);
        //3.读取数据
        String info=new String(data2, 0, dp2.getLength());
        System.out.println("我是客户端，服务器说："+info);
        //4.关闭资源
        ds.close();
    }

}

三、使用多线程实现多客户端的通信

多线程基本步骤：

• 服务器端创建DatagramSocket，循环调用receive()等待客户端发送数据报。
• 客户端创建一个DatagramSocket发送数据报到服务器端。
• 服务器端接收客户端的数据报，创建DatagramPacket与该客户建立专线接收数据报。
• 建立交互数据报在一个单独的线程上对话。
• 服务器端继续等待新的数据报。

新建一个服务器线程处理类UDPServerThread，该类继承Thread类：

/*
 * 服务器线程处理类
 */
public class UDPServerThread extends Thread {
    DatagramSocket ds = null;
    DatagramPacket dp = null;

    public UDPServerThread(DatagramSocket ds, DatagramPacket dp) {
        this.ds = ds;
        this.dp = dp;
    }

    public void run() {
        try {
            /*
             * 接收客户端发送的数据
             */

            // 4.读取数据
            // String info=Arrays.toString(data);
            byte[] data = dp.getData();
            String info = new String(data, 0, dp.getLength());
            System.out.println("我是服务器，客户端说：" + info);
            /*
             * 响应客户端
             */
            // 1.定义客户端的地址、端口号、数据
            InetAddress add = dp.getAddress();
            int port = dp.getPort();
            byte[] data2 = "欢迎您！".getBytes();
            // 2.创建数据报，包含响应的数据信息
            DatagramPacket dp2 = new DatagramPacket(data2, data2.length, add, port);
            // 3.响应客户端
            ds.send(dp2);

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

服务端：

/*
 * 服务器端
 */
public class UDPSever {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub

        try {

            // 1.创建服务器端DatagramSocket，指定端口
            DatagramSocket ds = new DatagramSocket(8080);
            System.out.println("服务器即将启动，等待客户端的连接...");
            byte[] data = new byte[1024];
            // 记录客户端的数量
            int count = 0;
            // 循环侦听等待客户端的连接
            while (true) {
                DatagramPacket dp = new DatagramPacket(data, data.length);
                ds.receive(dp);
                // 创建一个新的线程
                UDPServerThread udp = new UDPServerThread(ds, dp);
                // 启动线程，执行与客户端的交互
                udp.start();
                count++;
                System.out.println("此时客户端数量为：" + count);
                InetAddress add = dp.getAddress();
                System.out.println("当前客户端的ip地址为" + add.getHostAddress());
            }

        } catch (SocketException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}