Linux网络：应用层之HTTP协议

news2025/1/17 2:57:59

文章目录

  • 一、应用层
    • 1.协议
    • 2.网络版计算器
  • 二、HTTP 协议
    • 1. URL
    • 2. HTTP 协议格式
    • 3.查看 HTTP 请求
    • 4.发送 HTTP 响应
    • 5. HTTP 的方法
    • 6. HTTP 的状态码
    • 7. HTTP 的版本
    • 8. HTTP 常见 Header
    • 9. Cookie 与 session
  • 三、HTTP 与 HTTPS

一、应用层

我们程序员写的一个个解决实际问题，满足日常需求的网络程序，都是在应用层。

1.协议

协议是一种约定。网络协议是计算机网络中通信双方都必须遵守的一组约定。

在网络通信中，都是以 “字符串” 的方式来发送和接收数据的。
如果要发送和接收一些结构化的数据，就需要序列化和反序列化。

  • 什么是序列化和反序列化？
    ① 序列化：将结构化的数据按照一个规则转化成字符串。
    ② 反序列化：将字符串按照相同的规则转化回结构化的数据。

  • 为什么要进行序列化和反序列化？
    ① 为了方便应用层的网络通信。
    ② 为了方便上层使用内部成员，将应用和网络进行解耦。

结构化的数据，是不便于网络传输的，而字符串便于网络传输。
结构化的数据，以二进制的方式进行收发会有问题，因为客户端和服务器对结构体大小的认识可能不一样，比如每个字段的大小，内存对齐的方式。

结构化的数据，本质就是协议的表现。

2.网络版计算器

程序说明：client 发送一个计算请求给 server ，server 接收到后进行计算，再将响应结果返回给 client 。

我们约定：
 ① 定义结构体来表示我们需要交互的信息，在这里就是请求和响应。
 ② 对收发的数据进行序列化和反序列化。

我们会用到 json 组件对结构化的数据进行序列化和反序列化。

Linux 平台下，下载 json 组件的命令：sudo yum install -y jsoncpp-devel。

下面的程序包含四个文件：
 ① Sock.hpp：基本通信函数的实现。
 ② Protocol.hpp：协议的定制、序列化和反序列化的实现。
 ③ CalServer.cc：服务端。
 ④ CalClient.cc：客户端。

  • Sock.hpp：
#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

using namespace std;

class Sock
{
public:
    static int Socket()
    {
        int sock = socket(AF_INET, SOCK_STREAM, 0);
        if(sock < 0){
            cerr << "socket error!" << endl;
            exit(2);
        }

        return sock;
    }

    static void Bind(int sock, uint16_t port)
    {
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        local.sin_addr.s_addr = INADDR_ANY;
        
        if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0){
            cerr << "bind error!" << endl;
            exit(3);
        }
    }

    static void Listen(int sock)
    {
        if(listen(sock, 5) < 0)
        {
            cerr << "listen error!" << endl;
            exit(4);
        }
    }

    static int Accept(int sock)
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int fd = accept(sock, (struct sockaddr*)&peer, &len);
        if(fd >= 0){
            return fd;
        }
        return -1;
    }

    static void Connect(int sock, std::string ip, uint16_t port)
    {
        struct sockaddr_in server;
        memset(&server, 0, sizeof(server));

        server.sin_family = AF_INET;
        server.sin_port = htons(port);
        server.sin_addr.s_addr = inet_addr(ip.c_str());

        if(connect(sock, (struct sockaddr*)&server, sizeof(server)) == 0)
        {
            cout << "Connect Success!" << endl;
        }
        else
        {
            cout << "Connect Failed!" << endl;
            exit(5);
        }
    }
};
  • Protocol.hpp：
#pragma once

#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>

using namespace std;

// 定制协议的过程，目前就是定制结构化数据的过程
// 我们自己定义的协议，client && server 都必须遵守！这就叫做自定义协议
// 请求格式
typedef struct request
{
    int x;
    int y;
    char op;  // "+-*/%"
} request_t;

// 响应格式
typedef struct response
{
    int code;
    // 只有计算结果，
    // 不能区分是正常的计算结果，还是异常的退出结果
    // server运算完毕的计算状态: 
    // code(0:success), code(-1: div 0) ...
    
    int result;  
} response_t;

// request_t -> string
std::string SerializeRequest(const request_t &req)
{
    // 序列化
    Json::Value root;  // 可以盛装任何对象，json是一种kv式的序列化方案
    root["datax"] = req.x;
    root["datay"] = req.y;
    root["operator"] = req.op;

    // FastWriter, StyledWriter
    // Json::StyledWriter writer;
    Json::FastWriter writer;
    std::string json_string = writer.write(root);
    return json_string;
}

// string -> request_t
void DeserializeRequest(const std::string &json_string, request_t &out)
{
    // 反序列化
    Json::Reader reader;
    Json::Value root;

    reader.parse(json_string, root);

    out.x = root["datax"].asInt();
    out.y = root["datay"].asInt();
    out.op = (char)root["operator"].asInt();
}

std::string SerializeResponse(const response_t &resp)
{
    Json::Value root;
    root["code"] = resp.code;
    root["result"] = resp.result;

    Json::FastWriter writer;
    std::string res = writer.write(root);
    
    return res;
}

void DeserializeResponse(const std::string &json_string, response_t &out)
{
    Json::Reader reader;
    Json::Value root;

    reader.parse(json_string, root);
    out.code = root["code"].asInt();
    out.result = root["result"].asInt();
}
  • CalServer.cc：
#include <pthread.h>
#include "Protocol.hpp"
#include "Sock.hpp"

static void Usage(string proc)
{
    cout << "Usage: " << proc << " port" << endl;
}

