计算机网络基础

计算机网络

OSI七层模型

OSI模型介绍

OSI模型指的是 Open System Interconnection Reference Model，即开放式系统互联模型。它是世界上第一个试图在世界范围内规范网络标准的框架。

从下到上一共分为7层：

1.物理层（Physical Layer）

• 封装和隐藏具体的传输手段，并且提供稳定的传输接口
• 比如：光缆，光纤，蓝牙等

2.数据链路层（Data Link Layer）

• 确保两个临近设备间数据的传输，并隐藏底层实现
• 帧同步：两个设备之间传输时的协商速率问题
• 数据纠错

3.网络层（Network Layer）

负责把一个封包从一个IP地址传输到另一个IP地址

4.传输层（Transport Layer）

负责将数据从一个实体（一个服务或应用）传输到另一个实体，但不负责数据传输的方式。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7ZC1QZqd-1645899571673)(images/2.png)]

传输层的能力

• ==数据分隔重组：==将数据拆分后按照顺序重组
• ==纠错：==在数据传输过程中出现问题后采取方式进行纠正
• ==管理连接：==处理数据的频繁交换
• ==流量控制：==控制传输数据的速率
• ==端口寻址：==标明参于传输的实体的端口号

5.会话层(Session Layer)

负责管理两个连网实体间的连接，比如说 服务器到服务器、客户端到服务…

**功能及特点：**建立连接、维持通信、释放连接

6.表现层（Presentation Layer）

负责协商用于传输的数据格式，并转换数据格式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-te04KJMn-1645899571674)(images/1.png)]

7.应用层 （Application Layer）

应用层位于OSI模型最上层

只关心业务逻辑，不关系数据的传输

OSI的问题

分层设计较为臃肿，并非每一层都为必要的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8SyiZZE8-1645899571674)(images/3.png)]

TCP/IP互联网协议群

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QRhbgXYD-1645899571674)(images/4.png)]

TCP协议

概述

TCP的全称是（Transport Control Protocol），是一个可以提供可靠的、支持全双工、连接向导的协议，因此在客户端和服务端之间传输数据的时候，是必须先建立一个连接的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ckHXlMEQ-1645899571675)(images/5.png)]

什么是连接？

• 是虚拟、抽象的概念
• 能让两个通讯的程序间确保彼此都在线
• 加快响应请求速度
• 连接也被称为会话（Session）
• 使通信更稳定、安全
• 消耗更多资料

什么是全双工？

**单工：**任何时刻数据只能单项发送

**半单工：**允许数据在两个方向上传输，在某一时刻，只允许数据在一个方向上传输

**全双工：**任何时刻都能双向发送数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XefyAidS-1645899571675)(images/6.png)]

什么是可靠性？

可靠性指数据保证无损传输

• 使无序的数据恢复原有顺序
• 多播时每个接收方都获得无损副本

TCP工作过程

建立连接的过程（三次握手）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cw4Zewgu-1645899571675)(images/7.png)]

断开连接的过程（四次挥手）

传输数据

• 报文拆分

  • 应用层数据很大时无法一次性传输完
  • 拆分后可实现并行传输

• 顺序保证

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jSm27Zbt-1645899571675)(images/8.png)]

  • TCP序号：发送序号（Seq）、接收序号（Ack）

  • 一个端的发送序号是另一个端的接受序号

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ReuVstOD-1645899571676)(images/9.png)]

    ​

TCP头

TCP报文段：TCP头部｜TCP段数据

• 源端口：描述发送方机器上的应用
• 目标端口：描述接收方服务器上的应用
• 发送序号（Seq）/接收序号（Ack） 每个序号32个字节

TCP头-标志位

• NS、CWR、ECN：TCP扩展协议
• ECN：显示拥塞控制协议，有助于帮助解决延迟和丢包问题，
• URG：紧急标志位
• SYN（Synchronize Sequence Numbers）：同步序号，也就是在建立连接
• FIN：终止连接
• ACK（Achnowledgment）：响应
• PSH（push）：传送数据
• RST（Rest Connection）：重置连接

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IWrgPfms-1645899571676)(images/10.png)]

