Http

Adrian Yang

Adrian Yang

Front End Engineer

HTTP

hyoertext transport protocol 也叫超文本传输协议, 是一种基于TCP/IP 的应用层通信协议,这个协议详细制定了浏览器和万维网服务器之间互相通信的规则

  • 是什么:超文本传输协议(属于应用层协议)
  • 特点:无状态,现在cookie解决了无状态的问题(早期网页开发时,用cookie解决,现在是cookie和session配合使用)
  • 作用:规定了服务器和客户端传递信息的规则(统称为报文,分为:请求报文、响应报文。)
  • 版本:
    • http 1.0 (老版本) ---------- 不支持长连接
    • http 1.1 (主流版本)--------- 优点:支持长连接,弊端:同时发送资源的数量过小。
    • http 2.0 (最新版) ---------- 同时发送资源的数量稍有提升。
  • 报文(请求报文、响应报文)的组成: 1.报文首行 2.报文头 3.空行(仅仅作为一个分割) 4.报文体

HTTP 的长连接 和 短连接

HTTP协议与TCP/IP协议的关系

  HTTP的长连接和短连接本质上是TCP长连接和短连接。HTTP属于应用层协议,在传输层使用TCP协议,在网络层使用IP协议。IP协议主要解决网络路由和寻址问题,TCP协议主要解决如何在IP层之上可靠的传递数据包,使在网络上的另一端收到发端发出的所有包,并且顺序与发出顺序一致。TCP有可靠,面向连接的特点。

什么是长连接、短连接?

在HTTP/1.0中,默认使用的是短连接。也就是说,浏览器和服务器每进行一次HTTP操作,就建立一次连接,但任务结束就中断连接。如果客户端浏览器访问的某个HTML或其他类型的 Web页中包含有其他的Web资源,如JavaScript文件、图像文件、CSS文件等;当浏览器每遇到这样一个Web资源,就会建立一个HTTP会话。

但从 HTTP/1.1起,默认使用长连接,用以保持连接特性。使用长连接的HTTP协议.

在使用长连接的情况下,当一个网页打开完成后,客户端和服务器之间用于传输HTTP数据的 TCP连接不会关闭,如果客户端再次访问这个服务器上的网页,会继续使用这一条已经建立的连接。Keep-Alive不会永久保持连接,它有一个保持时间,可以在不同的服务器软件(如Apache)中设定这个时间。实现长连接要客户端和服务端都支持长连接。

GET请求报文

(给服务器看的)-- 通过form表单发送的GET请求

GET http://localhost:3000/?name=kobe&password=123 HTTP/1.1
Host: localhost:3000
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
DNT: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Referer: http://localhost:63347/0719_node/demo.html?_ijt=tphpp47dag8jevtqrnq44blv6p
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
Cookie: Webstorm-9af2238=09820128-3adb-43e4-8242-a6f65c9e523a
空行
空行

请求报文首行

GET http://localhost:3000/?name=kobe&password=123 HTTP/1.1
-请求方式 协议名://主机地址:端口号/?urlencoded编码形式的参数 协议名/版本

请求报文头

Host: localhost:3000
--发送请求的目标主机:主机名:端口号
Connection: keep-alive
--浏览器告诉服务器,浏览器支持长连接。
Pragma: no-cache
-- 不走缓存
Cache-Control: no-cache
-- 不走缓存(强缓存) expires
Upgrade-Insecure-Requests: 1
-- 浏览器告诉服务器可以使用 https或http1.1
DNT: 1
-- 浏览器告诉服务器:禁止跟踪。最终是否跟踪,还得看服务器是否配合。
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Safari/537.36
-- 用户代理:之前该字段用于判断用户的浏览器品牌以及版本,但是现在不好用了。
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
-- 浏览器能够接收资源的类型及优先级,优先级不写默认是1,1的优先级是最高的。
Referer: http://localhost:63347/0719_node/demo.html?_ijt=tphpp47dag8jevtqrnq44blv6p
-- 本次请求是“站”在哪里发出去的。 1.防盗链。 2.广告计费
Accept-Encoding: gzip, deflate, br
-- 浏览器告诉服务器,浏览器所能接受的压缩文件类型。
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
-- 浏览器告诉服务器,浏览器所能支持的语言种类,及权重。
Cookie: Webstorm-9af2238=09820128-3adb-43e4-8242-a6f65c9e523a
-- Webstorm给你种下的cookie

请求报文体

GET请求没有报文体

POST请求报文

(给服务器看的)-- 通过form表单发送的POST请求

POST http://localhost:3000/ HTTP/1.1
Host: localhost:3000
Connection: keep-alive
Content-Length: 22
Pragma: no-cache
Cache-Control: no-cache
Origin: http://localhost:63347
Upgrade-Insecure-Requests: 1
DNT: 1
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Referer: http://localhost:63347/0719_node/day04/5.http%E6%8A%A5%E6%96%87&%E7%8A%B6%E6%80%81%E7%A0%81/%E6%BC%94%E7%A4%BA%E9%98%B2%E7%9B%97%E9%93%BE.html?_ijt=v73gogoe0uaatcie38ma6l7gso
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
Cookie: Webstorm-9af2238=09820128-3adb-43e4-8242-a6f65c9e523a
空行
name=kobe&password=123

请求报文首行

POST http://localhost:3000/ HTTP/1.1

请求报文头

  • Content-Type: application/x-www-form-urlencoded 常用于原生form 表单的提交
  • Connection: keep-alive 默认使用长连接,用以保持连接特性。
