TCP/IP协议以及UDP(超详细,看这一篇就够了)

💓 博客主页：从零开始的-codeninja之路

⏩ 收录专栏：tcp/ip协议以及udp(超详细,看这一篇就够了)

🎉欢迎大家点赞👍评论📝收藏⭐文章

前提概括

首先进入本章知识重点之前,我们要先了解清楚计算机在客户端以及服务端扮演的角色以及交流过程.

接收端和发送端

在⼀次网络数据传输时：
发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
注意：发送端和接收端只是相对的，只是⼀次网络数据传输产生数据流向后的概念。

客户端和服务端

服务端：在常见的网络数据传输场景下，把提供服务的一方进程，称为服务端，可以提供对外服务。
客户端：获取服务的一方进程，称为客户端。

客户端和服务端交流过程

最常见的场景，客户端是指给用户使用的程序，服务端是提供用户服务的程序：

1. 客户端先发送请求到服务端
2. 服务端根据请求数据，执行相应的业务处理
3. 服务端返回响应：发送业务处理结果
4. 客户端根据响应数据，展示处理结果（展示获取的资源，或提示保存资源的处理结果）.

一: tcp协议

传输层tcp协议
tcp，即transmission control protocol（传输控制协议），传输层协议

1.1:tcp协议的六大特性

对于字节流来说，可以简单的理解为，传输数据是基于io流，流式数据的特征就是在io流没有关闭的
情况下，是无边界的数据，可以多次发送，也可以分开多次接收

1.2:socket

socket 是客户端socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服
务端socket。
不管是客户端还是服务端socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据
的。

socket 方法：

1.3:serversocket

serversocket 是创建tcp服务端socket的api。
serversocket 构造方法：

serversocket 方法：

1.4:tcp的实现

1. 客户端和服务端：开发时，经常是基于⼀个主机开启两个进程作为客户端和服务端，但真实的场
   景，⼀般都是不同主机。
2. 注意目的ip和目的端口号，标识了⼀次数据传输时要发送数据的终点主机和进程
3. socket编程我们是使用流套接字和数据报套接字，基于传输层的tcp或udp协议，但应用层协议，
   也需要考虑，这块我们在后续来说明如何设计应用层协议。
4. 关于端口被占用的问题
5. 如果⼀个进程a已经绑定了⼀个端口，再启动⼀个进程b绑定该端口，就会报错，这种情况也叫端口
   被占用。对于java进程来说，端口被占用的常见报错信息如下：
   

tcp echo server服务器

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 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().t
// 接下来就可以读取请求, 根据请求计算响应, 返回响应三步⾛了.
// socket 对象内部包含了两个字节流对象, 可以把这俩字节流对象获取到, 完成后续的读写
        try (inputstream inputstream = clientsocket.getinputstream();
             outputstream outputstream = clientsocket.getoutputstream()) {
// ⼀次连接中, 可能会涉及到多次请求/响应
            while (true) {
// 1. 读取请求并解析. 为了读取⽅便, 直接使⽤ scanner.
               scanner scanner = new scanner(inputstream);
                if (!scanner.hasnext()) {
// 读取完毕, 客⼾端下线.
                    system.out.printf("[%s:%d] 客⼾端下线!\n", clientsocket.getine
                    break;
                }
// 这个代码暗含⼀个约定, 客⼾端发过来的请求, 得是⽂本数据, 同时, 还得带有
                string request = scanner.next();
// 2. 根据请求计算响应
                string response = process(request);
// 3. 把响应写回给客⼾端. 把 outputstream 使⽤ printerwriter 包裹⼀下
                printwriter writer = new printwriter(outputstream);
// 使⽤ printwriter 的 println ⽅法, 把响应返回给客⼾端.
// 此处⽤ println, ⽽不是 print 就是为了在结尾加上 \n . ⽅便客⼾端
                writer.println(response);
// 这⾥还需要加⼀个 "刷新缓冲区" 操作.
                writer.flush();
// ⽇志, 打印当前的请求详情.
                system.out.printf("[%s:%d] req: %s, resp: %s\n", clientsocket.ge
                        request, response);
            }
        } catch (ioexception e) {
            e.printstacktrace();
        } finally {
// 在 finally 中加上 close 操作, 确保当前 socket 被及时关闭!!
            try {
                clientsocket.close();
            } 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();
    }
}

tcp echo client客服端

import java.io.ioexception;
import java.io.inputstream;
import java.io.outputstream;
import java.io.printwriter;
import java.net.socket;

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.print("-> ");
                string request = scannerconsole.next();