void *HandlerRequest(void *args)
{
    int sock = *(int *)args;
    delete (int *)args;

    pthread_detach(pthread_self());

    // 业务逻辑，做一个短服务
    // request -> 分析处理 -> 构建response -> send(response) -> close(sock)
    // 1. 读取请求
    char buffer[1024];
    request_t req;
    ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
    if (s > 0)
    {
        buffer[s] = 0;
        cout << "get a new request: " << buffer << endl;
        std::string str = buffer;
        DeserializeRequest(str, req);  // 反序列化请求

        // 2. 分析请求 && 3. 计算结果
        response_t resp = {0, 0};
        switch (req.op)
        {
        case '+':
            resp.result = req.x + req.y;
            break;
        case '-':
            resp.result = req.x - req.y;
            break;
        case '*':
            resp.result = req.x * req.y;
            break;
        case '/':
            if (req.y == 0)
                resp.code = -1; // 代表除0
            else
                resp.result = req.x / req.y;
            break;
        case '%':
            if (req.y == 0)
                resp.code = -2; // 代表模0
            else
                resp.result = req.x % req.y;
            break;
        default:
            resp.code = -3; // 代表请求方法异常
            break;
        }
        cout << "request: " << req.x << req.op << req.y << endl;

        // 4. 构建响应，并进行返回
        std::string send_string = SerializeResponse(resp);  // 序列化之后的字符串
        write(sock, send_string.c_str(), send_string.size());

        cout << "服务结束: " << send_string << endl;
    }

    // 5. 关闭连接
    close(sock);
}

// ./CalServer port
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(1);
    }    

    uint16_t port = atoi(argv[1]);

    int listen_sock = Sock::Socket();
    Sock::Bind(listen_sock, port);
    Sock::Listen(listen_sock);

    for (;;)
    {
        int sock = Sock::Accept(listen_sock);
        if (sock >= 0)
        {
            cout << "get a new client..." << endl;
            int *pram = new int(sock);
            pthread_t tid;
            pthread_create(&tid, nullptr, HandlerRequest, pram);
        }
    }

    return 0;
}
  • CalClient.cc：
#include "Protocol.hpp"
#include "Sock.hpp"

void Usage(string proc)
{
    cout << "Usage: " << proc << " server_ip server_port" << endl;
}

// ./CalClient server_ip server_port
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }

    int sock = Sock::Socket();
    Sock::Connect(sock, argv[1], atoi(argv[2]));

    // 业务逻辑
    request_t req;
    memset(&req, 0, sizeof(req));
    cout << "Please Enter Data One# ";
    cin >> req.x;
    cout << "Please Enter Data Two# ";
    cin >> req.y;
    cout << "Please Enter Operator# ";
    cin >> req.op;

    std::string json_string = SerializeRequest(req);  // 序列化请求

    ssize_t s = write(sock, json_string.c_str(), json_string.size());

    char buffer[1024];
    s = read(sock, buffer, sizeof(buffer)-1);
    if(s > 0)
    {
        response_t resp;
        buffer[s] = 0;
        std::string str = buffer;
        DeserializeResponse(str, resp);  // 反序列化

        cout << "code[0:success]: " << resp.code << endl;
        cout << "result: " << resp.result << endl;
    }

    return 0;
}

运行测试：
在这里插入图片描述

我们上面写的 C/S 模式的在线版本计算器，本质就是一个应用层网络服务：基本通信代码、结构化数据等约定、业务逻辑、序列化和反序列化，这些都是由我们自己实现的。

二、HTTP 协议

虽然说应用层协议是由我们程序员自己定的，但实际上已经有大佬们定义了一些现成的又非常好用的应用层协议，供我们直接参考使用，HTTP 协议（Hyper Text Transfer Protocol，超文本传输协议）就是其中之一。

网络通信、序列化和反序列化、协议细节，这些在 HTTP 协议的内部都实现了。

1. URL

我们请求的图片、视频、音频、文档等，都称之为资源。
服务器的后台是 Linux 。

公网 IP 唯一确认一台主机，而网络资源一定是存在网络中的一台 Linux 机器上！
Linux 保存资源的方式，都是以文件的方式保存的。单 Linux 系统，标识一个唯一资源的方式，是通过路径！

所以，IP + Linux 路径，就可以唯一地确认一个网络资源！
IP：通常以域名的方式呈现，路径可以通过目录名 + / 确认。

例子：
在这里插入图片描述

我们所说的 “网址” ，其实就是 URL（Uniform Resource Locator，统一资源定位符）。

在这里插入图片描述

 ① 协议方案名：想要通过什么协议来获得资源。
 ② 登录信息：现在主流的 URL 已经很少用它，一般是通过表单的方式去提交。
 ③ 服务器地址：IP 通常以域名的方式呈现，实际上是建立了一个域名和 IP 地址的映射关系。
 ④ 服务器端口号：要访问服务器的端口，一般是省略的。因为协议方案名和端口号的关系是十分紧密的，在 URL 中指明了协议方案，端口号就不用呈现了。
 ⑤ 带层次的文件路径：基于 Linux 的文件系统目录结构。

一个基本的 URL 的构成方式是：协议 + 域名 + 资源路径，可能带参。

URL 的作用是，确认全网中唯一的一个资源。

2. HTTP 协议格式

HTTP 协议的序列化和反序列化格式，是 HTTP 协议自身定制的。

HTTP 请求和响应，基本上都是以行（\n）为单位进行构建的。
无论是请求还是响应，基本上都是由 3 或 4 部分组成。


在这里插入图片描述

说明：
 ① 请求行/状态行只有一行内容。
 ② 请求报头/响应报头有多行内容，是请求/响应属性，这些属性都以冒号分割的键值对的形式按行陈列（即每组属性之间使用 \n 分隔）。
 ③ 空行就是一个 \n 。
 ④ 请求正文/响应正文允许为空字符串。若请求正文/响应正文存在，则在请求报头/响应报头中会有一个 Content-Length 属性来标识请求正文/响应正文的长度。