Host: localhost:3000
Connection: keep-alive
【Content-Length: 22】
-- 返回数据的长度
Pragma: no-cache
Cache-Control: no-cache
【Origin: http://localhost:63347】
-- 精简版的Referer 1.防盗链。 2.广告计费
Upgrade-Insecure-Requests: 1
DNT: 1
【Content-Type: application/x-www-form-urlencoded】
--浏览器告诉服务器,发送数据的类型
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Referer: http://localhost:63347/node/demo.html?_ijt=r08g7l67qsmghv05cf7mphidka
-- “站”在哪里发出去的请求(源站) 1.防盗链。 2.广告计费
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
Cookie: Webstorm-9af2238=09820128-3adb-43e4-8242-a6f65c9e523a
空行

请求报文体

name=kobe&password=123 // 请求体参数
编码类型 urlencoded

备注:

1.form表单的 post请求和get请求 参数均已urlencoded形式进行编码
2.get请求将urlencoded编码的参数放入请求地址携带给服务器,所以称之为:查询字符串参数。
3.post请求将urlencoded编码的参数放入请求体,所以称之为:请求体参数。

响应报文

(给浏览器看的)

HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: text/html; charset=utf-8
Content-Length: 2
ETag: W/"2-eoX0dku9ba8cNUXvu/DyeabcC+s"
Date: Fri, 01 Nov 2019 08:24:19 GMT
Connection: keep-alive
空行
ok

报文首行

HTTP/1.1 200 OK
--协议名/协议版本 状态码

报文头

X-Powered-By: Express
--服务器所采用的框架(尽量不要让用户知道服务器具体采用的技术)
Content-Type: text/html; charset=utf-8
--告诉浏览器返回资源的类型及编码格式
Content-Length: 2
--返回数据的长度
ETag: W/"2-eoX0dku9ba8cNUXvu/DyeabcC+s"
--协商缓存必要字段
Date: Fri, 01 Nov 2019 08:24:19 GMT
--响应的日期+时间
Connection: keep-alive
--服务器告诉浏览器,下次请求时,或许会采用长连接。

报文体

ok
# **HTTP 协议面试题**

HTTP 面试题

HTTP 请求的方式?

GET

POST

Head: 类似于 get 请求 用于提前请求文件的大小,请求的文件是否可以访问,以及文件最后修改时间

Option: 允许服务端查看服务器性能 比如服务器支持的请求方式

PUT

DELETE

增删改查 put-delete-post-get

get post 的区别? get的请求参数可不可以放到Body里面呢?

数据的传输方式包参数大小
GET通过 url 传输数据一个限制读数据
POST通过请求消息体Body两个以上无限制写数据

GET 类似查找的过程,用户获取数据,不需要每次都与数据库建立连接,所以可以使用缓存

POST 操作过程, 进行修改 和 删除,必须与数据库交互,不能使用缓存.

POST 请求两个以上的包 因为有请求体

GET 最大长度是因为 web 服务器限制 URL 的长度

HTTP 与 HTTPS

SSL加密是在传输层实现的 (secure socket layer)

需要 ca 证书

http默认端口为80,对于传输采用不加密的方式,而https默认端口为443,对于传输的数据进行加密传输。

对称加密:

又称私钥加密,即信息的发送方和接收方使用同一个密钥去加密和解密数据,对称加密的特点是算法公开,加密和解密的速度快,适合于大数据量进行加密。加密过程中的私钥与解密过程中的私钥是同一个密钥,因此成为对称加密,由于对称加密的算法公开,因此密钥一旦被泄漏,那么密文就很容易被破解,所以对称加密的缺点是密钥安全管理困难。

非对称加密:

又称为公钥加密,与对称加密相比,安全性更高,非对称加密使用一对密钥,分别为公钥和私钥,且二者成对出现,私钥被自己保存,不能对外泄露,公钥指的是公共的密钥,任何人都可以获取。用公钥和密钥中的任何一个进行加密,用另一个进行解密。缺点是加密和解密的时间长,速度慢,只适合对少量数据进行加密。

HTTPS通信过程:

HTTPS协议=HTTP协议+SSL/TLS协议,HTTPS为了兼顾安全与效率,同时使用了对称加密和非对称加密。具体是数据是利用对称加密进行传输,而对称加密的过程需要客户端的一个密钥,为了确保能把密钥安全传输到服务器端,采用非对称加密的方式去对该密钥再进行加密传输,总的来说,就是对数据进行对称加密,而对称加密所需的密钥通过非对称加密传输。

HTTPS请求过程:共四次握手
  1. 首先用户向服务器端发送HTTPS请求,请求到服务器端的443端口上。
  2. 服务器端有一对密钥,分别为公钥和私钥,私钥由服务器端自身保存并且不可泄露,公钥可以传递给任何人。
  3. 服务器端向客户端发送公钥
  4. 客户端接收到公钥之后,首先检测公钥是否合法,如果不合法则此次HTTPS传输无效,如果公钥合格,就会生成一个随机值,这个随机值就是用于进行对称加密的密钥,我们成它为客户端密钥,主要是为了和服务器端上的密钥进行区分,然后用服务器端传递过来的公钥对这个客户端密钥进行非对称加密,这样客户端密钥就变成了密文,然后再传递给服务器端。
  5. 服务器端接收到密文之后,用私钥对其进行非对称加密,获取到明文就是客户端密钥,然后用客户端密钥对数据进行对称加密,然后将加密后的密文再传递给客户端。
  6. 客户端接收到服务器端传递过来的密文,用客户端密钥进行对称解密,得到服务器端传递过来的数据。

HTTP 2.0