// 2. 把请求发送给服务器
                printwriter printwriter = new printwriter(outputstream);
// 使⽤ println 带上换⾏. 后续服务器读取请求, 就可以使⽤ scanner.n
                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();
    }
}

二: udp协议

传输层udp协议
udp，即user datagram protocol（用户数据报协议），传输层协议。

2.1:udp协议的六大特特性

对于数据报来说，可以简单的理解为，传输数据是⼀块⼀块的，发送⼀块数据假如100个字节，必须⼀
次发送，接收也必须⼀次接收100个字节，而不能分100次，每次接收1个字节。

2.2:datagramsocket

datagramsocket 是udp socket，用于发送和接收udp数据报。

datagramsocket 构造方法

datagramsocket 方法

2.3:datagrampacket

datagrampacket是udp socket发送和接收的数据报。
datagrampacket 构造方法：

datagrampacket 方法：

2.4:udp的实现

对于udp协议来说，具有无连接，面向数据报的特征，即每次都是没有建立连接，并且⼀次发送全部
数据报，⼀次接收全部的数据报。
java中使用udp协议通信，主要基于 datagramsocket 类来创建数据报套接字，并使用
datagrampacket 作为发送或接收的udp数据报。对于⼀次发送及接收udp数据报的流程如下：

udp echo server服务器

import java.io.ioexception;
import java.net.datagrampacket;
import java.net.datagramsocket;
import java.net.socketexception;

public class udpechoserver {
    private datagramsocket socket = null;
    // 参数是服务器要绑定的端⼝
    public udpechoserver(int port) throws socketexception {
        socket = new datagramsocket(port);
    }
    // 使⽤这个⽅法启动服务器.
    public void start() throws ioexception {
        system.out.println("服务器启动!");
        while (true) {
// 反复的, ⻓期的执⾏针对客⼾端请求处理的逻辑.
// ⼀个服务器, 运⾏过程中, 要做的事情, 主要是三个核⼼环节.
// 1. 读取请求, 并解析
            datagrampacket requestpacket = new datagrampacket(new byte[4096], 40
                    socket.receive(requestpacket);
// 这样的转字符串的前提是, 后续客⼾端发的数据就是⼀个⽂本的字符串.
            string request = new string(requestpacket.getdata(), 0, requestpacke
// 2. 根据请求, 计算出响应
                    string response = process(request);
// 3. 把响应写回给客⼾端
// 此时需要告知⽹卡, 要发的内容是啥, 要发给谁.
            datagrampacket responsepacket = new datagrampacket(response.getbytes
                    requestpacket.getsocketaddress());
            socket.send(responsepacket);
// 记录⽇志, ⽅便观察程序执⾏效果.
          system.out.printf("[%s:%d] req: %s, resp: %s\n", requestpacket.getad
                    request, response);
        }
    }
    // 根据请求计算响应. 由于是回显程序, 响应内容和请求完全⼀样.
    public string process(string request) {
        return request;
    }
    public static void main(string[] args) throws ioexception {
        udpechoserver server = new udpechoserver(9090);
        server.start();
    }
}

udp echo client客服端

import java.io.ioexception;
import java.net.datagrampacket;
import java.net.datagramsocket;
import java.net.inetaddress;
import java.net.socketexception;
import java.util.scanner;

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 请求, 发给服务器
// 最终再显⽰在客⼾端的屏幕上.
    public void start() throws ioexception {
        scanner scanner = new scanner(system.in);
        system.out.println("客⼾端启动!");
        while (true) {
// 1. 从控制台读取⽤⼾输⼊的内容
            system.out.print("-> "); // 命令提⽰符, 提⽰⽤⼾要输⼊字符串.
            string request = scanner.next();
// 2. 构造请求对象, 并发给服务器.
            datagrampacket requestpacket = new datagrampacket(request.getbytes()
                    inetaddress.getbyname(serverip), serverport);
           socket.send(requestpacket);
// 3. 读取服务器的响应, 并解析出响应内容.
            datagrampacket responsepacket = new datagrampacket(new byte[4096], 4
                    socket.receive(responsepacket);
            string response = new string(responsepacket.getdata(), 0, responsepa
// 4. 显⽰到屏幕上.
                    system.out.println(response);
        }
    }
    public static void main(string[] args) throws ioexception {
        udpechoclient client = new udpechoclient("127.0.0.1", 9090);
// udpechoclient client = new udpechoclient("42.192.83.143", 9090);
        client.start();
    }
}

如果觉得文章不错，期待你的一键三连哦，你个鼓励是我创作的动力之源，让我们一起加油，顶峰相见！！！💓 💓 💓