🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇
服务器和客户端的传输
🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇
今日推荐歌曲: 你不知道的事 -- 王力宏 🎵🎵
系列文章目录
【网络原理 2】UDP 协议的报文结构和注意事项-CSDN博客
【网络原理 3】TCP协议的相关特性（三次握手，四次挥手）（万字详解）看完必懂 ！-CSDN博客
【网络原理 4 】应用层中 服务器和客户端的传输-CSDN博客
【网络原理 5 】网络层中的 ” 主宰 “ IP 协议-CSDN博客
【网络原理 8】HTTP 协议的基本格式和 fiddler 的用法-CSDN博客
【网络原理 9】HTTP协议 请求 & 响应 超详解 看这篇就够-CSDN博客
【网络原理 10】HTTPS 协议 工作过程 超细节（精心配图）-CSDN博客
目录
前言
这里会介绍服务器和客户端之间使用 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是一种可靠的、面向连接的传输协议，适用于对数据完整性和可靠性要求较高的应用场景。
更详细的可参考我这篇文章:
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 服务器使用了多线程的方式实现，所以这里可以启动多个客户端来连接一个服务器。
博客不易
大家点点赞 ， 收藏 加 关注，让孩子开心开心， 后续我会酷酷更新更多学习笔记。
3357
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