HTTP1.1

  • 添加了可持久链接 (connection)
  • etag cache-control
  • 支持文件断点续传

HTTP2.0

  • 多路复用
  • 添加了加密
  • 头部压缩
  • 服务器推送

对于 1999年发布的 HTTP1.0 的首次更新, 基于HTTPS

允许多路复用

改善了针对同一个域名下 同一时间的 一定量的请求限制

二进制分帧

将传输的信息分割为更小的信息 或者 帧 并对他们的二进制首部进行压缩

HTTP/2中,每个用户的操作行为被分配了一个流编号(stream ID),这意味着用户与服务端之间创建了一个TCP通道;协议将每个请求分割为二进制的控制帧与数据帧部分,以便解析

HTTP1.x 基于文本

Header压缩:

使用HPACK 算法

在http1中,我们使用文本的形式传输header,在header携带cookies的情况下,可能每次都要重复传输几百到几千的字节。

而在http2中,使用header压缩可以减少每次传输的大小,在两端维护了索引表,用于记录出现过的header,在之后的传输过程中就可以传输已经记录过的header键名,对端收到数据后就可以通过键名找到对应的值。

服务器端Push

在http2中,服务器可以再客户端某个请求之后主要推送其他资源。这允许服务器直接提供浏览器渲染页面所需资源,而无须浏览器在收到、解析页面后再提起一轮请求,节约了加载时间。

例如某些资源客户端是一定会请求的,这时就可以采取服务器端push技术,提前给客户端推送必要的资源,这样就可以节省一些请求时的开销减少一些延迟时间。

强缓存 和 协商缓存

根据header 内容来决定

强缓存:

浏览器直接从本地存储中获得数据 不与服务器进行交互 (200 from cache)

  • Expires(该字段是 http1.0 时的规范,值为一个绝对时间的 GMT 格式的时间字符串,代表缓存资源的过期时间)
  • Cache-Control:max-age(该字段是 http1.1 的规范,强缓存利用其 max-age 值来判断缓存资源的最大生命周期,它的值单位为秒)

协商缓存:

浏览器发送请求(Get), 服务器来告知告知缓存是否可用 (304 not modified)

  • Last-Modified(值为资源最后更新时间,随服务器response返回)
  • If-Modified-Since(通过比较两个时间来判断资源在两次请求期间是否有过修改,如果没有修改,则命中协商缓存)
  • ETag(表示资源内容的唯一标识,随服务器response返回)
  • If-None-Match(服务器通过比较请求头部的If-None-Match与当前资源的ETag是否一致来判断资源是否在两次请求之间有过修改,如果没有修改,则命中协商缓存)

Fetch 发送两次请求的原因

Fetch API 提供了一个 JavaScript 接口,用于访问和操纵 HTTP 管道的一些具体部分,例如请求和响应。它还提供了一个全局 fetch() 方法,该方法提供了一种简单,合理的方式来跨网络异步获取资源。

第一次发送options 请求: 询问服务器是否支持修改请求头

如果可以第二次发送真正的请求

var request = new Request('/users.json', {
method: 'POST',
mode: 'cors',
redirect: 'follow',
headers: new Headers({
'Content-Type': 'text/plain'
})
});
// 使用!
fetch(request).then(function() { /* handle response */ });
//处理 JSON 响应
fetch('https://davidwalsh.name/demo/arsenal.json').then(function(response) {
// 转换为 JSON
return response.json();
}).then(function(j) {
// 现在, `j` 是一个 JavaScript object
console.log(j);
});

TCP

TCP头部一些字段:

  • 序列号(seq):这个序号保证了TCP传输的报文是有序的,对端可以通过序号来拼接报文字段。
  • 确认号:这个序号表示数据接接收端期望接收的下一个字节的编号是多少,
  • 窗口大小(Window Size):表示还能接收多少字节的数据,用于流量控制。
  • 标识符:
    • ACK=1:该字段为表示确认号字段是有效的,此外TCP还规定在连接建立后传送的所有报文必须将ACK设为1.
    • SYN=1:当SYN=1,ACK=0时,表示当前报文段是一个连接请求报文,当SYN=1,ACK=1时,表示当前报文段是一个同意建立连接的应答报文。
    • FIN=1:该字段为一表示此报文段是一个释放连接的请求报文。

TCP 三次握手

  1. 客户端发送SYN (SYN=1,seq=x),进入SYN_SEND状态
  2. 服务端发送 SYN + ACK (SYN=1,ACK=1,确认序号=x+1,seq=y),进入SYN_RECV 状态
  3. 客户端回复ACK :ACK=1,确认序号=y+1,seq=x+1 客户端发送完这个报文段后便进入到ESTABLISHED状态,服务器端收到这个应答后也进入ESTABLISHED状态,此时连接建立成功。

TCP 和 UDP 的区别

TCP : 面向连接 提供可靠服务 面向字节流 首部较大为20字节

UDP: 无连接 最大尽力交付(不可靠) 面向报文 首部为 8 字节

DNS 解析

DNS解析的就是通过域名系统查询对应的IP。

具体过程为首先当用户在url中输入一个网址后,操作系统首先会在本地缓存中查询,若本地缓存中查询到就向用户返回对应的IP,若没有则去系统配置的DNS服务器中查询,本地服务器向根域名服务器中查询,根域名服务器返回顶级域名服务器的ip地址的列表,本地服务器向顶级域名服务器发送请求,顶级域名服务器返回权威域名服务器的IP地址列表,然后本地服务器再向权威域名服务器发送请求,最后权威域名服务器返回一个与主机名对应的IP地址列表。