TCP协议周边配置

• 纠错能力：保证数据可靠性
• 流控能力：协同两边速率，保证可靠性

纠错的Checksum

• TCP 拥有一个16bit的Checksum字段
• Checksum是一个函数，把原文映射到一个不可逆的16bit编码中这样就可以知道原文传输过程中有没有发送变化

流控能力

• 主要目标：让发送方和接收方协商一个合理的收发速率，让两边都可以稳定的工作
• 利用滑动窗口

IPv4协议

基本概念

==IP协议（Internet Protocol）：==网络层协议

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-miJPf1Y4-1645899571676)(images/11.png)]

IP协议可能遇到的问题

• 封包损坏 在数据传输过程中损坏
• 重发
• 丢包 在数据传输过程中丢失
• 乱序

网络层需要解决的3个问题

• 延迟
• 吞吐量
• 丢包率

IP协议的架构

IP协议目前主要有两种架构，IPv4和IPv6，IPv4是目前应用最广泛的互联网协议。

IP协议的工作原理

1. 分片（Fragmentation）

   • 把数据切成片
   • 适配底层传输网络

2. 增加协议头（IP Header）

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P3ip0SBC-1645899571676)(images/12.png)]

   • Type Of Service:服务的类型，是为了响应不同的用户诉求，用来选择延迟、吞吐量和丢包率之间的关系。
     • 低延迟
     • 高吞吐量
     • 低丢包率
     • 低成本
   • IHL（Internet Header Length）：IP协议头的大小
   • Total Length：报文（封包datagram）的长度
   • Identification：报文的ID，发送方分配，代表顺序
   • Fragment offset：描述是否要分包（拆分）、和如何拆分
   • Time To Live：封包存活的时间
   • Protocol：描述上层的协议，比如TCP=6，UDP=17
   • Options：可选项
   • Checksum：检验封包的正确性

3. 延迟、吞吐量、丢包率

   • 延迟：1bit的数据从网络的一个终端传到另一个终端需要的时间
   • 吞吐量：单位时间内可以传输的平均数剧量
   • 丢包率：发送出去的封包没有到达目的地的比例

4. 寻址（Addressing）

   寻址：给一个地址，然后找到这个东西

   IPv4地址（32位）：逐级寻址

   寻址步骤：

   1、找到顶层网络

   103.16.3.1最顶层的网络号和255.0.0.0（子网掩码）做位于运算得到：

   103.16.3.1&255.0.0.0=103.0.0.0（顶级网络）

   1&1=1，1&0=0，0&1=0，0&0=0

   2、找到下一层网络

   用IP地址和下一级的子网掩码做位于：

   103.16.3.1 & 255.255.0.0 = 103.16.0.0（下一级网络）

   3、找到再一下级网络

   使用255.255.255.0子网掩码找到下一级网络：

   103.16.3.1 & 255.255.255.0 = 103.16.3.0 （再下一级网络）

   4、定位设备

   设备在子网 103.16.3.0 中，最终找到的设备号是1

5. 路由（Routing）

   • 若寻找的IP 地址不在局域网中，需要路由找到去往对应网络的路径。

   • IP地址和子网掩码位于的构成是由路由算法实现的

     [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FedplaW6-1645899571676)(images/13.png)]

IPv6协议

**背景：**IPv4只能支持43亿个设备，不够用。

在IPv4中也有一种解决方案，就是拆分子网

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eCKidVkJ-1645899571676)(images/14.png)]

==NAT协议:==网络地址翻译

IPv6工作原理

IPv6和IPv4两者工作原理相似，为==切片、增加封包头、路由（寻址）==几个阶段

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eXkPwSsU-1645899571677)(images/15.png)]

IPv6和IPv4的区别

区别一：地址

