一、前言：認識UDP

UDP，全稱User Datagram Protocol(用戶資料報協議)，是Internet 協議集支持一個無連接的傳輸協議，UDP 為應用程式提供了一種無需建立連接就可以發送封裝的 IP 資料包的方法，

UDP主要用于不要求分組順序到達的傳輸中，分組傳輸順序的檢查與排序由應用層完成，提供面向報文的簡單不可靠資訊傳送服務，UDP 協議基本上是IP協議與上層協議的介面，適用埠分別運行在同一臺設備上的多個應用程式，

二、UDP的特點(與TCP相比)

正是UDP提供不可靠服務，具有了TCP所沒有的優勢，無連接使得它具有資源消耗小，處理速度快的優點，所以音頻、視頻和普通資料在傳送時經常使用UDP，偶爾丟失一兩個資料包，也不會對接收結果產生太大影響，

UDP有別于TCP，有自己獨立的套接字(IP+Port)，它們的埠號不沖突，和TCP編程相比，UDP在使用前不需要進行連接，沒有流的概念，
如果說TCP協議通信與電話通信類似，那么UDP通信就與郵件通信類似：不需要實時連接，只需要目的地址；
UDP通信前不需要建立連接，只要知道地址（ip地址和埠號）就可以給對方發送資訊；
基于用戶資料報文（包）讀寫；
UDP通信一般用于線路質量好的環境，如局域網內，如果是互聯網，往往應用于對資料完整性不是過于苛刻的場合，例如語音傳送等，

以上是對UDP的基本認識，與以前學習的理論相比，接下來的實踐更加有趣，實踐出真知，

三、UDP網路Socket編程(Java實作)

首先，熟悉java中UDP編程的幾個關鍵類：DatagramSocket（套接字類），DatagramPacket（資料報類），MulticastSocket，本篇主要使用前兩個，

1、創建客戶端

第一步，實體化一個資料報套接字，用于與服務器端進行通信，與TCP不同，UDP中只有DatagramSocket一種套接字，不區分服務端和客戶端，創建的時候并不需要指定目的地址，這也是TCP協議和UDP協議最大的不同點之一，

public UDPClient(String remoteIP,String remotePort) throws IOException{
        this.remoteIP=InetAddress.getByName(remoteIP);
        this.remotePort=Integer.parseInt(remotePort);
        //創建UDP套接字，系統隨機選定一個未使用的UDP埠系結
        socket=new DatagramSocket();
}

第二步，創建UDP資料報，實作發送和接收資料的方法，UDP發送資料是基于報文DatagramPacket，網路中傳遞的UDP資料都要封裝在這種自包含的報文中，

實作DatagramPacket發送資料的方法：

//定義一個資料的發送方法
public void send(String msg){
    try {
        //將待發送的字串轉為位元組陣列
        byte[] outData=msg.getBytes("utf-8");
        //構建用于發送的資料報文，構造方法中傳入遠程通信方（服務器）的ip地址和埠
        DatagramPacket outPacket=new DatagramPacket(outData,outData.length,remoteIP,remotePort);
        //給UDP發送資料報
        socket.send(outPacket);
    }catch (IOException e){
            e.printStackTrace();
     }
}

DatagramPacket接收資料的方法：

public String receive(){
    String msg;
    //準備空的資料報文
    DatagramPacket inPacket=new DatagramPacket(new byte[MAX_PACKET_SIZE],MAX_PACKET_SIZE);
    try {
        //讀取報文，阻塞陳述句，有資料就裝包在inPacket報文中，以裝完或裝滿為止
        socket.receive(inPacket);
        //將接收到的位元組陣列轉為對應的字串
        msg=new String(inPacket.getData(),0,inPacket.getLength(),"utf-8");
    } catch (IOException e) {
        e.printStackTrace();
        msg=null;
    }
    return msg;
}

可以看到，發送和接收資料中使用DatagramSocket的實體的send和receive方法，這就是資料報套接字的兩個重要方法，