递归查询指的是当我们发起一次请求后,域名服务器代为向下一级服务器发起请求,最终返回一个结果给我们,用户只需发起一次请求即可。

而迭代查询指的是用户发起一次请求之后,域名服务器返回单次查询的结果,下一次域名服务器还需要用户自己发起请求查询,迭代查询需要发起多次查询才会返回最终的查询结果。

那么我们向本地DNS服务器发起请求的方式就是递归请求,因为我们只需发起一次请求,等待本地服务器返回最终结果给我们。而本地DNS服务器向域名服务器发起请求属于迭代请求,需要本地服务器一次次的向不同级域名服务器发起请求才会返回最终的结果。

怎么跨域, JSONP CORS postMessage 是什么?

CORS

Cross-Origin Resource Sharing 跨源资源共享 使用自定义的HTTP 头部

HTTP 头部中额外添加 Origin

因为浏览器出于安全考虑,有同源策略。也就是说,如果协议、域名或者端口有一个不同就是跨域,Ajax 请求会失败。
为来防止CSRF攻击
1.JSONP
JSONP 的原理很简单,就是利用 <script> 标签没有跨域限制的漏洞。
通过 <script> 标签指向一个需要访问的地址并提供一个回调函数来接收数据当需要通讯时。
<script src="http://domain/api?param1=a&param2=b&callback=jsonp"></script>
<script>
function jsonp(data) {
console.log(data)
}
</script>
JSONP 使用简单且兼容性不错,但是只限于 get 请求,因为Sctipt 标签只能使用 get 请求
JSONP 需要配合后端返回指定格式的数据 JSON.stringifty() 后端返回的数据,前端以JS 解析,并且运行
2.CORS
CORS 需要浏览器和后端同时支持,需要设置 Access-Control-Allow-Origin:http://foo.example
IE 8 和 9 需要通过 XDomainRequest 来实现。
3.postMessage
这种方式通常用于获取嵌入页面中的第三方页面数据。一个页面发送消息,另一个页面判断来源并接收消息
补充:
JSONP和AJAX相比的优缺点?
1.JSONP可以跨域
2.因为JSONP是通过script标签发送的GET请求,所以读不到AJAX那么精确的状态码

Ajax 的四个步骤?

  1. 创建 Ajax 实例
  2. 执行 open 确定要访问的链接 以及异步同步
  3. 监听请求状态
  4. 发送请求
var request = new XMLHttpRequest()
request.open('GET', '/a/b/c?name=ff', true) // 第三个参数表示异步请求
request.onload = ()=> console.log(request.responseText)
request.send()
// 实现一个 ajax
var xhr = new XMLHttpRequest()
// 必须在调用 open()之前指定 onreadystatechange 事件处理程序才能确保跨浏览器兼容性
xhr.onreadystatechange = function () {
if (xhr.readyState === 4) {
if (xhr.status >= 200 && xhr.status < 300 || xhr.status ==== 304) {
console.log(xhr.responseText)
} else {
console.log('Error:' + xhr.status)
}
}
}
// 第三个参数表示异步发送请求
xhr.open('get', '/api/getSth', true)
// 参数为作为请求主体发送的数据
xhr.send(null)
// 将原生的ajax 封装为 promise
const ajax = (url, method, async, data) => {
return new Promise((resolve, reject) => {
const xhr = new XMLHttpRequest()
xhr.onreadystatechange = () => {
// 已经接收到全部响应数据,而且已经可以在客户端使用了
if (xhr.readyState === 4) {
if (xhr.status === 200) {
resolve(JSON.parse(xhr.responseText))
} else if (xhr.status > 400) {
reject('发生错误')
}
}
}
xhr.open(url, method, async)
xhr.send(data || null)
})
}

ajax 的 readyState 状态都代表什么?

  • 0:未初始化,但是已经创建了XHR实例
  • 1:调用了open()函数
  • 2:已经调用了send()函数,但还未收到服务器回应
  • 3:正在接受服务器返回的数据
  • 4:完成响应

HTTP 状态码

特性:
HTTP 是无连接无状态的
HTTP 一般构建于 TCP/IP 协议之上,默认端口号是 80
HTTP 可以分为两个部分,即请求和响应。
区分状态码
1××开头 - 信息提示 服务器已经收到了本次请求,但是还需要进一步的处理才可以。
2××开头 - 请求成功 服务器已经收到了本次请求,且已经分析、处理等...最终处理完毕!
3××开头 - 重定向 服务器已经接收到了请求,还需要其他的资源,或者重定向到其他位置,甚至交给其他服务器处理
4××开头 - 请求错误 一般指请求的参数或者地址有错误, 出现了服务器无法理解的请求(一般是前端的锅)
5××开头 - 服务器错误 不是因为请求地址或者请求参数不当造成的),无法响应用户请求(一般是后端人员的锅)
常见状态码
200 OK 客户端请求成功。 一般用于GET 和 POST请求
301 Moved Permanently 请求永久重定向。
302 Moved Temporarily 请求临时重定向。
304 Not Modified 命中了协商缓存 文件未修改,可以直接使用缓存的文件。
400 Bad Request 服务器不理解请求的语法(比如 没有JSON.stringify)
401 Unauthorized 未授权,无法访问。
403 Forbidden // !拒绝 服务器收到请求,但是拒绝提供服务。服务器通常会在响应正文中给出不提供服务的原因。
404 Not Found 请求的资源不存在,比如输入了错误的URL。
500 Internal Server Error 服务器发生不可预期的错误,导致无法完成客户端的请求。
502
503 Service Unavailable 服务器当前不能够处理客户端的请求,在一段时间之后,服务器可能会恢复正常。
补充:301 和 302 的区别是什么?
301 永久重定向,浏览器会记住 (旧地址被永久移除) 将会跳转到一个新资源,搜索引擎在抓取新内容的同时也将旧的网址替换为重定向之后的网址;
302 临时重定向 (旧地址资源还在 只不过转移到了新地址) 但会临时跳转到一个新资源,搜索引擎会抓取新的内容而保存旧的网址。

