1.5万字+40张图解HTTP常见面试题（值得收藏）

作者&＃xff1a;小林coding
图解计算机基础网站&＃xff1a;https://xiaolincoding.com

大家好&＃xff0c;我是小林&＃xff0c;我最开始写的第一篇图解文章就是这篇&＃xff1a;

那时候我也就不到 100 读者&＃xff0c;如今这篇阅读都快 2 万了。

当时这篇有些地方没有解释到位&＃xff0c;然后我周末抽时间把一些没解释清楚的地方重写了&＃xff0c;而且还增加 HTTP 缓存技术 方面的面试题&＃xff0c;文章的内容相比以前多了 5000 &＃43;字和 10 &＃43;张图。

不多说了&＃xff0c;发车发车&＃xff01;

HTTP 基本概念

HTTP 是什么&＃xff1f;

HTTP 是超文本传输协议&＃xff0c;也就是HyperText Transfer Protocol。

能否详细解释「超文本传输协议」&＃xff1f;

HTTP的名字「超文本协议传输」&＃xff0c;它可以拆成三个部分&＃xff1a;

• 超文本
• 传输
• 协议

1. 「协议」

在生活中&＃xff0c;我们也能随处可见「协议」&＃xff0c;例如&＃xff1a;

• 刚毕业时会签一个「三方协议」&＃xff1b;
• 找房子时会签一个「租房协议」&＃xff1b;

生活中的协议&＃xff0c;本质上与计算机中的协议是相同的&＃xff0c;协议的特点:

• 「协」字&＃xff0c;代表的意思是必须有两个以上的参与者。例如三方协议里的参与者有三个&＃xff1a;你、公司、学校三个&＃xff1b;租房协议里的参与者有两个&＃xff1a;你和房东。
• 「议」字&＃xff0c;代表的意思是对参与者的一种行为约定和规范。例如三方协议里规定试用期期限、毁约金等&＃xff1b;租房协议里规定租期期限、每月租金金额、违约如何处理等。

针对 HTTP 协议&＃xff0c;我们可以这么理解。

HTTP 是一个用在计算机世界里的协议。它使用计算机能够理解的语言确立了一种计算机之间交流通信的规范&＃xff08;两个以上的参与者&＃xff09;&＃xff0c;以及相关的各种控制和错误处理方式&＃xff08;行为约定和规范&＃xff09;。

2. 「传输」

所谓的「传输」&＃xff0c;很好理解&＃xff0c;就是把一堆东西从 A 点搬到 B 点&＃xff0c;或者从 B 点 搬到 A 点。

别轻视了这个简单的动作&＃xff0c;它至少包含两项重要的信息。

HTTP 协议是一个双向协议。

我们在上网冲浪时&＃xff0c;浏览器是请求方 A &＃xff0c;百度网站就是应答方 B。双方约定用 HTTP 协议来通信&＃xff0c;于是浏览器把请求数据发送给网站&＃xff0c;网站再把一些数据返回给浏览器&＃xff0c;最后由浏览器渲染在屏幕&＃xff0c;就可以看到图片、视频了。

数据虽然是在 A 和 B 之间传输&＃xff0c;但允许中间有中转或接力。

就好像第一排的同学想传递纸条给最后一排的同学&＃xff0c;那么传递的过程中就需要经过好多个同学&＃xff08;中间人&＃xff09;&＃xff0c;这样的传输方式就从「A <— > B」&＃xff0c;变成了「A <-> N <-> M <-> B」。

而在 HTTP 里&＃xff0c;需要中间人遵从 HTTP 协议&＃xff0c;只要不打扰基本的数据传输&＃xff0c;就可以添加任意额外的东西。

针对传输&＃xff0c;我们可以进一步理解了 HTTP。

HTTP 是一个在计算机世界里专门用来在两点之间传输数据的约定和规范。

3. 「超文本」

HTTP 传输的内容是「超文本」。

我们先来理解「文本」&＃xff0c;在互联网早期的时候只是简单的字符文字&＃xff0c;但现在「文本」的涵义已经可以扩展为图片、视频、压缩包等&＃xff0c;在 HTTP 眼里这些都算作「文本」。

再来理解「超文本」&＃xff0c;它就是超越了普通文本的文本&＃xff0c;它是文字、图片、视频等的混合体&＃xff0c;最关键有超链接&＃xff0c;能从一个超文本跳转到另外一个超文本。

HTML 就是最常见的超文本了&＃xff0c;它本身只是纯文字文件&＃xff0c;但内部用很多标签定义了图片、视频等的链接&＃xff0c;再经过浏览器的解释&＃xff0c;呈现给我们的就是一个文字、有画面的网页了。

OK&＃xff0c;经过了对 HTTP 里这三个名词的详细解释&＃xff0c;就可以给出比「超文本传输协议」这七个字更准确更有技术含量的答案&＃xff1a;

HTTP 是一个在计算机世界里专门在「两点」之间「传输」文字、图片、音频、视频等「超文本」数据的「约定和规范」。

那「HTTP 是用于从互联网服务器传输超文本到本地浏览器的协议 &＃xff0c;这种说法正确吗&＃xff1f;

这种说法是不正确的。因为也可以是「服务器<– >服务器」&＃xff0c;所以采用两点之间的描述会更准确。

HTTP 常见的状态码有哪些&＃xff1f;

1xx 类状态码属于提示信息&＃xff0c;是协议处理中的一种中间状态&＃xff0c;实际用到的比较少。

2xx 类状态码表示服务器成功处理了客户端的请求&＃xff0c;也是我们最愿意看到的状态。

• 「200 OK」是最常见的成功状态码&＃xff0c;表示一切正常。如果是非 HEAD 请求&＃xff0c;服务器返回的响应头都会有 body 数据。

• 「204 No Content」也是常见的成功状态码&＃xff0c;与 200 OK 基本相同&＃xff0c;但响应头没有 body 数据。

• 「206 Partial Content」是应用于 HTTP 分块下载或断点续传&＃xff0c;表示响应返回的 body 数据并不是资源的全部&＃xff0c;而是其中的一部分&＃xff0c;也是服务器处理成功的状态。

3xx 类状态码表示客户端请求的资源发送了变动&＃xff0c;需要客户端用新的 URL 重新发送请求获取资源&＃xff0c;也就是重定向。

• 「301 Moved Permanently」表示永久重定向&＃xff0c;说明请求的资源已经不存在了&＃xff0c;需改用新的 URL 再次访问。

• 「302 Found」表示临时重定向&＃xff0c;说明请求的资源还在&＃xff0c;但暂时需要用另一个 URL 来访问。

301 和 302 都会在响应头里使用字段 Location&＃xff0c;指明后续要跳转的 URL&＃xff0c;浏览器会自动重定向新的 URL。

• 「304 Not Modified」不具有跳转的含义&＃xff0c;表示资源未修改&＃xff0c;重定向已存在的缓冲文件&＃xff0c;也称缓存重定向&＃xff0c;也就是告诉客户端可以继续使用缓存资源&＃xff0c;用于缓存控制。

