超文本传输协议HTTP

HTTP协议

在网络通信中，我们可以自己进行定制协议，但是也有许多已经十分成熟的应用层协议，比如我们下面说的HTTP协议。

HTTP协议简介

HTTP（Hyper Text Transfer Protocol）协议又叫做超文本传输协议，是一个简单的请求-响应协议，HTTP通常运行在TCP之上，它是一个应用层协议。

URL

URL（Uniform Resource Lacator）叫做统一资源定位符，也就是我们通常所说的网址，是因特网的万维网服务程序上用于指定信息位置的表示方法。

一个URL由一下几部分组成。

http://user:pass@www.example.jp:80/dir/index.htm?uid=1#ch1

• [http://]

一、协议方案名

http://代表的是协议方案名，表示请求时需要用到的协议，通常使用的是HTTP协议或者安全协议HTTPS。HTTPS协议是以安全为目标的HTTP协议，即在HTTP协议的基础上通过传输加密和身份认证保证了传输过程的安全性。

常见的应用层协议还有：DNS协议：域名系统、FTP协议：文件传输协议、TELNET协议：远程终端协议、HTTPS协议：安全数据传输协议、SMTP协议：电子邮件传输协议、POP3协议：邮件读取协议、SNMP协议：简单网络管理协议、TFTP协议：简单文件传输协议。

• [user:pass]

二、登录信息(认证)

user:pass代表的是登录认证信息，包括用户的用户名和密码，虽然登录信息可以在URL中体现出来，但是绝大多数URL这个字段都是被省略的，因为登录信息可以通过其他方案交付给服务器。

• [www.example.jp]

三、服务器地址

www.example.jp表示的是服务器地址，也叫做域名，比如www.baidu.com、www.qq.com、www.taobao.com等。

要注意的是，我们使用IP地址标识公网内的一台主机，但是IP地址本身不适合给用户看。我们可以通过ping命令，获得www.baidu.com域名解析后的IP地址。

如果用户看到的是IP地址，用户在访问网站前就不知道这个网站到底是干什么的，但是如果用户看到的是www.baidu.com这个域名，那么用户就至少知道这个网站是哪个公司的，因此域名有更好的自描述性。

实际上，我们可以认为域名和IP地址是等价的，因为在计算机中既可以使用域名，也可以使用IP地址。但是URL呈现出来的是可以让用户看到的，因此URL是以域名形式代表服务器地址的。

• [80]

四、服务器端口号

80代表的是服务端口号，HTTP协议和套接字编程是一样位于应用层的，在进行套接字编程时，我们给服务器绑定对应的IP和端口号，而应用层协议同样需要明确的端口号。

常见协议对应的端口号：

HTTP-80、HTTPS-443、SSH-22

我们在使用某个协议时，该协议就是在给我们提供服务。现在大部分的服务与端口号是对应的，所以我们在使用时不用指明某个协议对应的端口号，因此在URL中服务器的端口号也是被省略的。

• [/dir/index.htm]

五、带层次的文件路径

/dir/index.htm代表的是要访问的资源所在的路径，访问服务器是为了获取服务器上的某个资源，通过前面的域名和端口号已经可以找到对应的进程了，此时要做的就是指明该资源所在的路径。

比如我们输入百度的域名，浏览器就帮我们获取了百度的首页。

当我们发起网页请求时，本质是获得了一张网页信息，然后浏览器对这张网页信息进行解释，最后就呈现出了对应的网页。

我们把这种资源称为网页资源，此外我们还可以向服务器请求视频、音频、图片等资源。HTTP之所以叫超文本传输协议，是因为很多资源并不是普通的文本资源。

因此在URL当中就有这样一个字段，用于表示要访问的资源所在的路径。此外我们可以看到，这里的路径分隔符是/，而不是\，这也就证明了实际很多服务都是部署在Linux上的。

• [uid=1]

六、查询字符串

uid=1代表的是请求时提供的额外参数、这些参数是以键值对的形式存在的，通过&分隔。

我们在百度中搜索腾讯，URL中的参数其中一个是wd=腾讯，这个参数wd就是word，表示我们搜索的关键字。

因此双方在网络通信时，是可以通过URL传输数据给用户的。

• [ch1]

七、片段标识符

chi1代表的是片段标识符，是对资源的部分补充。

我们在看一组图片时，URL中就会出现片段标识符。

urlencode和urldecode

如果在搜索关键字当中出现了像/?:这样的字符，由于这些字符已经被URL当作特殊意义理解了，因此URL在呈现时会对这些特殊字符进行转义。

转义规则：

将需要转码的字符转换为16进制，从右到左，取4位(不足4位直接处理)，每两位做一位，前面加上%，编码成%XY格式。

比如我们搜索C//时，由于/是一个特殊符号，就会被转义成对应的16进制的值0x2F，一个/就是%2F。

注意：URL不仅会对这些特殊符号做编码，也会对中文进行编码。

我们通过在线编码解码工具，看看我们上面说的对不对。

输入C%2F%2F

点击解码

和我们在刚刚百度输入的一样

实际上在服务器拿到对应的URL后，也需要对编码后的参数进行解码。

解码其实就是编码的逆过程。

HTTP协议格式

HTTP协议请求格式

HTTP请求由以下四部分组成

• 请求行

[请求方法]+[URL]+[http版本]

• 请求报头

请求的属性，一般以[key：value]的形式，以行为单位陈列。

• 空行

遇到空行代表请求报头结束。

• 请求正文

允许为空，如果不为空，在请求报头中会有一个Content-Length属性来标识请求正文长度。

前三部分是HTTP协议自带的，请求正文一般是用户的信息或数据，如果没有信息上传就为空。

分离HTTP请求的报头和有效载荷

当应用层收到一个HTTP请求时，它必须将HTTP的报头和有效载荷进行分离。

请求行和请求报头就是HTTP报头，请求正文就是HTTP的有效载荷。

我们可以通过HTTP请求中的空行来进行分离报头和有效载荷。当服务器收到一个HTTP请求，就可以进行按行读取，如果读取到空行，就说明已经把报头读取完了。

实际上，HTTP请求中的空行就是为了方便分离报头和有效载荷的。

如果我们把HTTP请求想象成一个大的线性结构，每行都是用\n隔开的，如果连续读到两个\n就说明已经把报头读取完毕了，剩下的就是有效载荷了。

尝试获取浏览器的HTTP请求

在网络协议栈中，应用层的下一层叫做传输层，而HTTP协议底层通常使用的传输层协议是TCP协议，因此我们可以用套接字编写一个TCP服务器，然后启动浏览器访问我们的这个服务器。

由于我们的服务器是直接用TCP套接字读取浏览器发来的HTTP请求，此时在服务端没有应用层对这个HTTP请求进行过任何解析，因此我们可以直接将浏览器发来的HTTP请求进行打印输出，此时就能看到HTTP请求的基本构成。

我们编写一个简单的TCP服务器，这个服务器要做的就是把浏览器发来的HTTP请求进行打印即可。

#include <iostream>
#include <cassert>
#include <fstream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
using namespace std;

class Socket {
private:
    int Create() {
        _listen_sock = socket(AF_INET, SOCK_STREAM, 0);
        if (_listen_sock < 0){
            cerr << "socket error!" << endl;
            return 1;
	    }
        return 0;
    }
    int Bind() {
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(8081);
        local.sin_addr.s_addr = htonl(INADDR_ANY);
        if (bind(_listen_sock, (struct sockaddr*)&local, sizeof(local)) < 0){
            cerr << "bind error!" << endl;
            return 2;
        }
        return 0;
    }
    int Listen() {
        if (listen(_listen_sock, 5) < 0){
            cerr << "listen error!" << endl;
            return 3;
	    }
        return 0;
    }
public:
    Socket():_listen_sock(-1){}
    void initServer() {
        //1.创建TCP套接字
        assert(Create() == 0);
        //2.bind绑定自己的网络信息
        assert(Bind() == 0);
        //3.设置服务器的socket为监听状态，监听客户端什么时候发来连接请求
        assert(Listen() == 0);
    }
    void start() {
        struct sockaddr peer;
        memset(&peer, 0, sizeof(peer));
        socklen_t len = sizeof(peer);
        for(;;) {
            int sock = accept(_listen_sock, (struct sockaddr*)&peer, &len);
            if(sock < 0) {
                cerr << "accept err" << endl;
                continue;
            }
            if(fork() == 0) {
                //爸爸进程
                close(_listen_sock);
                if(fork() > 0) {
                    exit(0);
                }
                //孙子进程
                char buffer[1024];
                recv(sock, buffer, sizeof(buffer), 0);//读取HTTP请求
                cout << "--------------------------http request begin--------------------------" << endl;
                cout << buffer << endl;
                cout << "---------------------------http request end---------------------------" << endl;
                close(sock);
                exit(0);
            }
            //爷爷进程
            close(sock);
            waitpid(-1, nullptr, 0);//等待爸爸进程
        }
    }
    
private:
    int _listen_sock;
};

int main() {
    Socket sock;
    sock.initServer();
    sock.start();
    return 0;
}

运行服务器程序后，然后用浏览器进行访问，此时我们的服务器就会收到浏览器发来的HTTP请求，并将收到的HTTP请求进行打印输出。

注意：

• 浏览器向我们的服务器发起HTTP请求后，因为我们的服务器没有对进行响应，此时浏览器就会认为服务器没有收到，然后再不断发起新的HTTP请求，因此虽然我们只用浏览器访问了一次，但会受到多次HTTP请求。

• 浏览器发起请求时默认用的就是HTTP协议，因此我们在浏览器的url框当中输入网址时可以不用指明HTTP协议。

• url当中的/不能称之为我们云服务器上根目录，这个/表示的是web根目录，这个web根目录可以是你的机器上的任何一个目录，这个是可以自己指定的，不一定就是Linux的根目录。

其中请求行一般是不携带域名以及端口号的，因为在请求报头中的Host字段会进行指明，请求行当中的url表示你要访问这个服务器上的哪一路径下的资源。

如果浏览器在访问我们的服务器时指明要访问的资源路径，那么此时浏览器发起的HTTP请求当中的url也会跟着变成该路径。

请求报头当中全部都是以key: value形式按行陈列的各种请求属性，请求属性陈列完后紧接着的就是一个空行，空行后的就是本次HTTP请求的请求正文，此时请求正文为空字符串，因此这里有两个空行。

HTTP的响应格式

HTTP响应由以下四部分组成：

• 状态行：

[http版本]+[状态码]+[状态码描述]

• 响应报头

响应的属性，这些属性都是以key: value的形式按行陈列的。

• 空行

遇到空行表示响应报头结束。

• 响应正文

响应正文允许为空字符串，如果响应正文存在，则响应报头中会有一个Content-Length属性来标识响应正文的长度。比如服务器返回了一个html页面，那么这个html页面的内容就是在响应正文当中的。

分离HTTP响应的报头和有效载荷

状态行和响应报头就是HTTP的报头信息，响应正文实际就是HTTP的有效载荷。

与HTTP请求相同，当应用层收到一个HTTP响应时，也是根据HTTP响应当中的空行来分离报头和有效载荷的

当客户端收到一个HTTP响应后，就可以按行进行读取，如果读取到空行则说明报头已经读取完毕。

构建一个HTTP响应

我们就将当前服务程序所在的路径作为我们的web根目录，我们可以在该目录下创建一个html文件，然后编写一个简单的html作为当前服务器的首页。

<html>
    <head></head>
    <body>
        <h1>hello http</h1>
    </body>
</html>

#include <iostream>
#include <cassert>
#include <fstream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
using namespace std;

class Socket {
private:
    int Create() {
        _listen_sock = socket(AF_INET, SOCK_STREAM, 0);
        if (_listen_sock < 0){
            cerr << "socket error!" << endl;
            return 1;
	    }
        return 0;
    }
    int Bind() {
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(8081);
        local.sin_addr.s_addr = htonl(INADDR_ANY);
        if (bind(_listen_sock, (struct sockaddr*)&local, sizeof(local)) < 0){
            cerr << "bind error!" << endl;
            return 2;
        }
        return 0;
    }
    int Listen() {
        if (listen(_listen_sock, 5) < 0){
            cerr << "listen error!" << endl;
            return 3;
	    }
        return 0;
    }
public:
    Socket():_listen_sock(-1){}
    void initServer() {
        //1.创建TCP套接字
        assert(Create() == 0);
        //2.bind绑定自己的网络信息
        assert(Bind() == 0);
        //3.设置服务器的socket为监听状态，监听客户端什么时候发来连接请求
        assert(Listen() == 0);
    }
    void start() {
        struct sockaddr peer;
        memset(&peer, 0, sizeof(peer));
        socklen_t len = sizeof(peer);
        for(;;) {
            int sock = accept(_listen_sock, (struct sockaddr*)&peer, &len);
            if(sock < 0) {
                cerr << "accept err" << endl;
                continue;
            }
            if(fork() == 0) {
                //爸爸进程
                close(_listen_sock);
                if(fork() > 0) {
                    exit(0);
                }
                //孙子进程
                char buffer[1024];
                recv(sock, buffer, sizeof(buffer), 0);//读取HTTP请求
                cout << "--------------------------http request begin--------------------------" << endl;
                cout << buffer << endl;
                cout << "---------------------------http request end---------------------------" << endl;
                close(sock);
                exit(0);
            }
            //读取default.html文件
			ifstream in("default.html");
			if (in.is_open()){
				in.seekg(0, in.end);
				int len = in.tellg();
				in.seekg(0, in.beg);
				char* file = new char[len];
				in.read(file, len);
				in.close();
				
				//构建HTTP响应
				string status_line = "http/1.1 200 OK\n"; //状态行
				string response_header = "Content-Length: " + to_string(len) + "\n"; //响应报头
				string blank = "\n"; //空行
				string response_text = file; //响应正文
				string response = status_line + response_header + blank + response_text; //响应报文
				
				//响应HTTP请求
				send(sock, response.c_str(), response.size(), 0);

				delete[] file;
            }
            //爷爷进程
            close(sock);
            waitpid(-1, nullptr, 0);//等待爸爸进程
        }
    }
private:
    int _listen_sock;
};

int main() {
    Socket sock;
    sock.initServer();
    sock.start();
    return 0;
}

当浏览器向服务器发起HTTP请求时，不管浏览器发来的是什么请求，我们都将这个网页响应给浏览器，此时这个html文件的内容就应该放在响应正文当中，我们只需读取该文件当中的内容，然后将其作为响应正文即可。

我们也可以通过telnet命令来访问我们的服务器，也是能够得到这个HTTP响应的。

注意：

• 实际我们在进行网络请求的时候，如果不指明请求资源的路径，此时默认你想访问的就是目标网站的首页，也就是web根目录下的index.html文件。
• 我们在构建HTTP响应时，在响应报头当中只添加了一个属性信息Content-Length，表示响应正文的长度，实际HTTP响应报头当中的属性信息还有很多。

为什么在进行通信时，要交互双方的版本

HTTP请求当中的请求行和HTTP响应当中的状态行，当中都包含了http的版本信息。

HTTP请求是由客户端发的，因此HTTP请求当中表明的是客户端的http版本，而HTTP响应是由服务器发的，因此HTTP响应当中表明的是服务器的http版本。

在通信时交互版本，目的是为了兼容性。因为客户端和服务端使用的http版本可能是不同的，为了让不同版本的客户端都能享受到服务端的服务，所以需要双方交互版本

HTTP的方法

常见方法

GET：

• 作用：获取资源
• 对应版本：1.0、1.1

POST：

• 作用：传输实体主体
• 对应版本：1.0、1.1

PUT：

• 作用：传输文件
• 对应版本：1.0、1.1

HEAD：

• 作用：获得报文首部
• 对应版本：1.0、1.1

DELETE：

• 作用：删除文件
• 对应版本：1.0、1.1

OPTIONS：

• 作用：询问支持的方法
• 对应版本：1.1

TRACE：

• 作用：追踪路径
• 对应版本：1.1

CONNECT：

• 作用：要求用隧道协议连接代理
• 对应版本：1.1

LINK：

• 作用：建立和资源之间的关系
• 对应版本：1.0

UNLINK：

• 作用：断开连接关系
• 对应版本：1.0

这些方法中，最常用的就是GET和POST方法。

GET方法一般用于获取某种资源信息，POST方法一般用于将数据上传给服务器。

实际上传数据时，也有可能使用GET方法。

GET和POST方法都是可以传参的：

• GET通过URL传参
• POST通过正文传参

由于URL的长度是有限的，所以POST方法通过正文传参能传递更多的参数。

而且理论上使用POST方法更加安全，因为POST方法不会把你的参数回显到URL中，也就不会被人轻易看到。

实际上，POST和GET方法都是不安全的，要做到安全智能通过加密来实现。

演示GET和POST的不同

我们html中再添加两个表单，作为用户名和密码的输入。

效果：

我们使用GET方法，当我们提交完用户名和密码时，我们的用户名和密码就会自动被同步到URL当中。

服务器也能收到提交的请求。

如果我们改为POST方法，我们提交的参数就不会在URL中显示。

服务器会通过正文来接收到用户名和密码

注意：

• 我们使用GET方法时，会将提交的参数提交到URL中，所以GET方法一般是处理数据不敏感的
• 如果你传递的一些数据比较私密，那就可以使用POST方法，不是因为POST安全，而是因为它通过正文传输数据，不会把数据回显到URL中，相对来说比较私密。

HTTP的状态码

1XX：信息性状态码，指接收的请求正在处理

2XX：成功状态码，请求正常处理完毕

3XX：重定向状态码，需要进行附件操作以完成请求

4XX：客户端错误状态码，服务器无法处理请求

5XX：服务器错误状态码，服务器处理请求出错

常见的状态码：200(OK)、302(Redirect)、404(Not Found)、403(Forbidden请求权限不够)、504(Bad Gateway)

重定向

重定向，也称为 URL 转发，通过各种方法将各种网络请求重新定个方向转到其它位置，这个服务器相当于提供了一个引路的服务。

重定向又可分为临时重定向和永久重定向，其中状态码301表示的就是永久重定向，而状态码302和307表示的是临时重定向。

临时重定向和永久重定向本质是影响客户端的标签，决定客户端是否需要更新目标地址。

如果某个网站是永久重定向，那么第一次访问该网站时由浏览器帮你进行重定向，但后续再访问该网站时就不需要浏览器再进行重定向了，此时你访问的直接就是重定向后的网站。

而如果某个网站是临时重定向，那么每次访问该网站时如果需要进行重定向，都需要浏览器来帮我们完成重定向跳转到目标网站。
演示重定向

#include <iostream>
#include <cassert>
#include <fstream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
using namespace std;

class Socket {
private:
    int Create() {
        _listen_sock = socket(AF_INET, SOCK_STREAM, 0);
        if (_listen_sock < 0){
            cerr << "socket error!" << endl;
            return 1;
	    }
        return 0;
    }
    int Bind() {
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(8080);
        local.sin_addr.s_addr = htonl(INADDR_ANY);
        if (bind(_listen_sock, (struct sockaddr*)&local, sizeof(local)) < 0){
            cerr << "bind error!" << endl;
            return 2;
        }
        return 0;
    }
    int Listen() {
        if (listen(_listen_sock, 5) < 0){
            cerr << "listen error!" << endl;
            return 3;
	    }
        return 0;
    }
public:
    Socket():_listen_sock(-1){}
    void initServer() {
        //1.创建TCP套接字
        assert(Create() == 0);
        //2.bind绑定自己的网络信息
        assert(Bind() == 0);
        //3.设置服务器的socket为监听状态，监听客户端什么时候发来连接请求
        assert(Listen() == 0);
    }
    void start() {
        struct sockaddr peer;
        memset(&peer, 0, sizeof(peer));
        socklen_t len = sizeof(peer);
        for(;;) {
            int sock = accept(_listen_sock, (struct sockaddr*)&peer, &len);
            if(sock < 0) {
                cerr << "accept err" << endl;
                continue;
            }
            if(fork() == 0) {
                //爸爸进程
                close(_listen_sock);
                if(fork() > 0) {
                    exit(0);
                }
                //孙子进程
                char buffer[1024];
                recv(sock, buffer, sizeof(buffer), 0);//读取HTTP请求
                cout << "--------------------------http request begin--------------------------" << endl;
                cout << buffer << endl;
                cout << "---------------------------http request end---------------------------" << endl;
                close(sock);
                exit(0);
            }
            //构建HTTP响应
			string status_line = "http/1.1 307 Temporary Redirect\n"; //状态行
			string response_header = "Location: https://www.qq.com/\n"; //响应报头
			string blank = "\n"; //空行
			string response = status_line + response_header + blank; //响应报文
			
			//响应HTTP请求
			send(sock, response.c_str(), response.size(), 0);
            //爷爷进程
            close(sock);
            waitpid(-1, nullptr, 0);//等待爸爸进程
        }
    }
private:
    int _listen_sock;
};

int main() {
    Socket sock;
    sock.initServer();
    sock.start();
    return 0;
}

我们运行程序后，在浏览器上进行访问，我们会发现他自己跳转到了ww.qq.com。

我们再用telnet演示：

HTTP常见的Header

常见的Header：

• Content-Type：数据类型（text/html等）。
• Content-Length：正文的长度。
• Host：客户端告知服务器，所请求的资源是在哪个主机的哪个端口上。

Host字段代表了客户端要访问的服务的IP和端口。我们在通过浏览器访问我们的服务器时，HTTP请求中的Host字段填的就是服务器的IP和端口。

为什么客户端还要告诉服务器它要访问的服务的对应的IP和端口？

因为有的服务器是一个代理服务器，它是替代客户端向其他服务器发起请求，然后把请求的结果返回给客户端。这种情况下，就需要告诉代理服务器，它需要访问的IP和端口。

• User-Agent：声明用户的操作系统和浏览器的版本信息。

User-Agent代表的是客户端对应的操作系统和浏览器的版本信息。

• Referer：当前页面是哪个页面跳转过来的。

代表从哪个页面跳转过来的，方便回退到上一个网页。

• Location：搭配3XX状态码使用，告诉客户端接下来要去哪里访问。

• Cookie：用于在客户端存储少量信息，通常用于实现会话（session）的功能。

• Connect：Keep-Alive长连接

HTTP1.0的常见工作方式是客户端和服务端先建立连接，然后客户端再给服务端发起请求，服务器再进行响应。

如果一个连接建立以后客户端和服务端只进行一次交互，就将连接关闭，那就太浪费资源了，所以主流的HTTP1.1是支持长连接的。

长连接就是，建立连接后，客户端可以向服务端不断的写入多个HTTP请求，而服务器在上层一个个读取这些请求就行了，此时一条连接就可以传送大量的请求和响应。

如果HTTP请求或者响应报头中Connect字段对应的值是Keep-Alive，就代表是支持长连接的。

Cookie和Session

Cookie

HTTP实际上是一种无状态协议，HTTP的每次请求和响应之间是没有任何关系的，但是你在使用浏览器时发现并不是这样的。

比如，你登录了一次csdn后，就算你把浏览器关闭或者重启了电脑，当再一次打开csdn时，csdn并没有要求你重新登录，这实际就是通过Cookie实现的。

点击edge浏览器的锁标志就可以查看网站对应的Cookie数据。

这些cookie数据都是服务器方写的，如果你将某些cookie删除，那么此时可能就需要你重新进行登录认证了，因为你删除的可能正好就是你登录时所设置的cookie信息。

那么什么是Cookie？

HTTP是一种无状态协议，如果没有Cookie，那么我们每次在访问页面时都需要进行身份认证也就是登录账号。

比如，你是某视频网的会员，当你访问各种VIP视频时，都要麻烦你登录一次，这样就是让人感觉体验极差。

而Cookie就是为了解决这个问题的：

我们在第一次登录这个网站时，进行了身份认证，服务器确认你是一个合法的用户，就会进行Set-Cookie操作。

注意：Set-Cookie是HTTP报头中的一种属性信息

在服务器Set-Cookie后，服务器进行HTTP响应时就会把这个Set-Cookie响应给浏览器，浏览器在收到响应后，会将Set-Cookie中的值提取出来放到本地的Cookie文件中，此时就相等于把用户名和密码保存在了本地。

往后只要再次访问这个网站，浏览器会再次发起http请求，同时将保存的cookie信息推送至服务器，无须用户再次输入账号密码重新登录。

cookie信息可分为文件级cookie和内存级cookie两种，在本地，Cookie是可以手动配置文件级或者内存级。

如果是内存级cookie，则cookie的生命周期随浏览器进程，当我们把浏览器关闭之后，cookie信息会自动销毁，重新打开浏览器登录网站时，则需要再次输入账号和密码。

如果是文件级cookie，则cookie不受浏览器关闭的影响，或电脑开关机重启的影响，因为他存在于磁盘外设上。

但是Cookie还存在一个被盗用的问题。

Cookie中存储的是我们的私密信息，一旦Cookie被盗，我们的信息也就泄露了。因此主流的服务器还引入了一个SessionID。

Session

当我们第一次登录一个网站时，服务器认证成功后还会生成一个对应SessionID，这个SessionID和用户的信息是不相关的。系统会把所有登录用户的SessionID维护起来。

此时当认证通过后服务端在对浏览器进行HTTP响应时，就会将这个生成的SessionID值响应给浏览器。

浏览器收到响应后会自动提取出SessionID的值，将其保存在浏览器的cookie文件当中。后续访问该服务器时，对应的HTTP请求当中就会自动携带上这个SessionID。

服务器识别到HTTP请求当中包含了SessionID，就会提取出这个SessionID，然后再到对应的集合当中进行对比，对比成功就说明这个用户是曾经登录过的，此时也就自动就认证成功了，然后就会正常处理你发来的请求，这就是我们当前主流的工作方式。

• 安全是相对的

引入SessionID后，浏览器中的Cookie文件中存的是SessionID，但是这个SessionId同样可以被盗取。

但是此时用户的用户名和密码就不会泄露了，由于SessionID已经泄露，非法用户仍然可以通过SessionID区访问我们曾经登录过的服务器，还是存在刚才的问题。

虽然引入SessionID并没有彻底解决安全问题，但是这个方法是相对安全的。因为互联网上是不存在绝对的安全的，网络中的信息随时是可能被别人破解的。

但是如果破解成本远大于破解带来的收益，那么就不会有人去破解这个信息了，这个信息就可以说是安全的。

引入SessionID的好处

引入SessionID后，用户的用户名和密码都是由服务器来维护的，本地Cookie文件中存的只是SessionID。

虽然SessionID有可能被盗取，但是服务器也有一些策略来保证用户信息的安全性。

1. 服务器可以通过IP地址来判断用户登录的地址范围，如果用户在短时间内登录地址发生了巨大变化，此时服务器就会知道这个用户出异常了，就会清楚服务器中对应的SessionID。

这会要求用户在登录时重新输入用户名和密码，因为用户名和密码只有本人和服务器知道。重新验证后，就会将另一个IP识别为非法用户，加入黑名单中。将合法用户和非法用户分为白名单和黑名单。

2. 当用户进行一些高权限的操作时，会让用户再次输入密码，再次确认信息。

非法用户是不知道正确的密码的，就会让非法用户不能进行高权限的操作。比如修改密码时，需要输入旧密码。

3. SessionID也是会过期的，假如某一个SessionID只有1小时的有效期。

即使你的SessionID被盗用了，也仅仅是在1小时内被盗用，而且和权限也有限，因此影响不会太大。

理你发来的请求，这就是我们当前主流的工作方式。

• 安全是相对的

引入SessionID后，浏览器中的Cookie文件中存的是SessionID，但是这个SessionId同样可以被盗取。

但是此时用户的用户名和密码就不会泄露了，由于SessionID已经泄露，非法用户仍然可以通过SessionID区访问我们曾经登录过的服务器，还是存在刚才的问题。

虽然引入SessionID并没有彻底解决安全问题，但是这个方法是相对安全的。因为互联网上是不存在绝对的安全的，网络中的信息随时是可能被别人破解的。

但是如果破解成本远大于破解带来的收益，那么就不会有人去破解这个信息了，这个信息就可以说是安全的。

引入SessionID的好处

引入SessionID后，用户的用户名和密码都是由服务器来维护的，本地Cookie文件中存的只是SessionID。

虽然SessionID有可能被盗取，但是服务器也有一些策略来保证用户信息的安全性。

1. 服务器可以通过IP地址来判断用户登录的地址范围，如果用户在短时间内登录地址发生了巨大变化，此时服务器就会知道这个用户出异常了，就会清楚服务器中对应的SessionID。

这会要求用户在登录时重新输入用户名和密码，因为用户名和密码只有本人和服务器知道。重新验证后，就会将另一个IP识别为非法用户，加入黑名单中。将合法用户和非法用户分为白名单和黑名单。

2. 当用户进行一些高权限的操作时，会让用户再次输入密码，再次确认信息。

非法用户是不知道正确的密码的，就会让非法用户不能进行高权限的操作。比如修改密码时，需要输入旧密码。

3. SessionID也是会过期的，假如某一个SessionID只有1小时的有效期。

即使你的SessionID被盗用了，也仅仅是在1小时内被盗用，而且和权限也有限，因此影响不会太大。