一次 HTTP 请求的过程?

  • DNS

  • TCP 3次握手

  • 浏览器发起HTTP 请求

  • 服务器相应HTTP 请求

  • 浏览器解析html 并请求HTML 中的资源

从用户输入URl按下回车,一直到用户能看到界面,期间经历了什么?

一、DNS解析----域名翻译成IP地址(优先走缓存):

  • 1.找浏览器DNS缓存解析域名
  • 2.找本机DNS缓存:(备注:查看本机DNS缓存命令:ipconfig/displaydns > C:/dns.txt)
  • 3.找路由器DNS缓存
  • 4.找运营商DNS缓存(80%的DNS查找,到这一步就结束)
  • 5.递归查询 (查询全球13台根DNS服务器)

二、进行TCP(协议)连接,三次握手(根据上一步请求回来的ip地址,去联系服务器)

  • 第一次握手:由浏览器发给服务器,我想和你说话,你能“听见”嘛?
  • 第二次握手:由服务器发给浏览器,我能听得见,你说吧!
  • 第三次握手:由浏览器发给服务器,好,那我就开始说话。

三、发送请求(请求报文)

四、得到响应(响应报文)

五、浏览器开始解析html

  • --预解析:将所有外部的资源,发请求出去
  • --解析html,生成DOM树
  • --解析CSS,生成CSS树
  • --合并成一个render树
  • --js是否操作了DOM或样式
  • --有:进行重绘重排(不好,1.尽量避免;2.最小化重绘重排)
  • --没有:null
  • --最终展示界面

六、断开TCP连接,四次挥手(确保数据的完整性)

  • 第一次挥手:由浏览器发给服务器,我的东西接受完了,你断开吧。
  • 第二次挥手:--由服务器发给浏览器,我还有一些东西没接收完,你等一会,我接收好了且验证好了我告诉你
    * --由服务器发给浏览器,我的东西接收完了,但是你还得等一会,我要验证数据的完整性,验证完了我告诉你。
  • 第三次挥手:由服务器发给浏览器,我接收完(验证完)了,你断开吧。
  • 第四次挥手:由浏览器发给服务器,好的,那我断开了。
  • 备注:为什么握手要三次,挥手要四次?
  • 握手之前,还没有进行数据的传输,确保握手就可以了。
  • 挥手之前,正在进行数据的传输,为了确保数据的完整性,必须多经历一次验证(继续接收)

Cookie

关于cookie:是什么?

  • 本质就是一个【字符串】,里面包含着浏览器和服务器沟通的信息(交互时产生的信息)。

  • 存储的形式以:【key-value】的形式存储。

  • 浏览器会自动携带该网站的cookie,只要是该网站下的cookie,全部携带。

2.分类:

  • --会话cookie(关闭浏览器后,会话cookie会自动消失,会话cookie存储在浏览器运行的那块【内存】上)。

  • --持久化cookie:(看过期时间,一旦到了过期时间,自动销毁,存储在用户的硬盘上,备注:如果没有到过期时间,同时用户清理了浏览器的缓存,持久化cookie也会消失)

3.工作原理:

  • --当浏览器第一次请求服务器的时候,服务器可能返回一个或多个cookie给浏览器

  • --浏览器判断cookie种类

  • --会话cookie:存储在浏览器运行的那块内存上

  • --持久化cookie:存储在用户的硬盘上

  • --以后请求该网站的时候,自动携带上该网站的所有cookie(无法进行干预)

  • --服务器拿到之前自己“种”下cookie,分析里面的内容,校验cookie的合法性,根据cookie里保存的内容,进行具体的业务逻辑

4.应用:

  • 解决http无状态的问题(例子:7天免登录,一般来说不会单独使用cookie,一般配合后台的session存储使用)

5.不同的语言、不同的后端架构cookie的具体语法是不一样的,但是cookie原理和工作过程是不变的。

  • 备注:cookie不一定只由服务器生成,前端同样可以生成cookie,但是前端生成的cookie几乎没有意义。

6.对比浏览器的本地存储:

  • 1.localStorage:

    • (1).保存的数据,只要用户不清除,一直存在

    • (2).作为一个中转人,实现跨页签通信

    • (3).保存数据的大小:5MB - 10MB

  • 2.sessionStorage:

    • (1).保存的数据,关闭浏览器就消失
    • (3).保存数据的大小:5MB - 10MB
  • 3.cookie:

    • (1).分类:会话cookie----关浏览器消失、持久化cookie----到过期时间消失
    • (2).保存数据的大小:4K --- 8K
    • (3).主要用于解决http无状态(一般配合后端的session会话存储使用)
    • (4).浏览器请求服务器时,会自动携带该网站的所有cookie