• 地址数量：IPv4有4个8位，共32位，IPv6有8个16位，共128位
• 分隔符号
  • IPv4用==.==分隔
  • IPv6用==：==分隔
• 书写方式：IPv6地址可以缩写

区别二：寻址

• 全局单播

  • 站点点缀（Site Prefix）：48bit，一般是由ISP（Internet Service Provider，运营商）或者RIR（Regional Internet Registry，地区性互联网注册机构）。RIR将IP地址分配给运营商。
  • 子网号（Subnet ID）：16bit，用于站点内部区分子网。
  • 接口号（Interface ID）：64bit，用于站点内部区分设备。

• 本地单播

  定义：给定地址，本地网定位设备

  格式：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rHlzif28-1645899571677)(images/16.png)]

  例子：fe80::123e:456d

  Link-loacl必须以fe80开头

• 分组多播

  • 需要以8个1，也就是ff00 开头，后面跟上一个分组编号。
  • 所在的网络中已经定义了该分组编号，而且设备可以识别这个编号
  • 拥有分组下设备的完成清单，并把数据发送给对应的设备们
  • IPv4也支持分组多播，但需要网络配置整体配合

新设备接入

新设备接入IPv6后，会使用IPv6的邻居发现协议（Neighbour Discover Protocol）为自己申请一个IP地址。当新设备需要发送信息到目的地时，还可以通过ND协议广播查询目标设备。然后如果需要路由，还可以通过ND查找路由器。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KH0YGHkr-1645899571677)(images/17.png)]

UDP协议

背景

• 1980年由科学家David P.Reed提出
• 协议简单，搭建在IP协议之上
• 尽可能的减少通讯机制，速度非常快
• 该协议的RFC只有两页

介绍

全称：User Datagram Protocol，用户数据报文协议

定义：在传输层提供直接发送报文（Datagram）的能力。Datagram是数据传输的最小单位

目标：发送报文，无法拆分数据

为什么不直接调用IP协议？

IP协议只能把数据从一个网络接口发送到另一个网络接口，无法寻址到应用

UDP的封包设计

设计目标：允许用户直接发送报文的情况下最大限度的简化应用的设计

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ealzPkRw-1645899571677)(images/18.png)]

UDP和TCP的区别

协议	本质	可靠性	顺序	负载
UDP	提供报文交换，简化协议	不可靠	无序	负载小
TCP	提供可靠的网络传输	可靠	有序	负载大

TCP、UDP、IP抓包 Wireshark

Wireshark功能集

• 深入检查数百个协议，并不断添加更多协议
• 实时捕获和离线分析
• 支持Windows、Linux、macOS、Solaris、FreeBSD、NetBSD和许多其他平台
• 提供GUI浏览，可可以通过TTY
• VoIP支持
• Gzip支持
• IpSec支持

Socket编程

网络插槽Socket

多线同步程模型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YXL5fefp-1645899571677)(images/19.png)]

代码片段

package com.lxh.socket;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @description 功能描述
 * @Author: Mr、LXH
 * @Date: 2022/2/9 22:30
 * This file was created in IntelliJ IDEA
 */
public class RawHttpServer {

    public static void main(String[] args) throws Exception {
        ServerSocket socketServer = new ServerSocket(8000);

        //Main Thread
        while (true){
            //Blocking
            //Thread --> Sleep --> Threads
            Socket socket = socketServer.accept();
            System.out.println("A socket crated");

            DataInputStream iptStream = new DataInputStream(socket.getInputStream());
            BufferedReader bfReader = new BufferedReader(new InputStreamReader(iptStream));

            StringBuilder requestBuilder = new StringBuilder();

            String line="";
            while (!(line=bfReader.readLine()).isEmpty()){
             requestBuilder.append(line+"\n");
            }

            String request = requestBuilder.toString();
            System.out.println(request+"\n");

            BufferedWriter bfWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            bfWriter.write("HTTP/1.1 200 ok \n\n Hello World!\n");
            bfWriter.flush();
            socket.close();
        }
    }
}

