UDP和TCP的区别与代码实现（详解）

---

一、传输层协议

UDP和TCP区别

UDP:无连接,不可靠传输,面向数据报,全双工.
TCP:有连接,可靠传输,面向字节流,全双工.

1.有连接,无连接:

2.可靠传输,不可靠传输

TCP是可靠传输, UDP是不可靠传输,因此TCP比 UD更安全.
错。安全：谈到"网络安全"
指的是,如果你传输的数据是否容易被黑客截获.以及如果被截获后是否会泄露一些重要信息.

3.面向字节流，面向数据报

面向字节流:
TCP和文件操作类似,都是“流”式的(由于这里传输的单位是字节,称为字节流)
如：

面向数据报:
UDP是面向数据报,读写的基本单位,是一个UDP数据报(包含了一系列的数据/属性)

4.全双工,半双工

全双工一个通道,可以双向通信
半双工一个通道,只能单向通信.

二、UDP代码实现

1.UDP的socket api.

两个核心的类.

1.DatagramSocket

是一个Socket对象，Java中的socket对象,就对应这系统里的socket文件.(最终还是要落到网卡)。要进行网络通信,必须得先有socket对象。

操作系统,使用文件这样的概念,来管理一些软硬件资源.
网卡,操作系统也是使用文件的方式来管理网卡的。表示网卡的这类文件,称为Socket 文件。

1.客户端给服务器发数据:
源端口：就是客户端的端口。目的端口：服务器的端口
2.服务器给客户端发数据:
源端口：服务器的端口。目的端口：客户端的端口

客户端端口号：让系统自动分配一个端口，不指定固定值。
（一个客户端的主机，上面运行的程序很多，天知道手动指定的端口是不是被别的程序占用了.让系统自动分配一个端口是更明智的选择。）
服务器端口号：程序员指定固定值。

2.DatagramPacket

表示了一个UDP数据报.
代表了系统中设定的UDP数据报的二进制结构

2.动手写udp服务器.

最简单的UDP服务器.回显服务器(echo server).客户端发啥,服务器返回啥

//UDP回显服务器
public class UdpEchoServer {
    private DatagramSocket socket=null;
    public UdpEchoServer(int port) throws SocketException {
        socket=new DatagramSocket(port);//当端口号被占用就new失败
    }
    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true){
            //反复长期执行针对客户端请求处理逻辑
            //1．读取请求,并解析
            DatagramPacket requestPacket=new DatagramPacket(new byte[4096],4096);
            //如果此时客户端的请求还没来,receive方法就会阻塞等待.=>阻塞到真正有客户端发起请求过来了.
            socket.receive(requestPacket);
            //这样转字符串的前提是，后续客户端发的数据就是一个文本的字符串
            String request=new String(requestPacket.getData(),0,requestPacket.getLength());
            //2．根据请求,计算出响应（具体做了啥，由于写的是回显服务器，没第二步）
            String responce=process(request);
            //3．把响应写回给客户端
            //告知网卡，需要发的内容是什么，要发给谁
            DatagramPacket responsePacket=new DatagramPacket(responce.getBytes(),responce.getBytes().length,
                    requestPacket.getSocketAddress());
            socket.send(responsePacket);
            //记录日志，方便观察程序执行效果
            System.out.printf("[%s:%d] req:%s\n",requestPacket.getAddress().toString(),
                    requestPacket.getPort(),request,responce);
        }
    }

    public String process(String request){
        return request;
    }
    public static void main(String[] args) throws IOException {
            UdpEchoServer server=new UdpEchoServer(9090);
            server.start();
    }
}

1）最典型的情况,端口号被占用.端口号用来区分主机上的应用程序。
一个应用程序可以占据主机上的多个端口。一个端口只能被一个进程占用.(这句话其实不够严谨,有特例, 此处不讨论)
端口已经被别的进程占用了，此时你再尝试创建这个socket对象，占用该端口，此时就会报错

2）一个服务器要给很多客户端提供服务.服务器也不知道客户端啥时候来.
服务器只能"时刻准备着"，随时客户端来了,就随时提供服务.




3）把响应写回给客户端，告知网卡，需要发的内容是什么，要发给谁。

3.动手写udp客户端

public class UdpEchoClient {
    private DatagramSocket socket=null;
    private String serverIp;
    private int serverPort;