let cookieParser = require('cookie-parser')
router.use(cookieParser())
app.get('/demo',function (req,res) {
res.send('我是demo路由给你的反馈,我没有对cookie进行任何的操作')
})
//会话cookie,关闭浏览器即立刻消失
//demo1路由,负责给客户端“种”下一个会话cookie
app.get('/demo1',function (req,res) {
//express中给客户端“种”cookie不需要任何的库
let obj = {school:'jsut',subject:'front end'}
res.cookie('peiqi',JSON.stringify(obj)) //给客户端种下一个会话cookie
res.send('我是demo1路由给你的反馈,我给你种下了一个【会话cookie】,你赶紧去浏览器里看看!')
})
//demo2路由,负责给客户端“种”下一个持久化cookie
app.get('/demo2',function (req,res) {
let obj = {school:'jsut2',subject:'front end2'}
res.cookie('peiqi',JSON.stringify(obj),{maxAge:1000 * 60 * 60 *24 *30}) //给客户端种下一个持久化cookie
res.send('我是demo2路由给你的反馈,我给你种下了一个【持久化cookie】,你赶紧去浏览器里看看!')
})
//demo3路由,负责读取客户端所携带过来的cookie
app.get('/demo3',function (req,res) {
//express中读取客户端携带过来的cookie要借助一个中间件,名为:cookie-parser
console.log(req.cookies);
const {peiqi} = req.cookies
let a = JSON.parse(peiqi)
console.log(a.school)
res.send('我是demo3路由,我读取了你携带过来的cookie,你去服务器控制台看看吧')
})
//demo4路由,负责告诉客户端删除一个cokkie
app.get('/demo4',function (req,res) {
//res.cookie('peiqi','',{maxAge:0})
res.clearCookie('peiqi')
res.send('兄台,我删除了你所保存的key为peiqi的那个cookie')
})

Session

关于session是什么?

  • 标准来说,session这个单词指的是会话。

    • (1).前端通过浏览器去查看cookie的时候,会发现有些cookie的过期时间是:session,意味着该cookie是会话cookie。

    • (2).后端人员常常把【session会话存储】简称为:session存储,或者更简单的称为:session

2.特点:

  • 1.存在于服务端

  • 2.存储的是浏览器和服务器之间沟通产生的一些信息

3.默认session的存储在服务器的内存中,每当一个新客户端发来请求,服务器都会新开辟出一块空间,供session会话存储使用。

4.工作流程:

  • --第一次浏览器请求服务器的时候,服务器会开辟出一块内存空间,供session会话存储使用。

  • --返回响应的时候,会自动返回一个cookie(有时候会返回多个,为了安全),cookie里包含着,上一步产生会话存储“容器”的编号(id)

  • --以后请求的时候,会自动携带这个cookie,给服务器。

  • --服务器从该cookie中拿到对应的session的id,去服务器中匹配。

  • --服务器会根据匹配信息,决定下一步逻辑

5.备注:

  • 1.一般来说cookie一定会配合session使用。
  • 2.服务端一般会做session的持久化,防止由于服务器重启,造成session的丢失。

  • 3.session什么时候销毁?

  • (1).服务器没有做session的持久化的同时,服务器重启了。

  • (2).给客户端种下的那个用于保存session编号的cookie销毁了,随之服务器保存的session销毁(不管是否做了session的持久化)。

  • (3).用户主动在网页上点击了“注销” “退出登录”等等按钮。