4xx 类状态码表示客户端发送的报文有误&＃xff0c;服务器无法处理&＃xff0c;也就是错误码的含义。

• 「400 Bad Request」表示客户端请求的报文有错误&＃xff0c;但只是个笼统的错误。

• 「403 Forbidden」表示服务器禁止访问资源&＃xff0c;并不是客户端的请求出错。

• 「404 Not Found」表示请求的资源在服务器上不存在或未找到&＃xff0c;所以无法提供给客户端。

5xx 类状态码表示客户端请求报文正确&＃xff0c;但是服务器处理时内部发生了错误&＃xff0c;属于服务器端的错误码。

• 「500 Internal Server Error」与 400 类型&＃xff0c;是个笼统通用的错误码&＃xff0c;服务器发生了什么错误&＃xff0c;我们并不知道。

• 「501 Not Implemented」表示客户端请求的功能还不支持&＃xff0c;类似“即将开业&＃xff0c;敬请期待”的意思。

• 「502 Bad Gateway」通常是服务器作为网关或代理时返回的错误码&＃xff0c;表示服务器自身工作正常&＃xff0c;访问后端服务器发生了错误。

• 「503 Service Unavailable」表示服务器当前很忙&＃xff0c;暂时无法响应服务器&＃xff0c;类似“网络服务正忙&＃xff0c;请稍后重试”的意思。

HTTP 常见字段有哪些&＃xff1f;

Host 字段

客户端发送请求时&＃xff0c;用来指定服务器的域名。

Host: www.A.com


有了 Host 字段&＃xff0c;就可以将请求发往「同一台」服务器上的不同网站。

Content-Length 字段

服务器在返回数据时&＃xff0c;会有 Content-Length 字段&＃xff0c;表明本次回应的数据长度。

Content-Length: 1000


如上面则是告诉浏览器&＃xff0c;本次服务器回应的数据长度是 1000 个字节&＃xff0c;后面的字节就属于下一个回应了。

Connection 字段

Connection 字段最常用于客户端要求服务器使用 TCP 持久连接&＃xff0c;以便其他请求复用。

HTTP/1.1 版本的默认连接都是持久连接&＃xff0c;但为了兼容老版本的 HTTP&＃xff0c;需要指定 Connection 首部字段的值为 Keep-Alive。

Connection: keep-alive


一个可以复用的 TCP 连接就建立了&＃xff0c;直到客户端或服务器主动关闭连接。但是&＃xff0c;这不是标准字段。

Content-Type 字段

Content-Type 字段用于服务器回应时&＃xff0c;告诉客户端&＃xff0c;本次数据是什么格式。

Content-Type: text/html; charset&＃61;utf-8


上面的类型表明&＃xff0c;发送的是网页&＃xff0c;而且编码是UTF-8。

客户端请求的时候&＃xff0c;可以使用 Accept 字段声明自己可以接受哪些数据格式。