    //服务器的ip，服务器的端口号
    public  UdpEchoClient(String ip,int port) throws SocketException {
        serverIp=ip;
        serverPort=port;
        //这个new操作就不再指定端口了，让系统自动分配一个空闲端口
        socket=new DatagramSocket();
    }
    //让这个客户端反复从控制台读取用户输入内容，把这个内容构造UDP请求发送给服务器
    //再读取服务器返回的UDP响应，最终显示在客户端的屏幕上。
    public void start() throws IOException {
        Scanner scanner=new Scanner(System.in);
        System.out.println("客户端启动");
        while (true){
            //1.从控制台读取用户输入内容
            System.out.println("->");
            String request=scanner.next();
            //2.构造一个请求对象并发给服务器
            DatagramPacket requestPacket=new DatagramPacket(request.getBytes(),request.getBytes().length
            , InetAddress.getByName(serverIp),serverPort);
            socket.send(requestPacket);
            //3.读取响应并解析响应内容
            DatagramPacket responcePacket=new DatagramPacket(new byte[4096],4096);//构造一个空的对象
            socket.receive(responcePacket);
            String response=new String(responcePacket.getData(),0,responcePacket.getLength());//从0开始
            //4.显示到屏幕上
            System.out.println(response);
        }
    }

    public static void main(String[] args) throws IOException {
        UdpEchoClient client=new UdpEchoClient("127.0.0.1",9090);
        client.start();
    }
}

客户端和服务器执行顺序如下：
下面的4是同时执行的。服务器端执行到4后继续执行，客户端执行到4阻塞等待直到服务器返回响应。

2)

启动多个客户端,多个客户端也是可以被服务器应对的
IDEA上启动多个程序,需要稍微设置一下:

#手动写TCP

1.TCP服务端

public class TcpEchoServer {
   private ServerSocket serverSocket=null;
   public  TcpEchoServer(int port)throws IOException {
       serverSocket=new ServerSocket(port);
   }
   public void start() throws IOException {
       System.out.println("服务器启动");
       while (true){
           //进入循环之后，要做的事情不是读取客户端的请求,而是先处理客户端的"连接"
           Socket clientSocket=serverSocket.accept();
           processConnection(clientSocket);
       }
   }

   private void processConnection(Socket clientSocket) {
       System.out.printf("[%s:%d]客户端上线\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
       //接下来就可以读取请求，根据请求计算响应，返回响应
       try(InputStream inputStream=clientSocket.getInputStream();
           OutputStream outputStream=clientSocket.getOutputStream()){
           //一次连接中可能有多次请求，响应
           while (true){
               //读取请求并解析，直接使用Scanner
               Scanner scanner=new Scanner(inputStream);
               if(!scanner.hasNext()){
                   //读取完毕，客户端下线
                   System.out.printf("[%s,%d] 客户端下线\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                   break;
               }
               //这个代码暗含约定，客户端发过来的请求，得是文本数据，同时暗含约定读到空白符结束
               String request=scanner.next();
               //根据请求计算响应
               String response=process(request);
               //把响应写回客户端
               PrintWriter writer=new PrintWriter(outputStream);
               //使用PrintWriter的printIn方法，把响应返回给客户端
               writer.println(response);
               writer.flush();//刷新缓冲区
               //日志
               System.out.printf("[%s:%d] req:%s,resp:%s\n",clientSocket.getInetAddress().toString(),clientSocket.getPort(),
                       request,response);
           }
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
   public  String process(String request){
       return request;
   }
   public static void main(String[] args) throws IOException {
       TcpEchoServer server=new TcpEchoServer(9090);
       server.start();
   }
}

在finally中加上close，确保socket及时关闭

2.TCP客户端

客户端代码～~要做的事情:
1.从控制台读取用户的输入
⒉.把输入的内容构造成请求并发送给服务器
3.从服务器读取响应
4.把响应显示到控制台上.

package TCP;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoClient {
    private Socket socket=null;
    //要和服务器通信要需先知道服务器位置
    public TcpEchoClient(String serverIp,int serverPort) throws IOException {
        //这个new操作完成，完成了tcp建立
        socket=new Socket(serverIp,serverPort);

    }
    public  void start(){
        System.out.println("客户端启动");
        Scanner scannerConsole=new Scanner(System.in);
        try(InputStream inputStream=socket.getInputStream();
            OutputStream outputStream=socket.getOutputStream()) {
            while (true){
                //1.从控制台输入字符串
                System.out.println("->");
                String request =scannerConsole.next();
                //2.把请求发送给服务器
                PrintWriter printWriter=new PrintWriter(outputStream);
                //使用printIn带上换行，后续服务器读取请求，就可以使用scanner.next来获取了
                printWriter.println(request);
                //不要忘记flush,确保数据发送
                printWriter.flush();
                //3.从服务器读取响应
                Scanner scannerNetwork=new Scanner(inputStream);
                String response=scannerNetwork.next();
                //4.把响应打印出来
                System.out.println(response);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws IOException {
        TcpEchoClient client=new TcpEchoClient("127.0.0.1",9090);
        client.start();

    }

}

注意点

当前代码还存在一个很大的问题!!
当启动两个客户端,会咋样??
现象:
当第一个客户端连接好了之后,第二个客户端,不能正确被处理.服务器看不到客户端上线,同时客户端发来的请求也无法被处理。

当第一个客户端退出之后,之前第二个客户端发的请求,就能正确响应了。

1.使用多线程完成：


2.使用线程池也可以解决上述问题