//如下代码是配置express中操作session
//引入express-session,用于在express中简化操作session
const session = require('express-session');
//引入connect-mongo,用于做session持久化
const MongoStore = require('connect-mongo')(session);
app.use(session({
name: 'peiqi', //返回给客户端cookie的key。
secret: 'druids', //参与加密的字符串(又称签名)
saveUninitialized: false, //是否在存储内容之前创建session会话
resave: true ,//是否在每次请求时,强制重新保存session,即使他们没有变化(比较保险)
store: new MongoStore({
url: 'mongodb://localhost:27017/sessions_container',
touchAfter: 24 * 3600 //修改频率(例://在24小时之内只更新一次)
}),
cookie: {
httpOnly: true, // 开启后前端无法通过 JS 操作cookie
maxAge: 1000*30 // 设置cookie的过期时间,cookie的key,cookie的value,均不在此处配置。
},
}));
=======
路由中的逻辑
if(data){
//1.为请求开辟一个session会话存储空间
//2.将客户端与服务器沟通产生的数据放入session会话存储空间
//3.获取session会话存储空间的id
//4.返回给客户端一个cookie,包含着:将上一步的id。
//备注:如果使用了一些第三方库,以上四步,一行代码就可以完成。
//res.cookie('_id',data._id.toString(),{maxAge:1000*60})
req.session._id = data._id.toString()
res.redirect(`http://localhost:3000/user_center`) //此种方法浏览器的地址栏残留的东西太多了。
return
}
=======
//用于展示个人中心界面的路由,无其他任何逻辑 ----- UI路由
router.get('/user_center',(req,res)=>{
//1.获取客户端通过cookie携带过来的session编号
//2.根据session编号匹配session容器
//3.若匹配上:拿到session容器里的数据,去使用
//4.若未匹配上:驳回,去登录
const {_id} = req.session // req携带过来的是cookie:{key:peiqi,value:经过加密的session编号}

express中操作cookie和session教程

一、操作cookie:

1. 设置cookie(给客户端“种”cookie):
直接使用res.cookie('','',{})即可。
2. 获取cookie(要第三方中间件):
* 安装:npm i cookie-parser
* 引入:const cookieParser = require('cookie-parser')
* 使用:app.use(cookieParser())
3. 返回给客户端一个cookie:
* res.cookie('username','peiqi',{maxAge:1000*60*60})
备注:1.cookie是以:key-value的形式存在的,前两个参数分别为:key、value。
2.maxAge用于配置cookie有效期(单位毫秒)。
3.如果不传入maxAge配置对象,则为会话cookie,随着浏览器的关闭cookie自动会消失。
4.如果传入maxAge,且maxAge不为0,则cookie为持久化cookie,即使用户关闭浏览器,
cookie也不会消失,直到过了它的有效期。
4. 接收客户端传递过来的cookie:
* req.cookies.xxx :获取cookie上xxx属性对应的值。
备注:cookie-parser中间件会自动把客户端发送过来的cookie解析到request对象上。

二、操作session(cookie配合session):

1. 下载安装:`npm i express-session --save` 用于在express中操作session
2. 下载安装:`npm i connect-mongo --save` 用于将session写入数据库(session持久化)
3. 引入express-session模块:
`const session = require('express-session');`
4. 引入connect-mongo模块:
`const MongoStore = require('connect-mongo')(session);`
5. 编写全局配置对象:
` app.use(session({
name: 'userid', //设置cookie的name,默认值是:connect.sid
secret: 'druid', //参与加密的字符串(又称签名)
saveUninitialized: false, //是否在存储内容之前创建会话
resave: true ,//是否在每次请求时,强制重新保存session,即使他们没有变化
store: new MongoStore({
url: 'mongodb://localhost:27017/sessions_container',
touchAfter: 24 * 3600 //修改频率(例://在24小时之内只更新一次)
}),
cookie: {
httpOnly: true, // 开启后前端无法通过 JS 操作cookie
maxAge: 1000*30 // 设置cookie的过期时间
},
}));`
6. 向session中添加一个xxxx,值为yyy:`req.session.xxxx = yyy`
7. 获取session上的xxx属性:`const {xxx} = req.session`
整个过程是:
1.客户端第一次发起请求,服务器开启一个session专门用于存储这次请求的一些信息。
2.根据配置对象的信息,服务器决定是否进行:session持久化等其他操作。
2.与此同时服务器创建了一个cookie,它的key我们可以自己指定,但是它的value一定是上一步session的唯一标识。
3.服务器将我们指定好的内容添加进session对象,例如:req.session.xxxx = yyy。
4.等请求再次过来时,客户端的请求中包含着之前“种”的cookie。
5.服务器检查携带过来的cookie是否有效,决定是否去读取对应session中的信息。

Ajax

AJAX 全称为Asynchronous Javascript And XML,就是异步的 JS 和 XML。

通过AJAX可以在浏览器中向服务器发送异步请求,最大的优势:无刷新获取数据。

AJAX 不是新的编程语言,不是新的一门独立的技术,而是一种使用现有标准的新方法。

Ajax的工作原理相当于在用户和服务器之间加了一个中间层(Ajax引擎),使用户操作与服务器响应异步化。

Ajax 优点

  1. 可以无需刷新页面而与服务器端进行通信。

  2. 允许你根据用户事件来更新部分页面内容。

Ajax 缺点

  1. 没有浏览历史,不能回退

  2. 存在跨域问题

  3. SEO不友好

原生Ajax的get 请求

let btn = document.getElementById('btn')
btn.onclick = function () {
//使用原生js发送ajax_get
/*
* 1.实例化一个XMLHttpRequest对象,名为:xhr---------找来一个帮你发请求的人。
* 2.绑定一个名为onreadystatechange事件监听------和发请求的人约定好--成功了做什么,失败了做什么。
* 3.调用open方法---------用什么方法发?给谁发?带着什么过去?
* 4.调用send方法---------发送请求
* */
//1.实例化一个XMLHttpRequest对象
let xhr = new XMLHttpRequest()
//2.绑定一个名为onreadystatechange事件监听
xhr.onreadystatechange = function () {
//xhr对象本身有5种状态:xhr“诞生”的那一刻就是0状态
/*
* 0:xhr对象在实例化出来的那一刻,就已经是0状态,代表着xhr是初始化状态。
* 1:send方法还没有被调用,即:请求没有发出去,此时依然可以修改请求头。
* 2:send方法被调用了,即:请求已经发出去了,此时已经不可以再修改请求头。
* 3:已经回来一部分数据了,如果是比较小的数据,会在此阶段一次性接收完毕,较大数据,有待于进一步接收。
* 4:数据完美的回来了。
* */
//我们几乎不会在0状态里做任何事。即:如下判断0状态,永远进不去。
if(xhr.readyState === 0){
console.log('我是一个刚出生的娃娃')
}
//1:send方法还没有被调用,即:请求没有发出去,此时依然可以修改请求头。
if(xhr.readyState === 1){
console.log('我是1状态')
xhr.setRequestHeader('demo','123')
}
//2:send方法被调用了,即:请求已经发出去了,此时已经不可以再修改请求头。
if(xhr.readyState === 2){
console.log('我是2状态')
xhr.setRequestHeader('demo','123')
}
//3.已经回来一部分数据了,如果是比较小的数据,会在此阶段一次性接收完毕,较大数据,有待于进一步接收。
if(xhr.readyState === 3){
console.log(xhr.response)
}*
//4:数据完美的回来了。
if(xhr.readyState === 4 && xhr.status === 200){
//如果进入此判断,意味着:请求成功了,且数据已经回来了
console.log(xhr.response)
let demo = document.getElementById('demo')
demo.innerHTML = xhr.response
}
}
//3.调用open方法---------用什么方法发?给谁发?带着什么过去?
xhr.open('get','http://localhost:3000/ajax_get?name=kobe&age=18&t='+Date.now())
//4.调用send方法---------发送请求
xhr.send()
}

POST 原生请求

open() 函数中应该是 psot 方法 || 请求的参数再请求体中 || 另外要设置 Content-Type 请求头

//3.调用open方法---------用什么方法发?给谁发?带着什么过去?
xhr.open('post','http://localhost:3000/ajax_post')
//特别注意:此处是设置post请求所特有的请求头,若不设置,服务器无法获取参数
xhr.setRequestHeader('Content-Type','application/x-www-form-urlencoded')
//4.调用send方法---------发送请求
xhr.send('name=kobe&age=18')

取消上一次请求

xhr.abort() //用于“取消”本次请求
/*
* 关于xhr.abort
* 1.如果来得及,半路取消,请求根本没有到达服务器。
* 2.如果来不及,拒之门外,请求已经到达了服务器,且服务器已经给出响应。
* 3.也存在根本不起作用的情况。
* */
return xhr
}

取消上一次请求

let lastXhr
btn.onclick = function () {
if(lastXhr){
lastXhr.abort()
}
lastXhr = getAuthCode()
}

jQuery 对于 Ajax 的封装

//使用jQuery发送ajax-get请求------完整版写法
$.ajax({
url:'http://localhost:3000/ajax_get',
method:'get', //发送请求的方式
data:{name:'kobe',age:41}, //发送请求携带的数据
//成功的回调
success:function (result) {
console.log(result)
},
//失败的回调
error:function (err) {
console.log(err)
}
})
//使用jQuery发送ajax-get请求------简写
$.get('http://localhost:3000/ajax_get',{name:'kobe',age:41},(data)=>{
console.log(data)
})
})

