学习Java第二十一天（一）：1、基于UDP协议的通信程序

1、基于UDP协议的通信程序

1. 什么是UDP,它的优缺点是什么？

   UDP:用户数据报协议（无连接的协议）

   缺点：不能保证数据的安全与可靠

   优点：消耗小，效率高

2. 建立基于UDP的网络通讯程序需要使用的类和常用方法

   基于UDP的网络通讯程序是不区分客户端和服务器

   java.net.DatagramPacket---该类表示数据报包。（打包被发送的数据/接收发来的数据）

   构造方法：

   DatagramPacket(byte[] buf,int length)构造一个DatagramPacket用于接收长度的数据报length。（接收发来的数据的数据包）

   DatagramPacket(byte[] buf,int length,InetAddress address,int port)构造用于发送长度的分组的数据报包lenght,指定主机上到指定的端口号。（打包被发送的数据）

   实例方法：

   byte[] getData()返回数据缓冲区

   int getLength()返回要发送的数据的长度或接收的数据的长度。

   InetAddress getAddress()返回该数据包发送或接收数据报的计算机的IP地址。

   int getPort()返回发送数据报的远程主机上的端口号，或从中接收数据报的端口号。

   java.net.DatagramSocket 此类表示用于发送和接收数据报数据包的套接字

   构造方法

   DatagramSocket()---构造数据报套接字并将其绑定到本地主机上的任何可用端口（发包）。

   DatagramSocket()---构造数据报套接字并将其绑定到本地主机上的指定端口（收包）。

   实例方法

   void send(DataramPacket p)从此套接字发送数据报包。

   void receive(DatagramPacket p)从此套接字接收数据报包。

   void close()关闭此数据报套接字。

3. 基于UDP协议的通信程序创建步骤：

   发送放步骤：

   1. 将需要发送的 数据通过

      DatagramPacket(byte[] buf,int length,InetAddress address,int port)构造方法打包好

   2. 通过DatagamSocket()的构造方法创建DatagamSocket对象。

   3. DatagramSocket对象的send方法将打包好的数据报包，发送。

   4. 关闭DatagramSocket。

   接收方步骤：

   1. 通过DatagramSocket(int port)创建接收数据的DatagramSocket对象。

   2. 通过DatagramPacket(byte[] buf,int length)创建一个空的数据报包。

   3. 通过调用接收数据的DatagramSocket对象的receive方法接收数据报包到空的数据报包。

   4. 解析数据报包。

   5. 关闭DatagramSocket。

   示例：

   //示例一：客户端向服务器端发送
   //客户端
   public class ClientTest {
       public static void main(String[] args) throws IOException {
           //准备需要发送的数据
           BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
           System.out.println("请输入需要发送的内容：");
           String info = bufferedReader.readLine();
           byte[] bytes = info.getBytes();
           int length = bytes.length;
           InetAddress localHost = InetAddress.getLocalHost();
           int port = 2000;
           DatagramPacket datagramPacket = new DatagramPacket(bytes, length, localHost, port);
           DatagramSocket datagramSocket = new DatagramSocket();
           datagramSocket.send(datagramPacket);
           datagramSocket.close();
       }
   }
   //服务端
   public class ServerTest {
       public static void main(String[] args) throws Exception {
           //创建接收数据包的DatagramSocket对象
           int port = 2000;
           DatagramSocket datagramSocket = new DatagramSocket(port);
           //创建一个空的数据包，DatagramPacket(byte[] buf,int length)
           byte[] bytes = new byte[1024];
           DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length);
           //接收数据
           datagramSocket.receive(datagramPacket);
           //解析数据
           byte[] data = datagramPacket.getData();
           int len = datagramPacket.getLength();
           String result = new String(data, 0, len);
           String hostAddress = datagramPacket.getAddress().getHostAddress();
           int port1 = datagramPacket.getPort();
           System.out.println("接收到来自" + hostAddress + ":" + port1 + " 的信息：" + result);
           datagramSocket.close();
       }
   }