通信結束，銷毀Socket的方法如下：

public void close(){
    if (socket!=null)
        socket.close();
}

到這里，客戶端已全部完成，等待接下來與服務端的通信...

2、客戶端圖形界面

現在，設計客戶端通信的簡單界面，一方面可以更方便的和服務器連續對話通信，另一方面，有了圖形界面，體驗感更加！圖形化界面主要使用JavaFX實作，代碼容易看懂，

import javafx.application.Application;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyEvent;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

import java.io.IOException;


public class UDPClientFX extends Application {

    private Button btnExit=new Button("退出");
    private Button btnSend = new Button("發送");

    private TextField tfSend=new TextField();//輸入資訊區域

    private TextArea taDisplay=new TextArea();//顯示區域
    private TextField ipAddress=new TextField();//填寫ip地址
    private TextField tfport=new TextField();//填寫埠
    private Button btConn=new Button("連接");
    private UDPClient UDPClient;

    private String ip;
    private String port;


    @Override
    public void start(Stage primaryStage) {
        BorderPane mainPane=new BorderPane();

        //連接服務器區域
        HBox hBox1=new HBox();
        hBox1.setSpacing(10);
        hBox1.setPadding(new Insets(10,20,10,20));
        hBox1.setAlignment(Pos.CENTER);
        hBox1.getChildren().addAll(new Label("ip地址："),ipAddress,new Label("埠："),tfport,btConn);
        mainPane.setTop(hBox1);

        VBox vBox=new VBox();
        vBox.setSpacing(10);

        vBox.setPadding(new Insets(10,20,10,20));
        vBox.getChildren().addAll(new Label("資訊顯示區"),taDisplay,new Label("資訊輸入區"),tfSend);

        VBox.setVgrow(taDisplay, Priority.ALWAYS);
        mainPane.setCenter(vBox);


        HBox hBox=new HBox();
        hBox.setSpacing(10);
        hBox.setPadding(new Insets(10,20,10,20));
        hBox.setAlignment(Pos.CENTER_RIGHT);
        hBox.getChildren().addAll(btnSend,btnExit);
        mainPane.setBottom(hBox);

        Scene scene =new Scene(mainPane,700,500);
        primaryStage.setScene(scene);
        primaryStage.show();

        //連接服務器之前，發送bye后禁用發送按鈕，禁用Enter發送資訊輸入區域，禁用下載按鈕
        btnSend.setDisable(true);
        tfSend.setDisable(true);

        //連接按鈕
        btConn.setOnAction(event -> {
            ip=ipAddress.getText().trim();
            port=tfport.getText().trim();

            try {
                UDPClient = new UDPClient(ip,port);
                //連接服務器之后未結束服務前禁用再次連接
                btConn.setDisable(true);
                //重新連接服務器時啟用輸入發送功能
                tfSend.setDisable(false);
                btnSend.setDisable(false);
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        //發送按鈕事件
        btnSend.setOnAction(event -> {
            String msg=tfSend.getText();
            UDPClient.send(msg);//向服務器發送一串字符
            taDisplay.appendText("客戶端發送："+msg+"\n");

            String Rmsg=null;
            Rmsg=UDPClient.receive();
//            System.out.println(Rmsg);
            taDisplay.appendText(Rmsg+"\n");

            if (msg.equals("bye")){
                btnSend.setDisable(true);//發送bye后禁用發送按鈕
                tfSend.setDisable(true);//禁用Enter發送資訊輸入區域
                //結束服務后再次啟用連接按鈕
                btConn.setDisable(false);
            }
            tfSend.clear();
        });
        //對輸入區域系結鍵盤事件
        tfSend.setOnKeyPressed(new EventHandler<KeyEvent>() {
            @Override
            public void handle(KeyEvent event) {
               if(event.getCode()==KeyCode.ENTER){
                   String msg=tfSend.getText();
                   UDPClient.send(msg);//向服務器發送一串字符
                   taDisplay.appendText("客戶端發送："+msg+"\n");


                   String Rmsg=null;
                   Rmsg=UDPClient.receive();
                   taDisplay.appendText(Rmsg+"\n");

                   if (msg.equals("bye")){
                       tfSend.setDisable(true);//禁用Enter發送資訊輸入區域
                       btnSend.setDisable(true);//發送bye后禁用發送按鈕
                       //結束服務后再次啟用連接按鈕
                       btConn.setDisable(false);
                   }
                   tfSend.clear();
                }
            }
        });
        
        btnExit.setOnAction(event -> {
            try {
                exit();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });
        //表單關閉回應的事件,點擊右上角的×關閉,客戶端也關閉
        primaryStage.setOnCloseRequest(event -> {
            try {
                exit();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });


        //資訊顯示區滑鼠拖動高亮文字直接復制到資訊輸入框，方便選擇檔案名
        //taDispaly為資訊選擇區的TextArea，tfSend為資訊輸入區的TextField
        //為taDisplay的選擇范圍屬性添加監聽器，當該屬性值變化(選擇文字時)，會觸發監聽器中的代碼
        taDisplay.selectionProperty().addListener(((observable, oldValue, newValue) -> {
            //只有當滑鼠拖動選中了文字才復制內容
            if(!taDisplay.getSelectedText().equals(""))
                tfSend.setText(taDisplay.getSelectedText());
        }));
    }

    private void exit() throws InterruptedException {
        if (UDPClient!=null){
            //向服務器發送關閉連接的約定資訊
            UDPClient.send("bye");
            UDPClient.close();
        }
        System.exit(0);
    }

    
    public static void main (String[] args) {
            launch(args);
    }
}

重點在各個控制元件的事件處理邏輯上，需避免要一些誤操作導致例外拋出，如：連接服務器前禁用發送按鈕，在連接服務器成功后禁用連接按鈕，禁用輸入區等，另外，實作了回車發送的快捷功能，詳見代碼的鍵盤事件系結部分，

還有，約定發送"bye"或者退出按鈕結束通信關閉Socket，

成功連接后：

3、創建服務器端

服務器端為客戶端提供服務，實作通信，這里包括了幾個方法Service(),udpSend()和udpReceive().

首先，我將UDP資料報發送和接收寫成一個方法，作為整體方便多次呼叫，

public DatagramPacket udpReceive() throws IOException {
    DatagramPacket receive;
    byte[] dataR = new byte[1024];
    receive = new DatagramPacket(dataR, dataR.length);
    socket.receive(receive);
    return receive;
}

public void udpSend(String msg,InetAddress ipRemote,int portRemote) throws IOException {
    DatagramPacket sendPacket;
    byte[] dataSend = msg.getBytes();
    sendPacket = new DatagramPacket(dataSend,dataSend.length,ipRemote,portRemote);
    socket.send(sendPacket);
}

與TCP的Socket通信不同，需要將資料轉化成位元組資料形式，封裝成資料報進行傳輸，接收時決議資料為位元組，再進行讀取，

服務器端核心部分為Service()方法，實體化一個DatagramSocket類套接字，實作回圈與客戶端的通信，

與客戶端約定的結束標志"bye"進行處理，結束對話，

    public void Service() throws IOException {
        try {
            socket = new DatagramSocket(port);
            System.out.println("服務器創建成功，埠號：" + socket.getLocalPort());

            while (true) {

                //服務器接收資料
                String msg=null;
                receivePacket = udpReceive();
                InetAddress ipR = receivePacket.getAddress();
                int portR = receivePacket.getPort();
                msg = new String(receivePacket.getData(), 0, receivePacket.getLength(), "utf-8");

//                System.out.println("收到："+receivePacket.getSocketAddress()+"內容："+msg);

                if (msg.equalsIgnoreCase("bye")) {
                    udpSend("來自服務器訊息：服務器斷開連接，結束服務！",ipR,portR);
                    System.out.println(receivePacket.getSocketAddress()+"的客戶端離開，");
                    continue;
                }
                System.out.println("建立連接："+receivePacket.getSocketAddress());

                String now = new Date().toString();
                String hello = "From 服務器：&" + now + "&" + msg;
                udpSend(hello,ipR,portR);

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

四、服務器端和客戶端完整代碼

服務器端：

//UDPServer.java
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Date;

public class UDPServer {
    private DatagramSocket socket = null;
    private int port = 8888;
    private DatagramPacket receivePacket;

    public UDPServer() throws IOException {
        System.out.println("服務器啟動監聽在" + port + "埠...");
    }

    public void Service() throws IOException {
        try {
            socket = new DatagramSocket(port);
            System.out.println("服務器創建成功，埠號：" + socket.getLocalPort());

            while (true) {

                //服務器接收資料
                String msg=null;
                receivePacket = udpReceive();
                InetAddress ipR = receivePacket.getAddress();
                int portR = receivePacket.getPort();
                msg = new String(receivePacket.getData(), 0, receivePacket.getLength(), "utf-8");

//                System.out.println("收到："+receivePacket.getSocketAddress()+"內容："+msg);

                if (msg.equalsIgnoreCase("bye")) {
                    udpSend("來自服務器訊息：服務器斷開連接，結束服務！",ipR,portR);
                    System.out.println(receivePacket.getSocketAddress()+"的客戶端離開，");
                    continue;
                }
                System.out.println("建立連接："+receivePacket.getSocketAddress());

                String now = new Date().toString();
                String hello = "From 服務器：&" + now + "&" + msg;
                udpSend(hello,ipR,portR);

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

    public DatagramPacket udpReceive() throws IOException {
        DatagramPacket receive;
        byte[] dataR = new byte[1024];
        receive = new DatagramPacket(dataR, dataR.length);
        socket.receive(receive);
        return receive;
    }

    public void udpSend(String msg,InetAddress ipRemote,int portRemote) throws IOException {
        DatagramPacket sendPacket;
        byte[] dataSend = msg.getBytes();
        sendPacket = new DatagramPacket(dataSend,dataSend.length,ipRemote,portRemote);
        socket.send(sendPacket);
    }

    public static void main(String[] args) throws IOException {
        new UDPServer().Service();
    }
}

客戶端：

//UDPClient.java

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPClient {
    private int remotePort;
    private InetAddress remoteIP;
    private DatagramSocket socket;
    //用于接收資料的報文位元組陣列快取最最大容量，位元組為單位
    private static final int MAX_PACKET_SIZE=512;

    public UDPClient(String remoteIP,String remotePort) throws IOException{
        this.remoteIP=InetAddress.getByName(remoteIP);
        this.remotePort=Integer.parseInt(remotePort);
        //創建UDP套接字，系統隨機選定一個未使用的UDP埠系結
        socket=new DatagramSocket();

    }

    //定義一個資料的發送方法
    public void send(String msg){
        try {
            //將待發送的字串轉為位元組陣列
            byte[] outData=msg.getBytes("utf-8");
            //構建用于發送的資料報文，構造方法中傳入遠程通信方（服務器）的ip地址和埠
            DatagramPacket outPacket=new DatagramPacket(outData,outData.length,remoteIP,remotePort);
            //給UDP發送資料報
            socket.send(outPacket);
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    public String receive(){
        String msg;
        //準備空的資料報文
        DatagramPacket inPacket=new DatagramPacket(new byte[MAX_PACKET_SIZE],MAX_PACKET_SIZE);
        try {
            //讀取報文，阻塞陳述句，有資料就裝包在inPacket報文中，以裝完或裝滿為止
            socket.receive(inPacket);
            //將接收到的位元組陣列轉為對應的字串
            msg=new String(inPacket.getData(),0,inPacket.getLength(),"utf-8");
        } catch (IOException e) {
            e.printStackTrace();
            msg=null;
        }
        return msg;
    }

    public void close(){
        if (socket!=null)
            socket.close();
    }
}