HTTP request 和 HTTP response ，其实就是一个长字符串！它们的读取和发送实际上就是字符串的读取和发送。上面的形式是打印出来之后呈现的结果。

  • HTTP 的解包：读字符串时只要读到空行，就是把报头读完了，剩下的部分就是有效载荷。HTTP 的报头和有效载荷，是通过一个特殊字符（空行）来区分的。
  • HTTP 的封装：构建 HTTP 请求时，在请求行和请求报头后加上空行，然后再加上请求正文即可。构建 HTTP 响应同理。
  • HTTP 的分用：不是 HTTP 解决的，是具体的应用代码解决的。HTTP 需要有接口来帮助上层获取参数。

HTTP 协议的底层是 TCP 协议。

3.查看 HTTP 请求

程序说明：服务端只读取并打印 HTTP 请求，不构建和发送 HTTP 响应。

下面的程序包含两个文件：
 ① Sock.hpp：基本通信函数的实现。
 ② Http.cc：服务端。

  • Sock.hpp：
#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

using namespace std;

class Sock
{
public:
    static int Socket()
    {
        int sock = socket(AF_INET, SOCK_STREAM, 0);
        if(sock < 0){
            cerr << "socket error!" << endl;
            exit(2);
        }

        return sock;
    }

    static void Bind(int sock, uint16_t port)
    {
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        local.sin_addr.s_addr = INADDR_ANY;
        
        if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0){
            cerr << "bind error!" << endl;
            exit(3);
        }
    }

    static void Listen(int sock)
    {
        if(listen(sock, 5) < 0)
        {
            cerr << "listen error!" << endl;
            exit(4);
        }
    }

    static int Accept(int sock)
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int fd = accept(sock, (struct sockaddr*)&peer, &len);
        if(fd >= 0){
            return fd;
        }
        return -1;
    }

    static void Connect(int sock, std::string ip, uint16_t port)
    {
        struct sockaddr_in server;
        memset(&server, 0, sizeof(server));

        server.sin_family = AF_INET;
        server.sin_port = htons(port);
        server.sin_addr.s_addr = inet_addr(ip.c_str());

        if(connect(sock, (struct sockaddr*)&server, sizeof(server)) == 0)
        {
            cout << "Connect Success!" << endl;
        }
        else
        {
            cout << "Connect Failed!" << endl;
            exit(5);
        }
    }
};
  • Http.cc：
#include "Sock.hpp"
#include <pthread.h>

void Usage(std::string proc)
{
    std::cout << "Usage: " << proc << " port" << std::endl;
}

void *HandlerHttpRequest(void *args)
{
    int sock = *(int*)args;
    delete (int*)args;
    pthread_detach(pthread_self());

#define SIZE 1024*10
    char buffer[SIZE];
    memset(buffer, 0, sizeof(buffer));

    // 这种读法是不正确的，只不过在现在问题没有暴露出来
    ssize_t s = recv(sock, buffer, sizeof(buffer), 0);  // 跟read函数等价
    if(s > 0)
    {
        buffer[s] = 0;
        std::cout << "--------------------http request begin--------------------" << std::endl;
        std::cout << buffer;  // 查看http的请求格式！for test
        std::cout << "---------------------http request end---------------------" << std::endl;
    }

    close(sock);
    return nullptr;
}

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        exit(1);
    }

    uint16_t port = atoi(argv[1]);
    int listen_sock = Sock::Socket();
    Sock::Bind(listen_sock, port);
    Sock::Listen(listen_sock);

    for( ; ; )
    {
        int sock = Sock::Accept(listen_sock);
        if(sock > 0)
        {
            pthread_t tid;
            int *parm = new int(sock);
            pthread_create(&tid, nullptr, HandlerHttpRequest, parm);
        }
    }
}

运行测试：
使用浏览器连接服务器（浏览器会给服务器发送 HTTP 请求）：在这里插入图片描述

服务器接收到 HTTP 请求后，将其打印：
在这里插入图片描述
由于我们没有提交数据，所以这里的 HTTP 请求没有请求正文，只有三部分。

4.发送 HTTP 响应

HTTP 请求的 / 并不是根目录，而是叫做 web 根目录。web 根目录下放置的内容，都叫做资源！

我们一般要请求的一定是一个具体的资源：
 ① 若请求是 / ，意味着我们要请求的是该网站的首页，即 index.html 或 index.htm（一般所有的网站，都要有默认首页）。其实是服务器内部做判断，将访问资源的路径由 / 改成 /index.html 或 /index.htm 。
 ② 若请求是完整路径，意味着我们要请求的是一个特定的资源。

程序说明：服务端先读取并打印 HTTP 请求，然后发送一个 HTTP 响应。这里我们写死了，无论给服务器发送什么HTTP请求，服务器都只会把首页信息返回回去。

下面的程序包含三个文件：
 ① Sock.hpp：基本通信函数的实现，跟上面的一样，这里就不贴了。
 ② Http.cc：服务端。
 ③ index.html：一个简单的网站首页。

  • Http.cc：
#include "Sock.hpp"
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fstream>

// 其中我们这里的wwwroot目录，就叫做web根目录
// 理论上，web根目录可以放在Linux系统的任何目录下，只要能找到就行

// web根目录下的index.html就叫做网站的首页

#define WWWROOT "./wwwroot/"
#define HOME_PAGE "index.html"

void Usage(std::string proc)
{
    std::cout << "Usage: " << proc << " port" << std::endl;
}