package com.lxh.socket;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.function.Function;

/**
 * @description 功能描述
 * @Author: Mr、LXH
 * @Date: 2022/2/9 22:44
 * This file was created in IntelliJ IDEA
 */
public class Step1Server {
    ServerSocket socketServer;
    Function<String, String> handler;

    public Step1Server(Function<String, String> handler) {
        this.handler = handler;
    }

    public void listen(int port) throws IOException {
        socketServer = new ServerSocket(port);
        while (true) {
            this.accept();
        }
    }

    void accept() throws IOException {
        //Blocking
        //Thread --> Sleep --> Threads
        try {
            Socket socket = socketServer.accept();
            System.out.println("A socket crated");

            DataInputStream iptStream = new DataInputStream(socket.getInputStream());
            BufferedReader bfReader = new BufferedReader(new InputStreamReader(iptStream));

            StringBuilder requestBuilder = new StringBuilder();

            String line = "";
            while (!(line = bfReader.readLine()).isEmpty()) {
                requestBuilder.append(line + "\n");
            }

            String request = requestBuilder.toString();
            System.out.println(request + "\n");

            BufferedWriter bfWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            String response = this.handler.apply(request);
            bfWriter.write(response);
            bfWriter.flush();
            socket.close();
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException{
        Step1Server server = new Step1Server(req -> {
            return "HTTP/1.1 201 ok\n\nGood!\n";
        });
        server.listen(8001);
    }
}

package com.lxh.socket;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.function.Function;

/**
 * @description 功能描述
 * @Author: Mr、LXH
 * @Date: 2022/2/9 22:44
 * This file was created in IntelliJ IDEA
 */
public class Step2Server {
    ServerSocket socketServer;
    Function<String, String> handler;

    public Step2Server(Function<String, String> handler) {
        this.handler = handler;
    }

    public void listen(int port) throws IOException {
        socketServer = new ServerSocket(port);
        while (true) {
            this.accept();
        }
    }
    void accept()throws IOException{
        //Blocking
        Socket socket = socketServer.accept();
        new Thread(()->{
            try {
                this.funHandler(socket);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
    }
    void funHandler(Socket socket) throws IOException {
        //Blocking
        //Thread --> Sleep --> Threads
        try {
            System.out.println("A socket crated");

            DataInputStream iptStream = new DataInputStream(socket.getInputStream());
            BufferedReader bfReader = new BufferedReader(new InputStreamReader(iptStream));

            StringBuilder requestBuilder = new StringBuilder();

            String line = "";
            while (!(line = bfReader.readLine()).isEmpty()) {
                requestBuilder.append(line + "\n");
            }

            String request = requestBuilder.toString();
            System.out.println(request + "\n");

            BufferedWriter bfWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            String response = this.handler.apply(request);
            bfWriter.write(response);
            bfWriter.flush();
            socket.close();
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException{
        Step2Server server = new Step2Server(req -> {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "HTTP/1.1 201 ok\n\nGood!\n";
        });
        server.listen(8001);
    }
}

NIO模型

NIO 并不是 No IO 而是 New IO

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2rN2vArw-1645899571677)(images/20.png)]

代码

package com.lxh.socket;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.Set;

/**
 * @description NIO 实现 Socket
 * @Author: Mr、LXH
 * @Date: 2022/2/9 23:42
 * This file was created in IntelliJ IDEA
 */
public class Step3Server {

    ServerSocketChannel ssc;

    public void listen(int port) throws IOException {
        ssc = ServerSocketChannel.open();
        ssc.bind(new InetSocketAddress(port));
        //非阻塞的
        ssc.configureBlocking(false);

        Selector selector = Selector.open();

        ssc.register(selector, ssc.validOps(), null);

        ByteBuffer buffer = ByteBuffer.allocate(1024 * 16);

        for (; ; ) {
            int numOfKeys = selector.select();
            Set selectedKeys = selector.selectedKeys();
            Iterator it = selectedKeys.iterator();
            while (it.hasNext()) {
                SelectionKey key = (SelectionKey) it.next();
                if (key.isAcceptable()) {
                    SocketChannel channel = ssc.accept();
                    if (channel == null) {
                        continue;
                    }
                    // Kernel -> map(buffer) -> User(Buffer)
                    channel.configureBlocking(false);
                    channel.register(selector, SelectionKey.OP_READ);
                } else {

                    SocketChannel channel = (SocketChannel) key.channel();
                    buffer.clear();
                    channel.read(buffer);
                    String request = new String(buffer.array());
                    //Logic...
                    buffer.clear();
                    buffer.put("HTTP/1.1 200 ok\n\nHello NIO!!".getBytes());

                    buffer.flip();
                    channel.write(buffer);
                    channel.close();
                }
            }
        }
    }

    public static void main(String[] args) throws IOException {
        Step3Server stepServer = new Step3Server();
        stepServer.listen(8001);
    }
}

HTTP协议

HTTP协议（Hyper Text Transfer Protocol）：应用层协议，是浏览器和WebServer之间通信的协议

目标：是处理客户端和服务端之间的通信

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g701FszL-1645899571678)(images/21.png)]

请求（Request）

一次请求，分成（Header）和体（Body）下面是请求头+消息体的示例：

GET / HTTP /1.1
Host: www.baidu.com

<消息体内容>

###返回（Response）

一次返回，也同样分（Header）和体（Body），下面是返回头+消息体的示例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VNcqbO62-1645899571678)(images/22.png)]

URL

URL（Uniform Resource Locator）：用于在互联网上定位（Locate）一个资源（Resource）

URL也称为网址，比如我们输入的网址

资源举例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0aTpcV9k-1645899571678)(images/23.png)]