跨域

1.为什么会有跨域这个问题?

原因是浏览器为了安全,而采用的同源策略(Same origin policy)

2.什么是同源策略?

1. 同源策略是由Netscape提出的一个著名的安全策略,现在所有支持JavaScript 的浏览器都会使用这个策略。
2. Web是构建在同源策略基础之上的,浏览器只是针对同源策略的一种实现。
3. 所谓同源,也称之为同域,是指:协议,域名(IP),端口必须要完全相同
即:协议、域名(IP)、端口都相同,才能算是在同一个域里。

备注:规则举例如下(假设已有网站地址为:http://study.cn) Alt text

3.没有同源策略的危险场景:

危险场景:

有一天你刚睡醒,收到一封邮件,说是你的银行账号有风险,赶紧点进www.yinghang.com改密码。你着急的赶紧点进去,还是熟悉的银行登录界面,你果断输入你的账号密码,登录进去看看钱有没有少了,睡眼朦胧的你没看清楚,平时访问的银行网站是www.yinhang.com,而现在访问的是www.yinghang.com,随后你来了一条短信,钱没了,这个钓鱼网站做了什么呢?大概是如下思路:

<iframe id="baidu" src="https://www.baidu.com"></iframe>
<script type="text/javascript">
const iframe = window.frames['baidu']
const inputNode = iframe.document.getElementById('输入敏感信息的input的id')
console.log(inputNode.value)
</script>

3.非同源受到哪些限制?

即:跨域了你不能干那些事情

1. Cookie不能读取;
2. DOM无法获得;
3. Ajax请求不能获取数据

4.如何在开发中解决跨域问题:

1.JSONP解决发送请求跨域问题:

要明确的是:JSONP不是一种技术,而是程序员“智慧的结晶”(利用了标签请求资源不受同源策略限制的特点) JSONP需要前后端人员互相配合。

前端页面写法:

JSONP方式来解决跨域请求,事先定义一个回调函数,然后通过动态创建script标签的方式并添加src属性,属性值为非同源服务器端链接。

在服务器端接收到传递过来的函数名和参数信息,进行处理最终向浏览器端传递调用函数的js代码,该js代码是定义好的全局函数的调用因此会立即执行。

H <body>
<button id="btn">按钮</button>
<script type="text/javascript">
var btn = document.getElementById('btn');
btn.onclick = function () {
//1. 创建一个script标签
var script = document.createElement('script');
//2. 设置回调函数
window.getData = function (data) {
console.log(data);//拿到数据
}
//3. 设置script标签src属性,填写跨域请求的地址
script.src = 'http://localhost:3000/jsonp?callback=getData';
//4. 将script标签添加到body中生效
document.body.appendChild(script);
//5.不影响整体DOM结构,删除script标签
document.body.removeChild(script);
}
</script>
</body>

后端写法:

app.get('/jsonp', (req, res) => {
//解构赋值获取请求参数
const {callback} = req.query
//去数据库查找对应数据
const data = [{name: 'tom', age: 18}, {name: 'jerry', age: 20}];
res.send(callback + '(' + JSON.stringify(data) + ')');
})

JQuery

/*
* 1.提前定义好一个等待被调用的函数
2.创建一个script节点
3.为节点指定src地址,同时指定好回调函数的名字
4.将节点插入页面
备注:以上所有步骤,都由jquery底层全部完成
* */
$('#btn').click(function () {
//完整写法
$.ajax({
url:'http://localhost:3000/test',
method:'get',
dataType:'jsonp', //该属性,控制了上面的4步
data:{name:'zhangsan',age:18},
success:function (result) {
console.log(result)
},
error:function (err) {
console.log(err)
}
})
//精简写法
$.getJSON('http://localhost:3000/test?callback=?',{name:'zhangsan',age:18},function (data) {
console.log(data)
})
})

2.后台配置cors解决跨域

CORS Cross-Origin Resource Sharing

跨源资源共享 使用自定义的HTTP 头部

HTTP 头部中额外添加 Origin

以Node为例:
res.set('Access-Control-Allow-Origin', 'http://localhost:63342');

3.使用代理服务器

例如:nginx等