void *HandlerHttpRequest(void *args)
{
    int sock = *(int*)args;
    delete (int*)args;
    pthread_detach(pthread_self());

#define SIZE 1024*10
    char buffer[SIZE];
    memset(buffer, 0, sizeof(buffer));

    // 这种读法是不正确的，只不过在现在问题没有暴露出来
    ssize_t s = recv(sock, buffer, sizeof(buffer), 0);  // 跟read函数等价
    if(s > 0)
    {
        buffer[s] = 0;
        std::cout << buffer;  // 查看http的请求格式！for test

        // std::string http_response = "HTTP/1.0 200 OK\n";
        // http_response += "Content-Type: text/plain\n";  // text/plain，正文是普通的文本
        // http_response += "\n";  // 空行
        // http_response += "hello world!";
        // send(sock, http_response.c_str(), http_response.size(), 0);  // 跟write函数等价

        // 这里我们写死了，无论给服务器发送什么HTTP请求，服务器都只会把首页信息返回回去
        std::string html_file = WWWROOT;
        html_file += HOME_PAGE;  // html_file表示文件路径
        // stat系统调用：获取指定路径下文件的属性（第二个参数是输出型参数）
        struct stat st;
        stat(html_file.c_str(), &st);
        // 返回的时候，不仅仅是返回正文网页信息，还要包括http响应
        std::string http_response = "HTTP/1.0 200 OK\n";
        http_response += "Content-Type: text/html; charset=utf8\n";  // 正文部分的数据类型
        http_response += "Content-Length: ";
        http_response += std::to_string(st.st_size);  // 内容长度，就是文件的大小
        http_response += "\n";
        http_response += "\n";  // 空行
        // 接下来才是正文
        std::ifstream in(html_file);  // 使用文件流对象打开文件
        if(!in.is_open())
        {
            std::cerr << "open html error!" << std::endl;
        }
        else{
            std::string content;
            std::string line;
            while(std::getline(in, line)){  // 用getline一行一行读取文件内容
                content += line;
            }
            http_response += content;
            in.close();

            send(sock, http_response.c_str(), http_response.size(), 0);  // 跟write函数等价
        }
    }

    close(sock);
    return nullptr;
}

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        exit(1);
    }

    uint16_t port = atoi(argv[1]);
    int listen_sock = Sock::Socket();
    Sock::Bind(listen_sock, port);
    Sock::Listen(listen_sock);

    for( ; ; )
    {
        int sock = Sock::Accept(listen_sock);
        if(sock > 0)
        {
            pthread_t tid;
            int *parm = new int(sock);
            pthread_create(&tid, nullptr, HandlerHttpRequest, parm);
        }
    }
}
  • index.html：
<!DOCTYPE html>

<html>
    <head>
        <meta charset="utf-8">
    </head>
    <body>
        <h3>hello world!</h3>
    </body>
</html>

运行测试：
浏览器给服务器发送 HTTP 请求，并接收到服务器的 HTTP 响应：
在这里插入图片描述

服务器接收到 HTTP 请求后，将其打印：
在这里插入图片描述

HTTP 协议，如果我们自己写的话，本质是我们要根据协议内容来进行文本分析。

  • 读取 HTTP request/response 时，我们要做到的事情是：
     ① 保证每次读取都是读取完整的一个 HTTP request/response 。
     ② 保证每次读取都不要将下一个 HTTP request/response 的一部分读到。

以 HTTP request 为例：在这里插入图片描述
读到空行，即可判定已经将报头部分读完。决定请求后面有没有正文，和请求方法有关。
Q：如果有正文，如何保证把正文全部读取完成，而且不要把下一个 HTTP 请求的部分数据读到呢？
A：读到空行，表明已把报头读完，就能提取报头中的一个属性Content-Length: len（如果有正文，就会有这个属性），该属性表明正文部分有多少个字节，然后再根据 len 决定读取多少个字节的正文。
正文就是有效载荷，换言之，Content-Length 表明了有效载荷的长度。

空行能够做到将报头和有效载荷进行分离（解包）。
同时，若存在 Content-Length ，它会帮助我们读取到完整的 HTTP 请求/响应；若不存在 Content-Length ，就是没有正文的时候，此时的 HTTP 请求/响应就只有三部分，只要读到空行，就读到了完整的 HTTP 请求/响应。

5. HTTP 的方法

在这里插入图片描述

其中最常用的是 GET 方法和 POST 方法。

实际上，管理服务器的人会把 GET 方法和 POST 方法暴露出来，一般不会把其它的方法暴露出来（主要是为了防止恶意操作，虽然协议支持）。


GET 方法和 POST 方法：

这里只修改了 index.html 的文件内容，其它文件内容不变。

  • GET 方法：如果提交参数，是通过 URL 的方式进行提交的。
<!DOCTYPE html>

<html>
    <head>
        <meta charset="utf-8">
    </head>
    <body>
        <h5>hello 我是首页!</h5>

        <h5>hello 我是表单!</h5>
        
        <!-- /a/b/handler_form并不存在，也不处理 -->
        <form action="/a/b/handler_from" method="GET">
            姓名：<input type="text" name="name"><br/>
            密码：<input type="password" name="passwd"><br/>
            <input type="submit" value="登录">
        </form>
    </body>
</html>

运行测试：
在这里插入图片描述
在这里插入图片描述

  • POST 方法：如果提交参数，是通过正文的方式进行提交的。
<!DOCTYPE html>

<html>
    <head>
        <meta charset="utf-8">
    </head>
    <body>
        <h5>hello 我是首页!</h5>

        <h5>hello 我是表单!</h5>
        
        <!-- /a/b/handler_form并不存在，也不处理 -->
        <form action="/a/b/handler_from" method="POST">
            姓名：<input type="text" name="name"><br/>
            密码：<input type="password" name="passwd"><br/>
            <input type="submit" value="登录">
        </form>
    </body>
</html>

运行测试：
在这里插入图片描述这里需要刷新一下浏览器，才能在请求正文中看到 POST 方法提交的参数：
在这里插入图片描述