Accept: */*


上面代码中&＃xff0c;客户端声明自己可以接受任何格式的数据。

Content-Encoding 字段

Content-Encoding 字段说明数据的压缩方法。表示服务器返回的数据使用了什么压缩格式

Content-Encoding: gzip


上面表示服务器返回的数据采用了 gzip 方式压缩&＃xff0c;告知客户端需要用此方式解压。

客户端在请求时&＃xff0c;用 Accept-Encoding 字段说明自己可以接受哪些压缩方法。

Accept-Encoding: gzip, deflate


GET 与 POST

GET 和 POST 有什么区别&＃xff1f;

根据 RFC 规范&＃xff0c;GET 的语义是从服务器获取指定的资源&＃xff0c;这个资源可以是静态的文本、页面、图片视频等。GET 请求的参数位置一般是写在 URL 中&＃xff0c;URL 规定只能支持 ASCII&＃xff0c;所以 GET 请求的参数只允许 ASCII 字符 &＃xff0c;而且浏览器会对 URL 的长度有限制&＃xff08;HTTP协议本身对 URL长度并没有做任何规定&＃xff09;。

比如&＃xff0c;你打开我的文章&＃xff0c;浏览器就会发送 GET 请求给服务器&＃xff0c;服务器就会返回文章的所有文字及资源。

根据 RFC 规范&＃xff0c;POST 的语义是根据请求负荷&＃xff08;报文body&＃xff09;对指定的资源做出处理&＃xff0c;具体的处理方式视资源类型而不同。POST 请求携带数据的位置一般是写在报文 body 中&＃xff0c; body 中的数据可以是任意格式的数据&＃xff0c;只要客户端与服务端协商好即可&＃xff0c;而且浏览器不会对 body 大小做限制。

比如&＃xff0c;你在我文章底部&＃xff0c;敲入了留言后点击「提交」&＃xff08;暗示你们留言&＃xff09;&＃xff0c;浏览器就会执行一次 POST 请求&＃xff0c;把你的留言文字放进了报文 body 里&＃xff0c;然后拼接好 POST 请求头&＃xff0c;通过 TCP 协议发送给服务器。

GET 和 POST 方法都是安全和幂等的吗&＃xff1f;

先说明下安全和幂等的概念&＃xff1a;

• 在 HTTP 协议里&＃xff0c;所谓的「安全」是指请求方法不会「破坏」服务器上的资源。
• 所谓的「幂等」&＃xff0c;意思是多次执行相同的操作&＃xff0c;结果都是「相同」的。

如果从 RFC 规范定义的语义来看&＃xff1a;

• GET 方法就是安全且幂等的&＃xff0c;因为它是「只读」操作&＃xff0c;无论操作多少次&＃xff0c;服务器上的数据都是安全的&＃xff0c;且每次的结果都是相同的。所以&＃xff0c;可以对 GET 请求的数据做缓存&＃xff0c;这个缓存可以做到浏览器本身上&＃xff08;彻底避免浏览器发请求&＃xff09;&＃xff0c;也可以做到代理上&＃xff08;如nginx&＃xff09;&＃xff0c;而且在浏览器中 GET 请求可以保存位书签。
• POST 因为是「新增或提交数据」的操作&＃xff0c;会修改服务器上的资源&＃xff0c;所以是不安全的&＃xff0c;且多次提交数据就会创建多个资源&＃xff0c;所以不是幂等的。所以&＃xff0c;浏览器一般不会缓存 POST 请求&＃xff0c;也不能把 POST 请求保存为书签。

做个简要的小结。

GET 的语义是请求获取指定的资源。GET 方法是安全、幂等、可被缓存的。

POST 的语义是根据请求负荷&＃xff08;报文主体&＃xff09;对指定的资源做出处理&＃xff0c;具体的处理方式视资源类型而不同。POST 不安全&＃xff0c;不幂等&＃xff0c;&＃xff08;大部分实现&＃xff09;不可缓存。

注意&＃xff0c; 上面是从 RFC 规范定义的语义来分析的。

但是实际过程中&＃xff0c;开发者不一定会按照 RFC 规范定义的语义来实现 GET 和 POST 方法。比如&＃xff1a;

• 可以用 GET 方法实现新增或删除数据的请求&＃xff0c;这样实现的 GET 方法自然就不是安全和幂等。
• 可以用 POST 方法实现查询数据的请求&＃xff0c;这样实现的 POST 方法自然就是安全和幂等。

曾经有个笑话&＃xff0c;有人写了个博客&＃xff0c;删除博客用的是GET请求&＃xff0c;他觉得没人访问就连鉴权都没做。然后Google服务器爬虫爬了一遍&＃xff0c;他所有博文就没了。。。

如果「安全」放入概念是指信息是否会被泄漏的话&＃xff0c;虽然 POST 用 body 传输数据&＃xff0c;而 GET 用 URL 传输&＃xff0c;这样数据会在浏览器地址拦容易看到&＃xff0c;但是并不能说 GET 不如 POST 安全的。

因为 HTTP 传输的内容都是明文的&＃xff0c;虽然在浏览器地址拦看不到 POST 提交的 body 数据&＃xff0c;但是只要抓个包就都能看到了。

所以&＃xff0c;要避免传输过程中数据被窃取&＃xff0c;就要使用 HTTPS 协议&＃xff0c;这样所有 HTTP 的数据都会被加密传输。

GET 请求可以带 body 吗&＃xff1f;

RFC 规范并没有规定 GET 请求不能带 body 的。理论上&＃xff0c;任何请求都可以带 body 的。只是因为 RFC 规范定义的 GET 请求是获取资源&＃xff0c;所以根据这个语义不需要用到 body。

另外&＃xff0c;URL 中的查询参数也不是 GET 所独有的&＃xff0c;POST 请求的 URL 中也可以有参数的。

HTTP 缓存技术

HTTP 缓存有哪些实现方式&＃xff1f;

对于一些具有重复性的 HTTP 请求&＃xff0c;比如每次请求得到的数据都一样的&＃xff0c;我们可以把这对「请求-响应」的数据都缓存在本地&＃xff0c;那么下次就直接读取本地的数据&＃xff0c;不必在通过网络获取服务器的响应了&＃xff0c;这样的话 HTTP/1.1 的性能肯定肉眼可见的提升。

所以&＃xff0c;避免发送 HTTP 请求的方法就是通过缓存技术&＃xff0c;HTTP 设计者早在之前就考虑到了这点&＃xff0c;因此 HTTP 协议的头部有不少是针对缓存的字段。

HTTP 缓存有两种实现方式&＃xff0c;分别是强制缓存和协商缓存。

什么是强制缓存&＃xff1f;

强缓存指的是只要浏览器判断缓存没有过期&＃xff0c;则直接使用浏览器的本地缓存&＃xff0c;决定是否使用缓存的主动性在于浏览器这边。

如下图中&＃xff0c;返回的是 200 状态码&＃xff0c;但在 size 项中标识的是 from disk cache&＃xff0c;就是使用了强制缓存。

强缓存是利用下面这两个 HTTP 响应头部&＃xff08;Response Header&＃xff09;字段实现的&＃xff0c;它们都用来表示资源在客户端缓存的有效期&＃xff1a;

• Cache-Control&＃xff0c; 是一个相对时间&＃xff1b;
• Expires&＃xff0c;是一个绝对时间&＃xff1b;

如果 HTTP 响应头部同时有 Cache-Control 和 Expires 字段的话&＃xff0c;Cache-Control的优先级高于 Expires 。

Cache-control 选项更多一些&＃xff0c;设置更加精细&＃xff0c;所以建议使用 Cache-Control 来实现强缓存。具体的实现流程如下&＃xff1a;

• 当浏览器第一次请求访问服务器资源时&＃xff0c;服务器会在返回这个资源的同时&＃xff0c;在 Response 头部加上 Cache-Control&＃xff0c;Cache-Control 中设置了过期时间大小&＃xff1b;
• 浏览器再次请求访问服务器中的该资源时&＃xff0c;会先通过请求资源的时间与 Cache-Control 中设置的过期时间大小&＃xff0c;来计算出该资源是否过期&＃xff0c;如果没有&＃xff0c;则使用该缓存&＃xff0c;否则重新请求服务器&＃xff1b;
• 服务器再次收到请求后&＃xff0c;会再次更新 Response 头部的 Cache-Control。

什么是协商缓存&＃xff1f;

当我们在浏览器使用开发者工具的时候&＃xff0c;你可能会看到过某些请求的响应码是 304&＃xff0c;这个是告诉浏览器可以使用本地缓存的资源&＃xff0c;通常这种通过服务端告知客户端是否可以使用缓存的方式被称为协商缓存。

上图就是一个协商缓存的过程&＃xff0c;所以协商缓存就是与服务端协商之后&＃xff0c;通过协商结果来判断是否使用本地缓存。

协商缓存可以基于两种头部来实现。

第一种&＃xff1a;请求头部中的 If-Modified-Since 字段与响应头部中的 Last-Modified 字段实现&＃xff0c;这两个字段的意思是&＃xff1a;

• 响应头部中的 Last-Modified&＃xff1a;标示这个响应资源的最后修改时间&＃xff1b;
• 请求头部中的 If-Modified-Since&＃xff1a;当资源过期了&＃xff0c;发现响应头中具有 Last-Modified 声明&＃xff0c;则再次发起请求的时候带上 Last-Modified 的时间&＃xff0c;服务器收到请求后发现有 If-Modified-Since 则与被请求资源的最后修改时间进行对比&＃xff08;Last-Modified&＃xff09;&＃xff0c;如果最后修改时间较新&＃xff08;大&＃xff09;&＃xff0c;说明资源又被改过&＃xff0c;则返回最新资源&＃xff0c;HTTP 200 OK&＃xff1b;如果最后修改时间较旧&＃xff08;小&＃xff09;&＃xff0c;说明资源无新修改&＃xff0c;响应 HTTP 304 走缓存。

第二种&＃xff1a;请求头部中的 If-None-Match 字段与响应头部中的 ETag 字段&＃xff0c;这两个字段的意思是&＃xff1a;

• 响应头部中 Etag&＃xff1a;唯一标识响应资源&＃xff1b;
• 请求头部中的 If-None-Match&＃xff1a;当资源过期时&＃xff0c;浏览器发现响应头里有 Etag&＃xff0c;则再次向服务器发起请求时&＃xff0c;会将请求头If-None-Match 值设置为 Etag 的值。服务器收到请求后进行比对&＃xff0c;如果资源没有变化返回 304&＃xff0c;如果资源变化了返回 200。

第一种实现方式是基于时间实现的&＃xff0c;第二种实现方式是基于一个唯一标识实现的&＃xff0c;相对来说后者可以更加准确地判断文件内容是否被修改&＃xff0c;避免由于时间篡改导致的不可靠问题。

如果 HTTP 响应头部同时有 Etag 和 Last-Modified 字段的时候&＃xff0c; Etag 的优先级更高&＃xff0c;也就是先会判断 Etag 是否变化了&＃xff0c;如果 Etag 没有变化&＃xff0c;然后再看 Last-Modified。

注意&＃xff0c;协商缓存这两个字段都需要配合强制缓存中 Cache-control 字段来使用&＃xff0c;只有在未能命中强制缓存的时候&＃xff0c;才能发起带有协商缓存字段的请求。

使用 ETag 字段实现的协商缓存的过程如下&＃xff1b;

• 当浏览器第一次请求访问服务器资源时&＃xff0c;服务器会在返回这个资源的同时&＃xff0c;在 Response 头部加上 ETag 唯一标识&＃xff0c;这个唯一标识的值是根据当前请求的资源生成的&＃xff1b;
• 当浏览器再次请求访问服务器中的该资源时&＃xff0c;首先会先检查强制缓存是否过期&＃xff0c;如果没有过期&＃xff0c;则直接使用本地缓存&＃xff1b;如果缓存过期了&＃xff0c;会在 Request 头部加上 If-None-Match 字段&＃xff0c;该字段的值就是 ETag 唯一标识&＃xff1b;
• 服务器再次收到请求后&＃xff0c;会根据请求中的 If-None-Match 值与当前请求的资源生成的唯一标识进行比较&＃xff1a;
  • 如果值相等&＃xff0c;则返回 304 Not Modified&＃xff0c;不会返回资源&＃xff1b;
  • 如果不相等&＃xff0c;则返回 200 状态码和返回资源&＃xff0c;并在 Response 头部加上新的 ETag 唯一标识&＃xff1b;
• 如果浏览器收到 304 的请求响应状态码&＃xff0c;则会从本地缓存中加载资源&＃xff0c;否则更新资源。

HTTP 特性

HTTP&＃xff08;1.1&＃xff09; 的优点有哪些&＃xff1f;

HTTP 最凸出的优点是「简单、灵活和易于扩展、应用广泛和跨平台」。

1. 简单

HTTP 基本的报文格式就是 header &＃43; body&＃xff0c;头部信息也是 key-value 简单文本的形式&＃xff0c;易于理解&＃xff0c;降低了学习和使用的门槛。

2. 灵活和易于扩展

HTTP协议里的各类请求方法、URI/URL、状态码、头字段等每个组成要求都没有被固定死&＃xff0c;都允许开发人员自定义和扩充。

同时 HTTP 由于是工作在应用层&＃xff08; OSI 第七层&＃xff09;&＃xff0c;则它下层可以随意变化。

HTTPS 也就是在 HTTP 与 TCP 层之间增加了 SSL/TLS 安全传输层&＃xff0c;HTTP/3 甚至把 TCP 层换成了基于 UDP 的 QUIC。

3. 应用广泛和跨平台

互联网发展至今&＃xff0c;HTTP 的应用范围非常的广泛&＃xff0c;从台式机的浏览器到手机上的各种 APP&＃xff0c;从看新闻、刷贴吧到购物、理财、吃鸡&＃xff0c;HTTP 的应用遍地开花&＃xff0c;同时天然具有跨平台的优越性。

HTTP&＃xff08;1.1&＃xff09; 的缺点有哪些&＃xff1f;

HTTP 协议里有优缺点一体的双刃剑&＃xff0c;分别是「无状态、明文传输」&＃xff0c;同时还有一大缺点「不安全」。

1. 无状态双刃剑

无状态的好处&＃xff0c;因为服务器不会去记忆 HTTP 的状态&＃xff0c;所以不需要额外的资源来记录状态信息&＃xff0c;这能减轻服务器的负担&＃xff0c;能够把更多的 CPU 和内存用来对外提供服务。

无状态的坏处&＃xff0c;既然服务器没有记忆能力&＃xff0c;它在完成有关联性的操作时会非常麻烦。

例如登录->添加购物车->下单->结算->支付&＃xff0c;这系列操作都要知道用户的身份才行。但服务器不知道这些请求是有关联的&＃xff0c;每次都要问一遍身份信息。

这样每操作一次&＃xff0c;都要验证信息&＃xff0c;这样的购物体验还能愉快吗&＃xff1f;别问&＃xff0c;问就是酸爽&＃xff01;

对于无状态的问题&＃xff0c;解法方案有很多种&＃xff0c;其中比较简单的方式用 COOKIE 技术。

COOKIE 通过在请求和响应报文中写入 COOKIE 信息来控制客户端的状态。

相当于&＃xff0c;在客户端第一次请求后&＃xff0c;服务器会下发一个装有客户信息的「小贴纸」&＃xff0c;后续客户端请求服务器的时候&＃xff0c;带上「小贴纸」&＃xff0c;服务器就能认得了了&＃xff0c;

2. 明文传输双刃剑

明文意味着在传输过程中的信息&＃xff0c;是可方便阅读的&＃xff0c;通过浏览器的 F12 控制台或 Wireshark 抓包都可以直接肉眼查看&＃xff0c;为我们调试工作带了极大的便利性。

但是这正是这样&＃xff0c;HTTP 的所有信息都暴露在了光天化日下&＃xff0c;相当于信息裸奔。在传输的漫长的过程中&＃xff0c;信息的内容都毫无隐私可言&＃xff0c;很容易就能被窃取&＃xff0c;如果里面有你的账号密码信息&＃xff0c;那你号没了。

3. 不安全

HTTP 比较严重的缺点就是不安全&＃xff1a;

• 通信使用明文&＃xff08;不加密&＃xff09;&＃xff0c;内容可能会被窃听。比如&＃xff0c;账号信息容易泄漏&＃xff0c;那你号没了。
• 不验证通信方的身份&＃xff0c;因此有可能遭遇伪装。比如&＃xff0c;访问假的淘宝、拼多多&＃xff0c;那你钱没了。
• 无法证明报文的完整性&＃xff0c;所以有可能已遭篡改。比如&＃xff0c;网页上植入垃圾广告&＃xff0c;视觉污染&＃xff0c;眼没了。

HTTP 的安全问题&＃xff0c;可以用 HTTPS 的方式解决&＃xff0c;也就是通过引入 SSL/TLS 层&＃xff0c;使得在安全上达到了极致。

HTTP/1.1 的性能如何&＃xff1f;

HTTP 协议是基于 TCP/IP&＃xff0c;并且使用了「请求 - 应答」的通信模式&＃xff0c;所以性能的关键就在这两点里。

1. 长连接

早期 HTTP/1.0 性能上的一个很大的问题&＃xff0c;那就是每发起一个请求&＃xff0c;都要新建一次 TCP 连接&＃xff08;三次握手&＃xff09;&＃xff0c;而且是串行请求&＃xff0c;做了无谓的 TCP 连接建立和断开&＃xff0c;增加了通信开销。

为了解决上述 TCP 连接问题&＃xff0c;HTTP/1.1 提出了长连接的通信方式&＃xff0c;也叫持久连接。这种方式的好处在于减少了 TCP 连接的重复建立和断开所造成的额外开销&＃xff0c;减轻了服务器端的负载。

持久连接的特点是&＃xff0c;只要任意一端没有明确提出断开连接&＃xff0c;则保持 TCP 连接状态。

当然&＃xff0c;如果某个 HTTP 长连接超过一定时间没有任何数据交互&＃xff0c;服务端就会主动断开这个连接。

2. 管道网络传输

HTTP/1.1 采用了长连接的方式&＃xff0c;这使得管道&＃xff08;pipeline&＃xff09;网络传输成为了可能。

即可在同一个 TCP 连接里面&＃xff0c;客户端可以发起多个请求&＃xff0c;只要第一个请求发出去了&＃xff0c;不必等其回来&＃xff0c;就可以发第二个请求出去&＃xff0c;可以减少整体的响应时间。

举例来说&＃xff0c;客户端需要请求两个资源。以前的做法是&＃xff0c;在同一个 TCP 连接里面&＃xff0c;先发送 A 请求&＃xff0c;然后等待服务器做出回应&＃xff0c;收到后再发出 B 请求。那么&＃xff0c;管道机制则是允许浏览器同时发出 A 请求和 B 请求&＃xff0c;如下图&＃xff1a;

但是服务器必须按照接收请求的顺序发送对这些管道化请求的响应。

注意&＃xff0c;是按照服务端收到的请求顺序响应&＃xff0c;并不管哪个请求是先发送的&＃xff0c;假设客户端先发送 A 请求&＃xff0c;后发送 B 请求&＃xff0c;如果服务端先收到 B 请求&＃xff0c;就先响应 B 请求&＃xff0c;然后再响应 A 请求&＃xff0c;但是假设处理 B 请求的时候&＃xff0c;耗时比较长&＃xff0c;那么请求 A 的响应就会被阻塞&＃xff0c;这称为「队头堵塞」。

所以&＃xff0c;HTTP/1.1 管道解决了请求的队头阻塞&＃xff0c;但是没有解决响应的队头阻塞。

3. 队头阻塞

「请求 - 应答」的模式加剧了 HTTP 的性能问题。

因为当顺序发送的请求序列中的一个请求因为某种原因被阻塞时&＃xff0c;在后面排队的所有请求也一同被阻塞了&＃xff0c;会招致客户端一直请求不到数据&＃xff0c;这也就是「队头阻塞」&＃xff0c;好比上班的路上塞车。

总之 HTTP/1.1 的性能一般般&＃xff0c;后续的 HTTP/2 和 HTTP/3 就是在优化 HTTP 的性能。

HTTP 与 HTTPS

HTTP 与 HTTPS 有哪些区别&＃xff1f;

1. HTTP 是超文本传输协议&＃xff0c;信息是明文传输&＃xff0c;存在安全风险的问题。HTTPS 则解决 HTTP 不安全的缺陷&＃xff0c;在 TCP 和 HTTP 网络层之间加入了 SSL/TLS 安全协议&＃xff0c;使得报文能够加密传输。
2. HTTP 连接建立相对简单&＃xff0c; TCP 三次握手之后便可进行 HTTP 的报文传输。而 HTTPS 在 TCP 三次握手之后&＃xff0c;还需进行 SSL/TLS 的握手过程&＃xff0c;才可进入加密报文传输。
3. HTTP 的端口号是 80&＃xff0c;HTTPS 的端口号是 443。
4. HTTPS 协议需要向 CA&＃xff08;证书权威机构&＃xff09;申请数字证书&＃xff0c;来保证服务器的身份是可信的。

HTTPS 解决了 HTTP 的哪些问题&＃xff1f;

HTTP 由于是明文传输&＃xff0c;所以安全上存在以下三个风险&＃xff1a;

• 窃听风险&＃xff0c;比如通信链路上可以获取通信内容&＃xff0c;用户号容易没。
• 篡改风险&＃xff0c;比如强制植入垃圾广告&＃xff0c;视觉污染&＃xff0c;用户眼容易瞎。
• 冒充风险&＃xff0c;比如冒充淘宝网站&＃xff0c;用户钱容易没。

HTTPS 在 HTTP 与 TCP 层之间加入了 SSL/TLS 协议&＃xff0c;可以很好的解决了上述的风险&＃xff1a;

• 信息加密&＃xff1a;交互信息无法被窃取&＃xff0c;但你的号会因为「自身忘记」账号而没。
• 校验机制&＃xff1a;无法篡改通信内容&＃xff0c;篡改了就不能正常显示&＃xff0c;但百度「竞价排名」依然可以搜索垃圾广告。
• 身份证书&＃xff1a;证明淘宝是真的淘宝网&＃xff0c;但你的钱还是会因为「剁手」而没。

可见&＃xff0c;只要自身不做「恶」&＃xff0c;SSL/TLS 协议是能保证通信是安全的。

HTTPS 是如何解决上面的三个风险的&＃xff1f;

• 混合加密的方式实现信息的机密性&＃xff0c;解决了窃听的风险。
• 摘要算法的方式来实现完整性&＃xff0c;它能够为数据生成独一无二的「指纹」&＃xff0c;指纹用于校验数据的完整性&＃xff0c;解决了篡改的风险。
• 将服务器公钥放入到数字证书中&＃xff0c;解决了冒充的风险。

1. 混合加密

通过混合加密的方式可以保证信息的机密性&＃xff0c;解决了窃听的风险。

HTTPS 采用的是对称加密和非对称加密结合的「混合加密」方式&＃xff1a;

• 在通信建立前采用非对称加密的方式交换「会话秘钥」&＃xff0c;后续就不再使用非对称加密。
• 在通信过程中全部使用对称加密的「会话秘钥」的方式加密明文数据。

采用「混合加密」的方式的原因&＃xff1a;

• 对称加密只使用一个密钥&＃xff0c;运算速度快&＃xff0c;密钥必须保密&＃xff0c;无法做到安全的密钥交换。
• 非对称加密使用两个密钥&＃xff1a;公钥和私钥&＃xff0c;公钥可以任意分发而私钥保密&＃xff0c;解决了密钥交换问题但速度慢。

2. 摘要算法

摘要算法用来实现完整性&＃xff0c;能够为数据生成独一无二的「指纹」&＃xff0c;用于校验数据的完整性&＃xff0c;解决了篡改的风险。

客户端在发送明文之前会通过摘要算法算出明文的「指纹」&＃xff0c;发送的时候把「指纹 &＃43; 明文」一同加密成密文后&＃xff0c;发送给服务器&＃xff0c;服务器解密后&＃xff0c;用相同的摘要算法算出发送过来的明文&＃xff0c;通过比较客户端携带的「指纹」和当前算出的「指纹」做比较&＃xff0c;若「指纹」相同&＃xff0c;说明数据是完整的。

3. 数字证书

客户端先向服务器端索要公钥&＃xff0c;然后用公钥加密信息&＃xff0c;服务器收到密文后&＃xff0c;用自己的私钥解密。

这就存在些问题&＃xff0c;如何保证公钥不被篡改和信任度&＃xff1f;

所以这里就需要借助第三方权威机构 CA &＃xff08;数字证书认证机构&＃xff09;&＃xff0c;将服务器公钥放在数字证书&＃xff08;由数字证书认证机构颁发&＃xff09;中&＃xff0c;只要证书是可信的&＃xff0c;公钥就是可信的。

通过数字证书的方式保证服务器公钥的身份&＃xff0c;解决冒充的风险。

HTTPS 是如何建立连接的&＃xff1f;其间交互了什么&＃xff1f;

SSL/TLS 协议基本流程&＃xff1a;

• 客户端向服务器索要并验证服务器的公钥。
• 双方协商生产「会话秘钥」。
• 双方采用「会话秘钥」进行加密通信。

前两步也就是 SSL/TLS 的建立过程&＃xff0c;也就是 TLS 握手阶段。

SSL/TLS 的「握手阶段」涉及四次通信&＃xff0c;可见下图&＃xff1a;

SSL/TLS 协议建立的详细流程&＃xff1a;

1. ClientHello

首先&＃xff0c;由客户端向服务器发起加密通信请求&＃xff0c;也就是 ClientHello 请求。

在这一步&＃xff0c;客户端主要向服务器发送以下信息&＃xff1a;

&＃xff08;1&＃xff09;客户端支持的 SSL/TLS 协议版本&＃xff0c;如 TLS 1.2 版本。

&＃xff08;2&＃xff09;客户端生产的随机数&＃xff08;Client Random&＃xff09;&＃xff0c;后面用于生成「会话秘钥」条件之一。

&＃xff08;3&＃xff09;客户端支持的密码套件列表&＃xff0c;如 RSA 加密算法。

2. SeverHello

服务器收到客户端请求后&＃xff0c;向客户端发出响应&＃xff0c;也就是 SeverHello。服务器回应的内容有如下内容&＃xff1a;

&＃xff08;1&＃xff09;确认 SSL/ TLS 协议版本&＃xff0c;如果浏览器不支持&＃xff0c;则关闭加密通信。

&＃xff08;2&＃xff09;服务器生产的随机数&＃xff08;Server Random&＃xff09;&＃xff0c;也是后面用于生产「会话秘钥」条件之一。

&＃xff08;3&＃xff09;确认的密码套件列表&＃xff0c;如 RSA 加密算法。

&＃xff08;4&＃xff09;服务器的数字证书。

3.客户端回应

客户端收到服务器的回应之后&＃xff0c;首先通过浏览器或者操作系统中的 CA 公钥&＃xff0c;确认服务器的数字证书的真实性。

如果证书没有问题&＃xff0c;客户端会从数字证书中取出服务器的公钥&＃xff0c;然后使用它加密报文&＃xff0c;向服务器发送如下信息&＃xff1a;

&＃xff08;1&＃xff09;一个随机数&＃xff08;pre-master key&＃xff09;。该随机数会被服务器公钥加密。

&＃xff08;2&＃xff09;加密通信算法改变通知&＃xff0c;表示随后的信息都将用「会话秘钥」加密通信。

&＃xff08;3&＃xff09;客户端握手结束通知&＃xff0c;表示客户端的握手阶段已经结束。这一项同时把之前所有内容的发生的数据做个摘要&＃xff0c;用来供服务端校验。

上面第一项的随机数是整个握手阶段的第三个随机数&＃xff0c;会发给服务端&＃xff0c;所以这个随机数客户端和服务端都是一样的。

服务器和客户端有了这三个随机数&＃xff08;Client Random、Server Random、pre-master key&＃xff09;&＃xff0c;接着就用双方协商的加密算法&＃xff0c;各自生成本次通信的「会话秘钥」。

4. 服务器的最后回应

服务器收到客户端的第三个随机数&＃xff08;pre-master key&＃xff09;之后&＃xff0c;通过协商的加密算法&＃xff0c;计算出本次通信的「会话秘钥」。

然后&＃xff0c;向客户端发送最后的信息&＃xff1a;

&＃xff08;1&＃xff09;加密通信算法改变通知&＃xff0c;表示随后的信息都将用「会话秘钥」加密通信。

&＃xff08;2&＃xff09;服务器握手结束通知&＃xff0c;表示服务器的握手阶段已经结束。这一项同时把之前所有内容的发生的数据做个摘要&＃xff0c;用来供客户端校验。

至此&＃xff0c;整个 SSL/TLS 的握手阶段全部结束。接下来&＃xff0c;客户端与服务器进入加密通信&＃xff0c;就完全是使用普通的 HTTP 协议&＃xff0c;只不过用「会话秘钥」加密内容。

HTTP/1.1、HTTP/2、HTTP/3 演变

HTTP/1.1 相比 HTTP/1.0 提高了什么性能&＃xff1f;

HTTP/1.1 相比 HTTP/1.0 性能上的改进&＃xff1a;

• 使用 TCP 长连接的方式改善了 HTTP/1.0 短连接造成的性能开销。
• 支持管道&＃xff08;pipeline&＃xff09;网络传输&＃xff0c;只要第一个请求发出去了&＃xff0c;不必等其回来&＃xff0c;就可以发第二个请求出去&＃xff0c;可以减少整体的响应时间。

但 HTTP/1.1 还是有性能瓶颈&＃xff1a;

• 请求 / 响应头部&＃xff08;Header&＃xff09;未经压缩就发送&＃xff0c;首部信息越多延迟越大。只能压缩 Body 的部分&＃xff1b;
• 发送冗长的首部。每次互相发送相同的首部造成的浪费较多&＃xff1b;
• 服务器是按请求的顺序响应的&＃xff0c;如果服务器响应慢&＃xff0c;会招致客户端一直请求不到数据&＃xff0c;也就是队头阻塞&＃xff1b;
• 没有请求优先级控制&＃xff1b;
• 请求只能从客户端开始&＃xff0c;服务器只能被动响应。

HTTP/2 做了什么优化&＃xff1f;

HTTP/2 协议是基于 HTTPS 的&＃xff0c;所以 HTTP/2 的安全性也是有保障的。

那 HTTP/2 相比 HTTP/1.1 性能上的改进&＃xff1a;

1. 头部压缩

HTTP/2 会压缩头&＃xff08;Header&＃xff09;如果你同时发出多个请求&＃xff0c;他们的头是一样的或是相似的&＃xff0c;那么&＃xff0c;协议会帮你消除重复的部分。

这就是所谓的 HPACK 算法&＃xff1a;在客户端和服务器同时维护一张头信息表&＃xff0c;所有字段都会存入这个表&＃xff0c;生成一个索引号&＃xff0c;以后就不发送同样字段了&＃xff0c;只发送索引号&＃xff0c;这样就提高速度了。

2. 二进制格式

HTTP/2 不再像 HTTP/1.1 里的纯文本形式的报文&＃xff0c;而是全面采用了二进制格式&＃xff0c;头信息和数据体都是二进制&＃xff0c;并且统称为帧&＃xff08;frame&＃xff09;&＃xff1a;头信息帧&＃xff08;Headers Frame&＃xff09;和数据帧&＃xff08;Data Frame&＃xff09;。

这样虽然对人不友好&＃xff0c;但是对计算机非常友好&＃xff0c;因为计算机只懂二进制&＃xff0c;那么收到报文后&＃xff0c;无需再将明文的报文转成二进制&＃xff0c;而是直接解析二进制报文&＃xff0c;这增加了数据传输的效率。

比如状态码 200 &＃xff0c;在 HTTP/1.1 是用 ‘2’‘0’‘0’ 三个字符来表示&＃xff08;二进制&＃xff1a;110010 110000 110000&＃xff09;&＃xff0c;如图&＃xff1a;

在 HTTP/2 是用数字 200 表示&＃xff08;二进制&＃xff1a;11001000&＃xff09;&＃xff0c;如图&＃xff1a;

3. 数据流

HTTP/2 的数据包不是按顺序发送的&＃xff0c;同一个连接里面连续的数据包&＃xff0c;可能属于不同的回应。因此&＃xff0c;必须要对数据包做标记&＃xff0c;指出它属于哪个回应。

在 HTTP/2 中每个请求或相应的所有数据包&＃xff0c;称为一个数据流&＃xff08;Stream&＃xff09;。每个数据流都标记着一个独一无二的编号&＃xff08;Stream ID&＃xff09;&＃xff0c;不同 Stream 的帧是可以乱序发送的&＃xff08;因此可以并发不同的 Stream &＃xff09;&＃xff0c;因为每个帧的头部会携带 Stream ID 信息&＃xff0c;所以接收端可以通过 Stream ID 有序组装成 HTTP 消息

客户端和服务器双方都可以建立 Stream&＃xff0c; Stream ID 也是有区别的&＃xff0c;客户端建立的 Stream 必须是奇数号&＃xff0c;而服务器建立的 Stream 必须是偶数号。

客户端还可以指定数据流的优先级。优先级高的请求&＃xff0c;服务器就先响应该请求。

4. 多路复用

HTTP/2 是可以在一个连接中并发多个请求或回应&＃xff0c;而不用按照顺序一一对应。

移除了 HTTP/1.1 中的串行请求&＃xff0c;不需要排队等待&＃xff0c;也就不会再出现「队头阻塞」问题&＃xff0c;降低了延迟&＃xff0c;大幅度提高了连接的利用率。

举例来说&＃xff0c;在一个 TCP 连接里&＃xff0c;服务器收到了客户端 A 和 B 的两个请求&＃xff0c;如果发现 A 处理过程非常耗时&＃xff0c;于是就回应 A 请求已经处理好的部分&＃xff0c;接着回应 B 请求&＃xff0c;完成后&＃xff0c;再回应 A 请求剩下的部分。

5. 服务器推送

HTTP/2 还在一定程度上改善了传统的「请求 - 应答」工作模式&＃xff0c;服务不再是被动地响应&＃xff0c;也可以主动向客户端发送消息。

比如&＃xff0c;客户端通过 HTTP/1.1 请求从服务器那获取到了 HTML 文件&＃xff0c;而 HTML 可能还需要依赖 CSS 来渲染页面&＃xff0c;这时客户端还要再发起获取 CSS 文件的请求&＃xff0c;需要两次消息往返&＃xff0c;如下图左边部分&＃xff1a;

如上图右边部分&＃xff0c;在 HTTP/2 中&＃xff0c;客户端在访问 HTML 时&＃xff0c;服务器可以直接主动推送 CSS 文件&＃xff0c;减少了消息传递的次数。

HTTP/2 有什么缺陷&＃xff1f;

HTTP/2 通过 Stream 的并发能力&＃xff0c;解决了 HTTP/1 队头阻塞的问题&＃xff0c;看似很完美了&＃xff0c;但是 HTTP/2 还是存在“队头阻塞”的问题&＃xff0c;只不过问题不是在 HTTP 这一层面&＃xff0c;而是在 TCP 这一层。

HTTP/2 是基于 TCP 协议来传输数据的&＃xff0c;TCP 是字节流协议&＃xff0c;TCP 层必须保证收到的字节数据是完整且连续的&＃xff0c;这样内核才会将缓冲区里的数据返回给 HTTP 应用&＃xff0c;那么当「前 1 个字节数据」没有到达时&＃xff0c;后收到的字节数据只能存放在内核缓冲区里&＃xff0c;只有等到这 1 个字节数据到达时&＃xff0c;HTTP/2 应用层才能从内核中拿到数据&＃xff0c;这就是 HTTP/2 队头阻塞问题。

举个例子&＃xff0c;如下图&＃xff1a;

图中发送方发送了很多个 packet&＃xff0c;每个 packet 都有自己的序号&＃xff0c;你可以认为是 TCP 的序列号&＃xff0c;其中 packet 3 在网络中丢失了&＃xff0c;即使 packet 4-6 被接收方收到后&＃xff0c;由于内核中的 TCP 数据不是连续的&＃xff0c;于是接收方的应用层就无法从内核中读取到&＃xff0c;只有等到 packet 3 重传后&＃xff0c;接收方的应用层才可以从内核中读取到数据&＃xff0c;这就是 HTTP/2 的队头阻塞问题&＃xff0c;是在 TCP 层面发生的。

所以&＃xff0c;一旦发生了丢包现象&＃xff0c;就会触发 TCP 的重传机制&＃xff0c;这样在一个 TCP 连接中的所有的 HTTP 请求都必须等待这个丢了的包被重传回来。

HTTP/3 做了哪些优化&＃xff1f;

前面我们知道了 HTTP/1.1 和 HTTP/2 都有队头阻塞的问题&＃xff1a;

• HTTP/1.1 中的管道&＃xff08; pipeline&＃xff09;虽然解决了请求的队头阻塞&＃xff0c;但是没有解决响应的队头阻塞&＃xff0c;因为服务端需要按顺序响应收到的请求&＃xff0c;如果服务端处理某个请求消耗的时间比较长&＃xff0c;那么只能等相应完这个请求后&＃xff0c; 才能处理下一个请求&＃xff0c;这属于 HTTP 层队头阻塞。
• HTTP/2 虽然通过多个请求复用一个 TCP 连接解决了 HTTP 的队头阻塞 &＃xff0c;但是一旦发生丢包&＃xff0c;就会阻塞住所有的 HTTP 请求&＃xff0c;这属于 TCP 层队头阻塞。

HTTP/2 队头阻塞的问题是因为 TCP&＃xff0c;所以 HTTP/3 把 HTTP 下层的 TCP 协议改成了 UDP&＃xff01;

UDP 发生是不管顺序&＃xff0c;也不管丢包的&＃xff0c;所以不会出现像 HTTP/2 队头阻塞的问题

大家都知道 UDP 是不可靠传输的&＃xff0c;但基于 UDP 的 QUIC 协议 可以实现类似 TCP 的可靠性传输。

QUIC 有以下 3 个特点。

1、无队头阻塞

QUIC 协议也有类似 HTTP/2 Stream 与多路复用的概念&＃xff0c;也是可以在同一条连接上并发传输多个 Stream&＃xff0c;Stream 可以认为就是一条 HTTP 请求。

QUIC 有自己的一套机制可以保证传输的可靠性的。当某个流发生丢包时&＃xff0c;只会阻塞这个流&＃xff0c;其他流不会受到影响&＃xff0c;因此不存在队头阻塞问题。这与 HTTP/2 不同&＃xff0c;HTTP/2 只要某个流中的数据包丢失了&＃xff0c;其他流也会因此受影响。

所以&＃xff0c;QUIC 连接上的多个 Stream 之间并没有依赖&＃xff0c;都是独立的&＃xff0c;某个流发生丢包了&＃xff0c;只会影响该流&＃xff0c;其他流不受影响。

2、更快的连接建立

对于 HTTP/1 和 HTTP/2 协议&＃xff0c;TCP 和 TLS 是分层的&＃xff0c;分别属于内核实现的传输层、openssl 库实现的表示层&＃xff0c;因此它们难以合并在一起&＃xff0c;需要分批次来握手&＃xff0c;先 TCP 握手&＃xff0c;再 TLS 握手。

HTTP/3 在传输数据前虽然需要 QUIC 协议握手&＃xff0c;这个握手过程只需要 1 RTT&＃xff0c;握手的目的是为确认双方的「连接 ID」&＃xff0c;连接迁移就是基于连接 ID 实现的。

但是 HTTP/3 的 QUIC 协议并不是与 TLS 分层&＃xff0c;而是QUIC 内部包含了 TLS&＃xff0c;它在自己的帧会携带 TLS 里的“记录”&＃xff0c;再加上 QUIC 使用的是 TLS/1.3&＃xff0c;因此仅需 1 个 RTT 就可以「同时」完成建立连接与密钥协商&＃xff0c;如下图&＃xff1a;

甚至&＃xff0c;在第二次连接的时候&＃xff0c;应用数据包可以和 QUIC 握手信息&＃xff08;连接信息 &＃43; TLS 信息&＃xff09;一起发送&＃xff0c;达到 0-RTT 的效果。

3、连接迁移

基于 TCP 传输协议的 HTTP 协议&＃xff0c;由于是通过四元组&＃xff08;源 IP、源端口、目的 IP、目的端口&＃xff09;确定一条 TCP 连接&＃xff0c;那么当移动设备的网络从 4G 切换到 WIFI 时&＃xff0c;意味着 IP 地址变化了&＃xff0c;那么就必须要断开连接&＃xff0c;然后重新建立连接。而建立连接的过程包含 TCP 三次握手和 TLS 四次握手的时延&＃xff0c;以及 TCP 慢启动的减速过程&＃xff0c;给用户的感觉就是网络突然卡顿了一下&＃xff0c;因此连接的迁移成本是很高的。

而 QUIC 协议没有用四元组的方式来“绑定”连接&＃xff0c;而是通过连接 ID来标记通信的两个端点&＃xff0c;客户端和服务器可以各自选择一组 ID 来标记自己&＃xff0c;因此即使移动设备的网络变化后&＃xff0c;导致 IP 地址变化了&＃xff0c;只要仍保有上下文信息&＃xff08;比如连接 ID、TLS 密钥等&＃xff09;&＃xff0c;就可以“无缝”地复用原连接&＃xff0c;消除重连的成本&＃xff0c;没有丝毫卡顿感&＃xff0c;达到了连接迁移的功能。

所以&＃xff0c; QUIC 是一个在 UDP 之上的伪 TCP &＃43; TLS &＃43; HTTP/2 的多路复用的协议。

QUIC 是新协议&＃xff0c;对于很多网络设备&＃xff0c;根本不知道什么是 QUIC&＃xff0c;只会当做 UDP&＃xff0c;这样会出现新的问题&＃xff0c;因为有的网络设备是会丢掉 UDP 包的&＃xff0c;而 QUIC 是基于UDP 实现的&＃xff0c;那么如果网络设备无法识别这个是 QUIC 包&＃xff0c;那么就会当作 UDP包&＃xff0c;然后被丢弃。

所以&＃xff0c;HTTP/3 现在普及的进度非常的缓慢&＃xff0c;不知道未来 UDP 是否能够逆袭 TCP。

参考资料&＃xff1a;

[1] 上野 宣.图解HTTP.人民邮电出版社.

[2] 罗剑锋.透视HTTP协议.极客时间.

[3] 陈皓.HTTP的前世今.酷壳CoolShell.https://coolshell.cn/articles/19840.html

[4] 阮一峰.HTTP 协议入门.阮一峰的网络日志.http://www.ruanyifeng.com/blog/2016/08/http.html

读者问答

读者问&＃xff1a;“https和http相比&＃xff0c;就是传输的内容多了对称加密&＃xff0c;可以这么理解吗&＃xff1f;”

1. 建立连接时候&＃xff1a;https 比 http多了 TLS 的握手过程&＃xff1b;

2. 传输内容的时候&＃xff1a;https 会把数据进行加密&＃xff0c;通常是对称加密数据&＃xff1b;

读者问&＃xff1a;“ 我看文中 TLS 和 SSL 没有做区分&＃xff0c;这两个需要区分吗&＃xff1f;”

这两实际上是一个东西。

SSL 是洋文 “Secure Sockets Layer 的缩写&＃xff0c;中文叫做「安全套接层」。它是在上世纪 90 年代中期&＃xff0c;由网景公司设计的。

到了1999年&＃xff0c;SSL 因为应用广泛&＃xff0c;已经成为互联网上的事实标准。IETF 就在那年把 SSL 标准化。标准化之后的名称改为 TLS&＃xff08;是 “Transport Layer Security” 的缩写&＃xff09;&＃xff0c;中文叫做 「传输层安全协议」。

很多相关的文章都把这两者并列称呼&＃xff08;SSL/TLS&＃xff09;&＃xff0c;因为这两者可以视作同一个东西的不同阶段。

读者问&＃xff1a;“为啥 ssl 的握手是 4 次&＃xff1f;”

SSL/TLS 1.2 需要 4 握手&＃xff0c;需要 2 个 RTT 的时延&＃xff0c;我文中的图是把每个交互分开画了&＃xff0c;实际上把他们合在一起发送&＃xff0c;就是 4 次握手&＃xff1a;

另外&＃xff0c; SSL/TLS 1.3 优化了过程&＃xff0c;只需要 1 个 RTT 往返时延&＃xff0c;也就是只需要 3 次握手&＃xff1a;

小林是专为大家图解的工具人&＃xff0c;Goodbye&＃xff0c;我们下次见&＃xff01;