【网络原理 4】应用层中 服务器和客户端的传输 以及 DNS 协议
🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇
服务器和客户端的传输
🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇
今日推荐歌曲: 你不知道的事 -- 王力宏 🎵🎵
系列文章目录
【 网络原理 1】 网络编程原理基础知识-CSDN博客
【网络原理 2】UDP 协议的报文结构和注意事项-CSDN博客
【网络原理 3】TCP协议的相关特性（三次握手，四次挥手）（万字详解）看完必懂 ！-CSDN博客
【网络原理 4 】应用层中 服务器和客户端的传输-CSDN博客
【网络原理 5 】网络层中的 ” 主宰 “ IP 协议-CSDN博客
【网络原理 6 】数据链路层-CSDN博客
【网络原理 7】NAT 机制的工作流程-CSDN博客
【网络原理 8】HTTP 协议的基本格式和 fiddler 的用法-CSDN博客
【网络原理 9】HTTP协议 请求 & 响应 超详解 看这篇就够-CSDN博客
【网络原理 10】HTTPS 协议 工作过程 超细节（精心配图）-CSDN博客
目录
UDP 传输
UDP服务器端( UDPEchoServer )
UDP客户端 ( UDPEchoClient )
运行结果
TCP 传输
TCP服务器端( TCPEchoServer )
TCP客户端 ( TCPEchoClient )
运行结果
总结
前言
这里会介绍服务器和客户端之间使用 socket 套接字来传输的方式，和 DNS 协议。
DNS协议
DNS是⼀整套从域名映射到IP的系统
DNS背景
TCP/IP中使⽤IP地址和端⼝号来确定⽹络上的⼀台主机的⼀个程序.但是IP地址不⽅便记忆.
于是⼈们发明了⼀种叫主机名的东西,是⼀个字符串,并且使⽤hosts⽂件来描述主机名和IP地址的关系.
• DNS是应⽤层协议
• DNS底层使⽤UDP进⾏解析
• 浏览器会缓存DNS结果
浏览器中输⼊url后,发⽣的事情，这是⼀个经典的⾯试题.没有固定答案,越详细越好
.可以参考:
当你在浏览器地址栏输入一个URL后回车，将会发生的事情？_web页面回车搜索-CSDN博客
UDP 传输
UDP（User Datagram Protocol，用户数据报协议）是一种无连接的、不可靠的网络传输协议。与TCP（Transmission Control Protocol，传输控制协议）相比，UDP更加简单，因为它不提供像TCP那样的可靠性和流量控制机制。
以下是UDP传输的一些关键特点：
无连接性：UDP是一种无连接的协议，这意味着在发送数据之前不需要建立连接。相比之下，TCP需要在通信之前建立连接，然后再进行数据传输。
不可靠性：UDP不提供可靠性保证，因此数据包可能会丢失、重复、交换顺序或者到达目的地时损坏。UDP不会进行重传或者错误检测，因此在网络环境不稳定或者拥塞时，数据包可能会丢失而不被察觉。
简单性：相对于TCP，UDP更加简单，因为它不需要维护连接状态、执行流量控制或者进行拥塞控制。因此，UDP的处理速度更快，并且在一些对实时性要求较高的应用场景下更加适用。
无序性：UDP不保证数据包的传输顺序，因此接收端收到的数据包的顺序可能与发送端不同。
广播和多播支持：UDP支持广播和多播，可以将数据同时发送给多个接收方。
适用场景：由于其简单性和低延迟的特点，UDP通常用于音频、视频、实时游戏等对实时性要求较高的应用场景。在这些场景中，偶尔丢失一些数据并不会对用户体验产生明显影响。
面向数据报传输
总的来说，UDP是一种轻量级的传输协议，适用于对可靠性要求不高、实时性要求较高的应用场景。
更详细的介绍可以参考我这篇文章:【网络原理 2】UDP 协议的报文结构和注意事项-CSDN博客
UDP服务器端( UDPEchoServer )
package network; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; // 服务器网络 请求-响应 的基本流程 public class UdpEchoServer1 { private DatagramSocket socket = null; public UdpEchoServer1(int port) throws IOException { socket = new DatagramSocket(port); } //服务器启动程序 public void start() throws IOException { System.out.println("服务器程序启动2!"); while (true) { // 每次循环就是处理一个请求-响应的过程 // 1.读取请求并且解析 DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096); socket.receive(requestPacket); // 用字符串来接收读到的字节数组方便后续的逻辑处理 这里的 getLength 指的是有效长度 不一定是4096 String request = new String(requestPacket.getData(),0,requestPacket.getLength()); // 2.对请求计算回应 (对于回显服务器来说,什么都不用做) String response = process(request); // 3.把响应返回给客户端 DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,requestPacket.getSocketAddress()); socket.send(responsePacket); System.out.printf("[%s,%d] req: %s ,reps: %s\n",requestPacket.getSocketAddress(),requestPacket.getPort(), request,response); } } private String process(String request) { return request; } public static void main(String[] args) throws IOException { UdpEchoServer1 server = new UdpEchoServer1(9091); server.start(); } } UDP客户端 ( UDPEchoClient )
package network; import java.io.IOException; import java.net.*; import java.util.Scanner; //Udp 回显服务 public class UdpEchoClient { private DatagramSocket socket = null; private String serverIp; private int serverPort; public UdpEchoClient(String serverIp,int serverPort) throws SocketException { this.serverIp = serverIp; this.serverPort = serverPort; socket = new DatagramSocket(); } public void start() throws IOException { System.out.println("客户端启动!"); Scanner in = new Scanner(System.in); while(true){ //1. 读取客户端输入的请求 System.out.print("->"); if(!in.hasNext()){ break; } String request = in.next(); //2. 构造客户端的请求发送给服务器 DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),0,request.getBytes().length , InetAddress.getByName(serverIp),serverPort); socket.send(requestPacket); //3. 等服务器响应 DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096); socket.receive(responsePacket); //4. 将服务器返回的回应解析打印在显示屏上 String response = new String(responsePacket.getData(),0,responsePacket.getLength()); System.out.println(response); } } public static void main(String[] args) throws IOException { UdpEchoClient client = new UdpEchoClient("127.0.0.1",9093); client.start(); } } 运行结果
TCP 传输
TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的网络传输协议。它提供了数据传输的可靠性、流量控制、错误检测和重传机制，因此在网络通信中被广泛应用。
以下是TCP传输的一些关键特点：
面向连接：TCP是一种面向连接的协议，通信双方在传输数据之前必须先建立连接。连接的建立包括三次握手过程，确保通信双方都能够进行数据传输。
可靠性：TCP提供了可靠的数据传输机制。它通过序列号、确认应答、超时重传等机制确保数据的可靠性，即使在网络环境不稳定或者拥塞时，也能够保证数据的完整性和可靠性。
流量控制：TCP通过流量控制机制来确保发送方和接收方之间的数据传输速率匹配。通过接收方发送的窗口大小等参数，TCP可以动态调整数据发送的速率，防止发送方发送过多的数据导致接收方无法及时处理。
拥塞控制：TCP通过拥塞控制机制来避免网络拥塞，并且在拥塞发生时进行恰当的调整。TCP会根据网络拥塞的程度来调整数据发送速率，以减少数据丢失和重传，从而维持网络的稳定性和吞吐量。
有序性：TCP保证数据包的有序传输，即接收方收到的数据包的顺序与发送方发送的顺序一致。这是通过序列号和确认应答机制实现的。
适用场景：由于其可靠性和稳定性的特点，TCP通常用于对数据完整性要求较高的应用场景，例如文件传输、网页浏览、电子邮件等。在这些场景中，即使稍微延迟一些也可以接受，但是数据的完整性和可靠性至关重要。
总的来说，TCP是一种可靠的、面向连接的传输协议，适用于对数据完整性和可靠性要求较高的应用场景。
更详细的可参考我这篇文章:
【网络原理 3】TCP协议的相关特性（三次握手，四次挥手）（万字详解）看完必懂 ！-CSDN博客
TCP服务器端( TCPEchoServer )
package network; import java.io.*; import java.net.DatagramSocket; import java.net.ServerSocket; import java.net.Socket; import java.net.SocketException; import java.util.Scanner; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class TcpEchoServer { ServerSocket serverSocket = null; public TcpEchoServer(int port) throws IOException { serverSocket = new ServerSocket(port); } public void start() throws IOException { System.out.println("服务器上线!"); ExecutorService pool = Executors.newCachedThreadPool(); // 通过 accept 来"接听电话",才能通信. 注意要加循环,因为要接收多个客户端 while(true) { Socket clientSocket = serverSocket.accept(); // 在处理完 processConnection 后要记得关闭客户端 // 这里如果出现多个客户端的话,则会一直阻塞在这里,所以这里需要创建多线程来处理多个客户端 // 但是这里需要创建一个线程运行完后再销毁当前线程,当客户端很多请求的时候 这消耗就太大了 // 所以这里就直接创建 线程池 来接收请求 // Thread t = new Thread(() -> { // try { // processConnection(clientSocket); // } catch (IOException e) { // throw new RuntimeException(e); // } // }); // t.start(); pool.submit(new Runnable() { @Override public void run() { try { processConnection(clientSocket); } catch (IOException e) { throw new RuntimeException(e); } } }); } } //通过这个方法处理一次建立连接,连接建立的过程中就会涉及道多次的请求响应交互. private void processConnection(Socket clientSocket) throws IOException { System.out.printf("[%s:%d] 客户端上线!\n",clientSocket.getInetAddress(),clientSocket.getPort()); try(InputStream inputStream = clientSocket.getInputStream(); OutputStream outputStream = clientSocket.getOutputStream()){ while(true){ //用 Scanner 读取客户发来的请求 Scanner scanner = new Scanner(inputStream); while(!scanner.hasNext()){ System.out.println("客户端下线!"); break; } // 1. 读取请求并解析,这里注意隐藏约定,next 要读道空白符才会停止 // 所以就要求客户端发来的请求必须带有空白符结尾,比如\n 或者空格等 String request = scanner.next(); // 2. 根据请求计算响应 String response = process(request); // 3. 把响应返回给客户端 //通过这种方式写不方便给返回的响应中添加\n // outputStream.write(response.getBytes(),0,response.getBytes().length); // 也可以给 outStream 套上一层 完成更方便的输入 PrintWriter printWriter = new PrintWriter(outputStream); printWriter.println(response); // 这里也需要刷新缓冲区, 不然这里客户端无法接收到响应 response printWriter.flush(); // 最后打印客户端请求的日志 System.out.printf("[%s:%d]: req:%s , resp:%s\n",clientSocket.getInetAddress(),clientSocket.getPort(), request,response); } }finally { // 这里处理完一次请求响应服务后需要关闭客户端的 socket clientSocket.close(); } } private String process(String request) { return request; } public static void main(String[] args) throws IOException { TcpEchoServer tcpEchoServer = new TcpEchoServer(9090); tcpEchoServer.start(); } } TCP客户端 ( TCPEchoClient )
package network; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.PrintWriter; import java.net.Socket; import java.util.HashMap; import java.util.Scanner; public class TcpEchoClient { private Socket socket = null; public TcpEchoClient(String serverIP,int serverPort) throws IOException { // 此处可以把 ip 和 port 直接传给 socket 对象 // 由于 tcp 是有链接的. 因此 socket 里面会保存好IP地址和端口的信息. // 所以这里就不需要 TcpEchoClient 类设创建私有成员保存 // 当这里创建好 socket 之后会自动响应一直在 accept 等待的服务器 socket = new Socket(serverIP,serverPort); } public void start() throws IOException { System.out.println("客户端启动!"); try(InputStream inputStream = socket.getInputStream(); OutputStream outputStream = socket.getOutputStream()){ Scanner scannerConsole = new Scanner(System.in); Scanner scannerNetwork = new Scanner(inputStream); while(true){ // 这里的流程和 UDP 的客户端类似 // 1. 从控制台读取输入的字符串 System.out.print("->"); String request = scannerConsole.next(); // 2. 把请求发送给服务器 // 这里需要用 PrintWriter 的 println 来发送,可以保证最后的空白符 PrintWriter writer = new PrintWriter(outputStream); writer.println(request); // 注意:由于 writer 里边又缓冲区,缓冲区要占满才会自动发送,所以这里需要 刷新一些 writer.flush(); // 3. 等待获取服务器的响应 String response = scannerNetwork.next(); // 4. 把响应打印出来 System.out.println(response); } } } public static void main(String[] args) throws IOException { TcpEchoClient tcpEchoClient = new TcpEchoClient("127.0.0.1",9090); tcpEchoClient.start(); } } 运行结果
总结
以上就是应用层服务器和客户端之间的一个简单的回显传输的例子，上述 TCP 服务器使用了多线程的方式实现，所以这里可以启动多个客户端来连接一个服务器。
博客不易
大家点点赞 ， 收藏 加 关注，让孩子开心开心， 后续我会酷酷更新更多学习笔记。