从上面的实验我们可以看到，GET 方法和 POST 方法都可以向服务器提交参数，它们的区别是提交参数时参数所放的位置不同。


总结：

  1. GET 方法：叫做获取，是最常用的方法。默认一般获取所有的网页，都是 GET 方法，如果要提交参数，它是通过 URL 来进行参数拼接，从而提交给服务端。
  2. POST 方法：叫做推送，是提交参数比较常用的方法。如果提交参数，一般是通过正文部分提交的（Content-Length: xxx表示参数的长度）。
  3. 如果想获得某种资源，大部分情况下用的是 GET 方法。当提交参数时，既可以使用 GET 方法也可以使用 POST 方法。
  4. 它们的区别：
    ① 提交参数时参数所放的位置不同，POST 方法比较私密（私密 != 安全），因为不会回显到浏览器的 URL 输入框。而 GET 方法不私密，因为会将重要信息回显到浏览器的 URL 输入框。
    ② GET 方法是通过 URL 传参的，而 URL 是有大小限制的，和具体的浏览器有关。POST 方法是通过正文部分传参的，一般没有大小限制。
  5. 如何选择：
    ① GET 方法：如果提交的参数不敏感，数量非常少，可以采用 GET 方法。
    ② POST 方法：否则，就使用 POST 方法。

HTTP 协议处理，本质是文本分析。
所谓的文本分析：
 ① HTTP 协议本身的字段。
 ② 提取参数，如果有的话。
GET 或者 POST ，其实是前后端交互的一个重要方式。

6. HTTP 的状态码

在这里插入图片描述最常见的状态码，比如 200(OK)，404(Not Found)，403(Forbidden)，302(Redirect，重定向)，504(Bad Gateway) 。

应用层是人要参与的，人的水平参差不齐，HTTP 的状态码，很多人根本就不清楚如何使用，又因为浏览器的种类太多了，导致大家可能对状态码的支持并不是特别好。
类似于 404 的状态码，对浏览器没有任何指导意义，浏览器就是正常地显示网页，不会根据状态码做处理。

3XX 的状态码是有特殊含义的，重定向：
 ① 永久重定向：301 ，常用于网站搬迁、域名更换。
 ② 临时重定向：302 or 307 ，比如注册或登录成功后自动跳转到首页。

重定向的例子：
 ① 当访问某一个网站的时候，会让我们跳转到另一个网址。
 ② 当我们访问某种资源的时候，提示我们登录，跳转到了登录页面，登录成功后，会自动跳转回来。

重定向是需要浏览器给我们提供支持的，前提是浏览器必须识别重定向状态码。
要完成重定向，需要服务器的 HTTP 的响应报头存在这么一个属性，Location: 新的地址，告诉客户端接下来要去哪里访问。


重定向演示：
下面的程序包含两个文件：
 ① Sock.hpp：基本通信函数的实现，跟上面的一样，这里就不贴了。
 ② Http.cc：服务端。

  • Http.cc：
#include "Sock.hpp"
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fstream>

#define WWWROOT "./wwwroot/"
#define HOME_PAGE "index.html"

void Usage(std::string proc)
{
    std::cout << "Usage: " << proc << " port" << std::endl;
}

void *HandlerHttpRequest(void *args)
{
    int sock = *(int *)args;
    delete (int *)args;
    pthread_detach(pthread_self());

#define SIZE 1024 * 10
    char buffer[SIZE];
    memset(buffer, 0, sizeof(buffer));

    ssize_t s = recv(sock, buffer, sizeof(buffer), 0);
    if (s > 0)
    {
        buffer[s] = 0;
        std::cout << buffer; // 查看http的请求格式！for test

        std::string response = "HTTP/1.0 301 Permanently moved\n";
        response += "Location: https://www.qq.com/\n";
        response += "\n";
        send(sock, response.c_str(), response.size(), 0);
    }

    close(sock);
    return nullptr;
}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(1);
    }

    uint16_t port = atoi(argv[1]);
    int listen_sock = Sock::Socket();
    Sock::Bind(listen_sock, port);
    Sock::Listen(listen_sock);

    for (;;)
    {
        int sock = Sock::Accept(listen_sock);
        if (sock > 0)
        {
            pthread_t tid;
            int *parm = new int(sock);
            pthread_create(&tid, nullptr, HandlerHttpRequest, parm);
        }
    }
}

运行测试：
在浏览器的 URL 输入框中输入服务器的 IP 和 port 后，自动跳转到重定向的网站。
在这里插入图片描述在这里插入图片描述

7. HTTP 的版本

  • HTTP/1.0：短连接。建立连接 -> 请求 -> 响应 -> 关闭连接，每次 HTTP 请求返回一个资源。
    一个大型的网页，是由非常多个资源组成的，于是访问一个大型网页时，就需要进行多次 HTTP 请求。HTTP 协议是基于 TCP 协议的，所以 TCP 要通信，就要建立连接 -> 传输数据 -> 关闭连接，每一次 HTTP 请求都要执行上面的过程。所以，频繁地建立 TCP 连接，带来的开销就会很大，降低了效率。

  • HTTP/1.1 之后：支持长连接。长连接的请求/响应报头中会有Connection: keep-alive字段。一个连接可以进行多次请求/响应，不需要频繁地建立 TCP 连接，提高了效率。

8. HTTP 常见 Header

  • Content-Type：数据类型（比如 text/html 等）。
  • Content-Length：Body 的长度。
  • Host：客户端告知服务器，所请求的资源是在哪个主机的哪个端口上。
  • User-Agent：声明用户的操作系统和浏览器版本信息。
  • Referer：当前页面是从哪个页面跳转过来的。
  • Location：搭配 3XX 状态码使用，告诉客户端接下来要去哪里访问。
  • Cookie：用于在客户端存储少量信息，通常用于实现会话（session）的功能。