DNS-工作原理

DNS（Domain Name System）：域名解析系统

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wdjpbQMN-1645899571678)(images/24.png)]

DNS Query 的分级缓存策略

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2b0QyvHF-1645899571678)(images/25.png)]

1. 先查询浏览器的本地缓存（通常在内存中）
2. 本地没缓存，查找操作系统的hosts文件，该文件在linux中在==/etc/hosts==里
3. 上述步骤没有找到，DNS会查询本地服务提供商（ISP）
4. ISP没找到，请求指向Root根服务器，返回顶级域名服务器地址
5. 浏览器发送请求给顶级域名服务器，返回权威域名服务器地址
6. 浏览器发送Lookup请求给权威域名服务器，找到具有DNS记录，返回给浏览器

**NDS概述：**DNS的数据以记录形式存储，就叫DNS记录。DNS记录的种类非常多，有30多种。每条DNS记录描述里网址（URL）的一种关系。

• A记录：定义主机的IP地址

  定义 www.example.com的地址 www.example.com. IN A 139.18.28.5;

• AAAA记录：定义IPv6的地址

  定义www.zhihu.com的地址 1251625956.s2tipv6.cdntip.com IN AAAA 240e:940:401:1:1a::

• CNAME记录（Canonical Name Record）：定义域名的别名

  定义www.example.com的别名 www.example.com IN CNAME example.com

• NS记录：定义DNS信息服务器所在位置

内容分发网络（CDN）

CDN（Content Delivery Network）：将请求分散到全世界各地，分发流量，加快访问速度。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VGvrqRCp-1645899571678)(images/26.png)]

CDN上无法部署业务逻辑，更新慢，无法保证一致性，比较适合纯的静态资源，比如图片、视频、脚本文件、样式文件等。

请求头/返回头

HTTP协议通过请求头和返回头控制协议工作。无论是请求头还是返回头都是Key/Value的形式。

• **Content-Length：**发送/接收Body内容的字节数。

• **User-Agent：**这个字段可以帮助统计客户端用了什么浏览器、操作系统等

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BtHNxTjN-1645899571678)(images/27.png)]