//示例二：可以持续发送接收
public class ClientTest {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = null;
        String sendMsg = null;
        InetAddress serverAddress = null;
        int serverPort = 2000;
        DatagramPacket sendPacket = null;
        DatagramSocket sendSocket = null;
​
        reader = new BufferedReader(new InputStreamReader(System.in));
        serverAddress = InetAddress.getLocalHost();
        sendSocket = new DatagramSocket();
        boolean flag = true;
        while (flag) {
            System.out.println("请输入需要发送的内容：");
            sendMsg = reader.readLine();
            sendPacket = new DatagramPacket(sendMsg.getBytes(), sendMsg.length(), serverAddress, serverPort);
            sendSocket.send(sendPacket);
            if (sendMsg.equals("exit")) {
                flag = false;
            }
        }
        sendSocket.close();
    }
}
​
public class ServerTest {
    public static void main(String[] args) throws Exception {
        DatagramSocket receiveSocket = null;
        DatagramPacket receivePacket = null;
        String receiveMsg = null;
        InetAddress clientAddress = null;
        int serverPort = 2000;
        byte[] data = null;
        int len = 0;
        int port = 0;
​
        receiveSocket = new DatagramSocket(serverPort);
        byte[] bytes = new byte[1024];
        receivePacket = new DatagramPacket(bytes, bytes.length);
        boolean flag = true;
        while(flag) {
            receiveSocket.receive(receivePacket);
            data = receivePacket.getData();
            len = receivePacket.getLength();
            clientAddress = receivePacket.getAddress();
            port = receivePacket.getPort();
            String result = new String(data, 0, len);
            System.out.println("接收到来自：" + clientAddress.getHostAddress() + ":" + port + "的信息：" + result);
            if(result.equals("exit")){
                flag = false;
            }
        }
        receiveSocket.close();
    }
}

//实例三：双向发送，客户端发送给服务器端，服务器端收到后，响应回信息给客户端
public class ClientTest {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = null;
        String sendMsg = null;
        InetAddress serverAddress = null;
        int sendPort = 2000;
        DatagramPacket sendPacket = null;
        DatagramSocket sendSocket = null;
        byte[] data = null;
        int len = 0;
        int receivePort = 3000;
        //接收
        DatagramSocket receiveSocket = null;
        DatagramPacket receivePacket = null;
        receiveSocket = new DatagramSocket(receivePort);
        byte[] bytes = new byte[1024];
        receivePacket = new DatagramPacket(bytes, bytes.length);
​
        reader = new BufferedReader(new InputStreamReader(System.in));
        serverAddress = InetAddress.getLocalHost();
        sendSocket = new DatagramSocket();
        boolean flag = true;
        while (flag) {
            System.out.println("请输入需要发送的内容：");
            sendMsg = reader.readLine();
            sendPacket = new DatagramPacket(sendMsg.getBytes(), sendMsg.length(), serverAddress, sendPort);
            sendSocket.send(sendPacket);
​
            //接收
            receiveSocket.receive(receivePacket);
            data = receivePacket.getData();
            len = receivePacket.getLength();
            String result = new String(data, 0, len);
            System.out.println("服务器响应的信息：" + result);
            if (sendMsg.equals("exit")) {
                flag = false;
            }
        }
        sendSocket.close();
        receiveSocket.close();
    }
}
​
public class ServerTest {
    public static void main(String[] args) throws Exception {
        DatagramSocket receiveSocket = null;
        DatagramPacket receivePacket = null;
        String receiveMsg = null;
        InetAddress clientAddress = null;
        int serverPort = 2000;
        byte[] data = null;
        int len = 0;
        int port = 0;
        //发送
        String sendMsg = null;
        InetAddress serverAddress = null;
        int sendPort = 3000;
        DatagramPacket sendPacket = null;
        DatagramSocket sendSocket = null;
        serverAddress = InetAddress.getLocalHost();
        sendSocket = new DatagramSocket();
​
        receiveSocket = new DatagramSocket(serverPort);
        byte[] bytes = new byte[1024];
        receivePacket = new DatagramPacket(bytes, bytes.length);
        boolean flag = true;
        while(flag) {
            receiveSocket.receive(receivePacket);
            data = receivePacket.getData();
            len = receivePacket.getLength();
            clientAddress = receivePacket.getAddress();
            port = receivePacket.getPort();
            String result = new String(data, 0, len);
            System.out.println("接收到来自：" + clientAddress.getHostAddress() + ":" + port + "的信息：" + result);
​
            //发送
            sendMsg = "server---" + result;
            sendPacket = new DatagramPacket(sendMsg.getBytes(), sendMsg.length(), serverAddress, sendPort);
            sendSocket.send(sendPacket);
            if(result.equals("exit")){
                flag = false;
            }
        }
        receiveSocket.close();
    }
}