9. Cookie 与 session

HTTP 协议本身是一种无状态的协议，它并不记录发起 HTTP 请求的上下文信息。

当我们在进行各种页面跳转时，本质就是在进行各种 HTTP 请求，但是不管怎么跳转，网站照样认识我们（比如帐号身份信息）。

HTTP 协议主要帮我们解决网络资源获取的问题。要网站认识我们，并不是 HTTP 协议本身要解决的问题，但 HTTP 可以提供一些技术支持，来保证网站具有 “会话保持” 的功能，会话管理的功能由 Cookie 技术支持。

  • Cookie：
     ① 浏览器：Cookie 其实是一个文件，在浏览器中，有两种存在形式：文件版和内存版。该文件里面保存的是用户的私密信息。
     ② HTTP 协议：如果有该网站对应的 Cookie ，在发起任何请求的时候，都会自动在 request 中携带该 Cookie 信息。

Cookie 演示：
下面的程序包含三个文件：
 ① Sock.hpp：基本通信函数的实现，跟上面的一样，这里就不贴了。
 ② Http.cc：服务端。
 ③ index.html：一个简单的网站首页。

  • Http.cc：
#include "Sock.hpp"
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fstream>

#define WWWROOT "./wwwroot/"
#define HOME_PAGE "index.html"

void Usage(std::string proc)
{
    std::cout << "Usage: " << proc << " port" << std::endl;
}

void *HandlerHttpRequest(void *args)
{
    int sock = *(int *)args;
    delete (int *)args;
    pthread_detach(pthread_self());

#define SIZE 1024 * 10
    char buffer[SIZE];
    memset(buffer, 0, sizeof(buffer));

    ssize_t s = recv(sock, buffer, sizeof(buffer), 0);
    if (s > 0)
    {
        buffer[s] = 0;
        std::cout << buffer; // 查看http的请求格式！for test

        std::string html_file = WWWROOT;
        html_file += HOME_PAGE; // html_file表示文件路径

        // 接下来才是正文
        std::ifstream in(html_file); // 使用文件流对象打开文件
        if (!in.is_open())
        {
            std::string http_response = "HTTP/1.0 404 Not Found\n";
            http_response += "Content-Type: text/html; charset=utf8\n"; // 正文部分的数据类型
            http_response += "\n";
            http_response += "<html><p>你访问的资源不存在</p></html>";
            send(sock, http_response.c_str(), http_response.size(), 0);
        }
        else
        {
            // stat系统调用：获取指定路径下文件的属性（第二个参数是输出型参数）
            struct stat st;
            stat(html_file.c_str(), &st);
            // 返回的时候，不仅仅是返回正文网页信息，还要包括http响应
            std::string http_response = "HTTP/1.0 200 OK\n";
            http_response += "Content-Type: text/html; charset=utf8\n"; // 正文部分的数据类型
            http_response += "Content-Length: ";
            http_response += std::to_string(st.st_size); // 内容长度，就是文件的大小
            http_response += "\n";

            // Set-Cookie：服务器向浏览器设置一个Cookie
            // 告诉浏览器把Set-Cookie后面的内容写到浏览器的Cookie文件里
            // 从此往后，浏览器再向服务器请求时，都会把这个Cookie信息带上
            http_response += "Set-Cookie: id=1111\n";
            http_response += "Set-Cookie: password=2222\n";
            http_response += "\n";  // 空行

            std::string content;
            std::string line;
            while (std::getline(in, line))
            { // 用getline一行一行读取文件内容
                content += line;
            }
            http_response += content;
            in.close();

            send(sock, http_response.c_str(), http_response.size(), 0);
        }
    }

    close(sock);
    return nullptr;
}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(1);
    }

    uint16_t port = atoi(argv[1]);
    int listen_sock = Sock::Socket();
    Sock::Bind(listen_sock, port);
    Sock::Listen(listen_sock);

    for (;;)
    {
        int sock = Sock::Accept(listen_sock);
        if (sock > 0)
        {
            pthread_t tid;
            int *parm = new int(sock);
            pthread_create(&tid, nullptr, HandlerHttpRequest, parm);
        }
    }
}
  • index.html：
<!DOCTYPE html>

<html>
    <head>
        <meta charset="utf-8">
    </head>
    <body>
        <h5>hello 我是首页!</h5>

        <h5>hello 我是表单!</h5>
        
        <!-- /a/b/handler_form并不存在，也不处理 -->
        <form action="/a/b/handler_from" method="POST">
            姓名：<input type="text" name="name"><br/>
            密码：<input type="password" name="passwd"><br/>
            <input type="submit" value="登录">
        </form>
    </body>
</html>

运行测试：
在这里插入图片描述
在这里插入图片描述

刷新几次浏览器：浏览器检测到要访问网站的 Cookie 是存在的，于是在以后的请求中自动携带上 Cookie 。
在这里插入图片描述
若我们把该网站的 Cookie 移除掉，再刷新一下浏览器：
在这里插入图片描述

我们就会发现浏览器发送请求时就不再携带 Cookie 了，因为浏览器发现没有该网站对应的 Cookie 信息。在这里插入图片描述

服务器要给浏览器设置 Cookie ，需要在响应报头中加上Set-Cookie: key=value字段。
我们发现，浏览器每次向目标网站发起请求时，都会自动把曾经给浏览器写入的目标网站的 Cookie 信息携带上。