• **Content-Type:**请求的时候，告知服务端数据的媒体类型（MediaType/MIME Type）。返回的时候告知客户端，数据的媒体类型

  • text/html: HTML格式
  • text/css：css文本
  • application/json：JSON数据格式
  • images/jpeg：jpg图片格式
  • text/plain：纯文本格式

• **Origin：**描述请求来源地址

  • **例如：**scheme://host:port
  • 不含路径
  • 可以是null

• **Accept：**是HTTP协议协商能力的体现，用于建议服务端返回何种媒体类型（MIME Type）

  • */*代表所有类型（默认）
  • 多个类型用逗号隔开。例如：text/html，application/json
  • Accept-Encding：建议服务端发送这种编码（压缩算法）
  • deflate，gzip；q=1.0，*；q=0.5
  • Accept-Language：建议服务端传递哪种语言
  • Accept- Language：fr-CH,fr;q=0.9,en;q=0.8,de;q=0.7,*;q=0.5

• Referer：

  • 告诉服务端打开当前页面的上一张页面的URL
  • 非浏览器环境有时候不发送Referer（或者虚拟Referer，通常是爬虫）
  • 常用于用户行为分析

• **Connection：**决定HTTP连接（不是TCP连接）是否在当前事物完成后关闭

HTTP方法

• ==GET：==从服务器获取资源
• ==POST：==在服务器创建资源
• ==PUT：==在服务器修改资源（幂等性）
• ==DELETE：==在服务器删除资源
• OPTION：
• TRACE：用于显示调试信息 多数网站不支持
• CONNET：
• PATCH：对资源进行部分更新（极少用）

状态码

• 1xx：提供信息
  • 100 continue 101 切换协议（switch protocol）
• ==2xx：==成功
• 3xx：重定向
• ==4xx：==客服端错误
• ==5xx：==服务端错误

2xx状态码

• 200 -OK
• 201 - Created 已创建
• 202 - Acceped 已接收
• 203 - Non- Authoritative Information 非权威内容
• 204 - No Content 没有内容
• 205 - Reset Content 重置内容
• 206 - Partial Content 服务器下发了部分内容（range header）

4xx状态码

• 400：Bad Request 请求格式错误
• 401：Unauthorized 没有授权
• 402：Payment Required 请先支付
• 403：Forbidden 禁止访问
• 404：Not Found 没有找到
• 405：Method Not Allowed 方法不被允许
• 406：Not Acceptable 服务端可以提供的内容和客服端期待的不一样

5xx状态码

• 500: Internal Server Error（内部服务器错误）
• 501: Not Implemented （没有实现）
• 502: Bad Gateway（网关错误）
• 503: Service Unavailable （服务不可用）
• 504: Gateway Timeout（网关超时）
• 505: HTTP Version Not Supported （版本不支持）

HTTP缓存

传统的HTTP协议层网络节后的三种实体：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-46InmmSG-1645899571678)(images/28.png)]

什么是缓存？

存储将被用到的数据，提升访问速度

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0HtF9I7e-1645899571679)(images/27.png)]

为什么使用缓存

• 成本低（速度快，时间少）
• 有选择性的缓存数据

缓存条目

缓存条目：通常是key/value结构，如HTTP缓存，通常以key为URL；value通常不仅仅只包括数据，还会包括一些描述字段，比如缓存的失效时间等。

缓存置换

缓存满了之后，每次创建新的缓存条目，就会删除旧的缓存条目。

LRU（LRU-Least recently used）缓存置换算法

加密、解密和证书

加密

加密：将明文信息变成不可读的密文内容，只有拥有解密方法的对象才能够将密文还原成加密前的内容。

加密算法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zFtshCrV-1645899571679)(images/30.png)]

对称加密

对称加密：加密/解密用一个密钥，且加密和解密方都知道密钥，如果 DES，3DES等

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8tsHCrnz-1645899571679)(images/31.png)]

非对称加密

非对称加密：加密用一个密钥，解密用另一个密钥且加密方一般有两个密钥，解密方有一个解密密钥。非对称加密安全性高，但速度慢，比如RSA算法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NLnvDWy0-1645899571679)(images/32.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EdR4cu3t-1645899571679)(images/33.png)]

摘要算法

摘要算法：就是将原文和摘要同时传输给接收方

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tbRwrU2t-1645899571679)(images/34.png)]

摘要算法3个特点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VmTuLXOW-1645899571679)(images/35.png)]

HTTPS和HTTP2.0

HTTPS

HTTPS（HTTP Over SecureSocket Layer）：应用层协议

HTTPS协议工作原理

HTTPS采用对称加密的方式加密传输的数据，然后对称加密的密钥，采用非对称加密的方式进行协商。

1. TCP协议三次握手，建立TCP连接
2. 服务器利用TCP将证书发送给浏览器
3. 浏览器通过本地Root CA验证网站证书
4. 浏览器用证书的公钥加密：协商对称加密的算法和密码
5. 服务器响应，确定对称加密算法和密码
6. 会话建立（来往数据使用对称加密）

HTTP2.0

HTTP 1.1 Keep-Alive 问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2GM3l0x0-1645899571680)(images/36.png)]

HTTP1.1 协议的Keep-Alive让==多个请求复用一个TCP连接，==非多路复用。有点：节省TCP握手时间；缺点：一个请求阻塞，其他请求也全都阻塞。

HTTP 2.0解决方案

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dAgxeLof-1645899571680)(images/37.png)]

HTTP2.0协议，使用多路复用，优点：一个请求阻塞了，其他请求依旧可以响应。

头部压缩技术

同源策略

禁止一个源（Origin）的脚本和文档和另一个源的脚本和文档交互

• 两个URL的protocol，port和host相同，那么同源

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cSvrrYRt-1645899571680)(images/38.png)]

解决跨域的几种方法：

• JSONP
• 配置请求头
• …

Linux网络指令

• ssh/scp

  可以把自己机器的公钥配置到 服务器的 authorized_keys中，进行免密登陆

• Ifconfig/netstat

• Ping/telnet

• Host/dig/nslookup

• curl/wget

网络面试真题实战

TCP/IP协议群做了哪些事情？

1. 报文拆分
2. 增加协议头
3. 数据传输
4. 路由和寻址
5. 数据重组

TCP协议为什么是3次握手4次挥手

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kPw4nBVH-1645899571680)(images/39.png)]

IPv4和IPv6的区别

• 地址不同（IPv432位、IPv6128位）-> 地址空间、数目不同
• 地址分配不同（IPv4资源是稀缺的，分配需要竞争；IPv6可以给每个人分配很多地址）
• 寻址方式不同：IPv4通过子网掩码计算网络地址；IPv6有固定的计算方式划分网络
• 地址解析策略不同（IPv4需要ARP，IPv6通过武装体啊的邻居发现）
• DNS不同（IPv4是A记录，IPv6是AAAA记录）

TCP和UDP的区别

• 面向流 VS 面向报文
• 会话 VS 无会话
• 头（大 VS 小）
• TCP保证正确性（可靠性），UDP不保证
• UDP实现广播成本低

CDN更换图片？缓存更新？

去中心化核心理念

LRU是什么？

缓存置换算法：缓存满了之后，每次创建新的缓存条目，就是阐述旧的缓存。

什么是https中间人攻击？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZRnWIyeP-1645899571680)(images/40.png)]

信任链问题：

NIO有什么优势？

• Reactive模型+非阻塞（减少线程切换）
• 内核级别拷贝存到JVM（减少系统调用）
• 缓冲区增加数据处理的灵活性（clear/flip等操作）

处理I/O场景有明显性能优势

一次NDS查询最快和最慢差距有多大？

• 最快命中本地浏览器缓存
• 。。。

HTTP keep-alive 和http2.0 的多路复用有什么区别？

串行和并行的区别

强制缓存和协商缓存的区别

。。。

正向代理和反向代理的区别