我们在任何网站登录后，一定会存在对应网站的 Cookie ，如果不想让网站认识我们，就可以把 Cookie 直接移除掉，再刷新网页，于是这个网站就不认识我们了；如果把 Cookie 一直保留着，浏览器在向目标网站发起任何请求时都会携带上 Cookie 字段，支持服务后端对我们的身份进行各种验证，所以在用户看来，只要在某个网站登录过一次，后面再次访问该网站时已无需登录，它已经认识我们了。

 ① 文件版 Cookie：在浏览器的安装目录以及浏览器使用的某些相关的用户级目录下，Cookie 信息保存在文件里，关闭浏览器甚至电脑重启再打开，都不会影响 Cookie 信息，再打开网站，还认识我们。
 ② 内存版 Cookie：Cookie 信息在内存中，浏览器一关闭，Cookie 信息就没有了，再打开网站，就不认识我们了。

这就是 Cookie 技术。

别人如果盗取我们的 Cookie 文件，别人就可以以我们的身份进行认证，访问特定的资源。如果保存的是我们的用户名和密码，那么就非常糟糕了。
单纯使用 Cookie 是具有一定安全隐患的。

  • session：核心思路是，将用户的私密信息保存在服务端。
    在这里插入图片描述

因为客户端的 Cookie 文件里面不再保存用户的任何私密信息，所以，即使 Cookie 文件泄露了，也不会导致用户的私密信息被泄露。

仍然存在 Cookie 文件被泄露的风险，这是无法杜绝的。如果 Cookie 文件泄露了，别人就可以拿着它，冒充我们的身份去访问对应的网站。虽然这个问题没法彻底解决，但是有一些衍生的防御方案，比如异地登录、短信认证等。

Cookie + session ，本质：增强用户访问网站或者平台的体验。

三、HTTP 与 HTTPS

HTTP 对数据是没有经过任何加密的，在网络中，数据其实是 “裸” 着的，是不安全的。

HTTPS = HTTP + TLS/SSL 。S 是 Secure 。TLS/SSL 可以理解为 HTTP 数据的加密解密层，也在应用层。HTTPS 对数据是经过加密的，是安全的。

什么叫做安全？安全不是让别人拿不到，而是别人拿到了也没法处理。
什么情况下是比较安全的呢？就是解密的成本远远超过解密之后带来的收益。

在这里插入图片描述
简单理解一下加密方式：

  • 对称加密，密钥（只有一个）X
    用 X 加密，也要用 X 解密。
    data ^ X = result
    result ^ X = data

  • 非对称加密，有一对密钥：公钥和私钥。
    用公钥加密，但只能用私钥解密，或者用私钥加密，但只能用公钥解密。
    一般而言，公钥是全世界公开的，私钥是自己必须私有保存的。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/178273.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

jvm 堆 栈中存什么？

jvm 堆 栈中存什么？

数据类型 Java虚拟机中&#xff0c;数据类型可以分为两类&#xff1a;基本类型和引用类型。基本类型的变量保存原始值&#xff0c;即&#xff1a;他代表的 值就是数值本身&#xff1b;而引用类型的变量保存引用值。“引用值”代表了某个对象的引用&#xff0c;而不是对象本身&…
阅读更多...
矩阵理论复习（六）

矩阵理论复习（六）

Q代表有理数&#xff0c;即整数和小数部分有限的分数和小数部分无限循环的分数。无限不循环的小数就是无理数。所有无理数和有理数加起来就是实数集R。与实数对应的就是虚数。 数域的定义 线性空间的定义 线性空间的基和维数 子空间的定义 子空间的判别方法 最常见的…
阅读更多...
【唐诗学习】二、初唐诗词领路人

【唐诗学习】二、初唐诗词领路人

二、初唐诗词领路人 唐朝之前的主流诗人都是在宫廷混口饭吃&#xff0c;他们整天围着皇帝转&#xff0c;写的大多是宫廷奢靡的生活&#xff0c;还会拍皇帝马屁。主流诗人受前朝影响很大&#xff0c;就这么发展到了初唐。照这个剧情发展下去&#xff0c;诗歌迟早要完蛋。 可有些…
阅读更多...
狂神聊Git~

狂神聊Git~

版本控制&#xff1a; 版本控制的概念: 它是一种在开发的过程中用于管理我们对文件&#xff0c;目录或工程等内容的修改历史&#xff0c;方便我们查看历史记录&#xff0c;备份以便恢复以前的版本的软件工程技术 版本控制的作用: 用于管理多人协同开发项目的技术 实现跨区…
阅读更多...
Tomcat进程占用CPU过高怎么办？

Tomcat进程占用CPU过高怎么办？

在性能优化这个主题里&#xff0c;前面我们聊过了Tomcat的内存问题和网络相关的问题&#xff0c;接下来我们看一下CPU的问题&#xff0c;CPU资源经常会成为系统性能的一个瓶颈&#xff0c;这其中的原因是多方面的&#xff0c;可能是内存泄漏导致频繁GC&#xff0c;进而引起CPU使…
阅读更多...
Linux命令--查看发行版本/内核版本的方法

Linux命令--查看发行版本/内核版本的方法

原文网址&#xff1a;Linux命令--查看发行版本/内核版本的方法_IT利刃出鞘的博客-CSDN博客 简介 本文介绍Linux查看发行版本和内核版本的方法。 查看发行版本 cat /etc/lsb_release 说明 这个命令适用于大部分linux发行版本&#xff08;除了redhat和centos等&#xff09; …
阅读更多...
C 语言零基础入门教程（九）

C 语言零基础入门教程（九）

C 函数 函数是一组一起执行一个任务的语句。每个 C 程序都至少有一个函数&#xff0c;即主函数 main() &#xff0c;所有简单的程序都可以定义其他额外的函数。 您可以把代码划分到不同的函数中。如何划分代码到不同的函数中是由您来决定的&#xff0c;但在逻辑上&#xff0c;…
阅读更多...
用Zybo调试CY7C68013A核心板的Slave FIFO模式

用Zybo调试CY7C68013A核心板的Slave FIFO模式

用Zybo调试CY7C68013A核心板简介CY7C68013A核心板CY7C68013程序设计硬件连接主要代码Zybo程序设计心得简介 最近在调试CY7C68013A核心板的Slave FIFO模式时&#xff0c;因为电路板的丝印bug&#xff0c;绕了一大圈。最终不但调试成功&#xff0c;也发现了用Zybo调试其它电路板…
阅读更多...
C语言对数组元素进行排序

C语言对数组元素进行排序

在实际开发中&#xff0c;有很多场景需要我们将数组元素按照从大到小&#xff08;或者从小到大&#xff09;的顺序排列&#xff0c;这样在查阅数据时会更加直观&#xff0c;例如&#xff1a;一个保存了班级学号的数组&#xff0c;排序后更容易分区好学生和坏学生&#xff1b;一…
阅读更多...
教练，我想学设计之禅

教练，我想学设计之禅

欢迎来到PaQiuQiu的空间 本文为【教练，我想学设计之禅】，方便大家更好的阅读! <—写在前面—> 本专栏分四部分展开，设计模式与设计原则、算法与数据结构、架构设计以及实战为王。 设计模式介绍了经典的23种设计模式，设计原则重点阐述SOLID原则； 算法与数据结构详…
阅读更多...
Linux常用命令——slabtop命令

Linux常用命令——slabtop命令

在线Linux命令查询工具(http://www.lzltool.com/LinuxCommand) slabtop 实时显示内核slab内存缓存信息 补充说明 slabtop命令以实时的方式显示内核“slab”缓冲区的细节信息。 语法 slabtop(选项)选项 --delayn, -d n&#xff1a;每n秒更新一次显示的信息&#xff0c;默…
阅读更多...
使用树莓派3B、RTL-SDR、OpenWebRX搭建无线电监测站

使用树莓派3B、RTL-SDR、OpenWebRX搭建无线电监测站

方案介绍&#xff1a; OpenWebRX是一个国外开源项目&#xff0c;基于Python语言编写&#xff0c;配合SDR设备使用&#xff0c;能将SDR接收软件Web化&#xff0c;通过网络实现多用户远程访问&#xff0c;无需安装任何客户端软件&#xff0c;功能非常强大&#xff0c;支持&#x…
阅读更多...
Python位置参数

Python位置参数

位置参数&#xff0c;有时也称必备参数&#xff0c;指的是必须按照正确的顺序将实际参数传到函数中&#xff0c;换句话说&#xff0c;调用函数时传入实际参数的数量和位置都必须和定义函数时保持一致。实参和形参数量必须一致在调用函数&#xff0c;指定的实际参数的数量&#…
阅读更多...
DaVinci：Camera Raw（CinemaDNG）

DaVinci：Camera Raw（CinemaDNG）

本文主要介绍 CinemaDNG Raw 格式素材相关的 Camera Raw 参数。解码质量Decode Quality解码质量决定了图像解拜耳之后所呈现的素质。默认为“使用项目设置” Use project setting&#xff0c;表示使用项目设置对话框中的“Camera RAW”解码质量设置。还可选择&#xff1a;全分辨…
阅读更多...
离散系统的数字PID控制仿真-1

离散系统的数字PID控制仿真-1

控制对象为&#xff1a;采样时间为1ms&#xff0c;采用z变换进行离散化&#xff0c;经过z变换后的离散化对象为&#xff1a;y(k)-den(2)y(k -1)- den(3)y(k -2)- den(4)y(k-3)num(2)u(k -1) num(3)u(k -2) num(4)u(k-3)设计离散PID控制器。其中&#xff0c;S为信号选择变量&…
阅读更多...
【数据库概论】第四章 数据库安全性

【数据库概论】第四章 数据库安全性

第四章 数据库安全性 目录第四章 数据库安全性4.1 概述4.2 数据库安全性控制1.用户身份识别2.存取控制3.自主存取控制方法4.授权&#xff1a;授予与收回GRANT&#xff1a;授权语句REVOKE&#xff1a;收回权限3.创建数据库模式的权限4.数据库角色5.角色权限的回收6.强制存取控制…
阅读更多...
贪心算法(greedy algorithm)

贪心算法(greedy algorithm)

贪心算法什么是贪心算法[122. 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/)代码[455. 分发饼干](https://leetcode.cn/problems/assign-cookies/)思路代码[435. 无重叠区间](https://leetcode.cn/problems/non-overlapping-inte…
阅读更多...
SaaS是什么，目前主流的国内SAAS平台提供商有哪些？

SaaS是什么，目前主流的国内SAAS平台提供商有哪些？

SaaS是什么&#xff0c;目前主流的国内SAAS平台提供商有哪些&#xff1f;SaaS这个概念近两年可谓说是十分火热&#xff0c;尤其是后疫情时代。 但还是有很多人对SaaS这个名词云里雾里&#xff0c;被碎片化的信息裹挟&#xff0c;并没有真正意义上理解SaaS的概念。 这篇就综合…
阅读更多...
87.【SpringBoot-01】

87.【SpringBoot-01】

SpringBoot(一)、前面回顾1.什么是Spring2.Spring 是如何简化Java开发的(二)、什么是SpringBoot1.基本含义:2.Spring Boot的主要优点(三)、微服务1.什么是微服务2.单体应用架构3.微服务架构 (活字印刷)4.如何构建微服务(四)、第一个SpringBoot程序1.点击新建文件2.勾选web框架3…
阅读更多...
通用的产品功能设计方法

通用的产品功能设计方法

通用的产品功能设计方法1.如何设计注册/登录功能1.1 注册功能设计1.2 登录功能的设计2.如何设计APP启动页功能和引导页功能2.1 启动页功能设计2.2 引导页功能设计3.如何设计非法信息输入校验功能3.1 非法文本信息的输入校验规则3.2 非法图片信息的输入校验规则3.3 非法附件信息…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023