HTTP协议详解：从URL到HTTP报文的全貌

⭐小白苦学IT的博客主页⭐

⭐初学者必看：Linux操作系统入门⭐

⭐代码仓库：Linux代码仓库⭐

❤关注我一起讨论和学习Linux系统

前言

随着互联网的飞速发展，HTTP协议作为支撑网络应用的核心基石，扮演着举足轻重的角色。无论是日常的网页浏览、在线购物，还是企业级的系统交互、数据交换，都离不开HTTP协议的默默支撑。本文将从认识URL开始，逐步深入HTTP协议的核心概念，通过理解和实践，帮助读者全面掌握HTTP协议的工作原理和应用技巧。

1.两个简单的预备知识

1.1认识URL

我们平常说的“网址”实际上就是URL（Uniform Resource Locator，统一资源定位符）的俗称。URL是用于指定互联网上资源位置的一种标识符，它告诉浏览器或其他客户端如何找到并访问这些资源。

URL的基本结构由几个关键部分组成。一般来说，它遵循以下格式：协议://域名:端口/路径?查询字符串#片段。其中，协议部分指定了使用的传输协议，如HTTP或HTTPS；域名是网站或服务器的地址；端口号（可选）指定了服务器上用于接收请求的端口；路径则指向了服务器上特定的资源位置；查询字符串用于传递额外的参数给服务器；片段则用于指定资源中的特定部分。

以下是一个基于HTTP协议的URL，以及对其进行的域名解析和每一部分的说明：
URL: http://example.com/products/item123?color=red&size=large
在这个例子中：

URL各部分说明：

协议：
http://：这表示使用的是HTTP协议。HTTP（超文本传输协议）是用于传输网页内容（如HTML、图片等）的协议。需要注意的是，为了安全性，实际使用中更推荐使用HTTPS协议（即https://），它提供了数据加密功能。
域名：
example.com：这是URL的域名部分，它指向了一个具体的服务器或服务器集群。在这个例子中，example.com是一个通用的示例域名，实际使用中会是一个真实的域名，比如google.com或amazon.com。
路径：
/products/item123：这是URL的路径部分，它指定了服务器上资源的具体位置。在这个例子中，路径指向了名为“products”的目录下的一个名为“item123”的资源，可能是某个产品页面的标识。
查询字符串：
?color=red&size=large：这是URL的查询字符串部分，用于传递额外的参数给服务器。在这里，我们传递了两个参数：color和size，分别表示产品的颜色和尺寸。查询字符串的参数之间用&符号分隔，参数名和参数值之间用=符号连接。

域名解析说明：

域名解析是将域名转换为IP地址的过程，这样浏览器或其他客户端才能知道如何连接到服务器。以下是对example.com域名解析的简要说明：

因此，当我们说“输入网址”或“访问网址”时，实际上就是在使用或引用一个URL，以便定位并获取互联网上的特定资源。在日常生活和技术交流中，人们常常用“网址”这个更通俗的词汇来代替“URL”这个更专业的术语。

1.2 urlencode和urldecode

URL的编码规则也是我们需要理解的重要方面。由于URL中可能包含一些特殊字符，如空格、斜杠等，这些字符在URL中具有特殊含义，因此不能直接使用。为了解决这个问题，URL编码规则被引入。通过特定的编码方式，这些特殊字符可以被转换为URL安全的格式，以确保URL的正确性和有效性。

像 / ? : 等这样的字符, 已经被url当做特殊意义理解了. 因此这些字符不能随意出现.
比如, 某个参数中需要带有这些特殊字符, 就必须先对特殊字符进行转义.
转义的规则如下:
将需要转码的字符转为16进制，然后从右到左，取4位(不足4位直接处理)，每2位做一位，前面加上%，编码成%XY格式

理解URL的作用和重要性也是至关重要的。URL作为网络资源的定位器，不仅可以帮助我们找到和访问特定的网页、图片、视频等资源，还可以用于构建复杂的网络应用和服务。通过URL，我们可以实现资源的共享、链接、跳转等操作，为互联网的发展和应用提供了强大的支持。

为了更好地理解和应用URL，我们可以结合实际的例子进行学习和实践。例如，我们可以尝试分析一些常见的URL结构，了解它们是如何构成的以及各部分的作用；我们还可以尝试使用URL编码和解码工具来处理包含特殊字符的URL；此外，通过浏览网页、点击链接等操作，我们也可以直观地感受URL在实际应用中的作用和价值。

以下是一些常见的URL特殊字符及其对应的编码：

空格：%20
正斜杠（用于分隔目录和子目录）：%2F
问号（用于分隔实际的URL和参数）：%3F
百分号（用于制定特殊字符）：%25
#号（用于表示书签）：%23
&号（用于分隔URL中的参数）：%26
=号（用于分隔参数和其值）：%3D

2.http请求和响应

HTTP（超文本传输协议）的请求和响应是Web通信的重要组成部分，它们允许客户端（如浏览器）向服务器请求资源，而服务器则将这些资源发送回客户端。理解HTTP的请求和响应是掌握Web开发和网络通信的关键。

HTTP请求主要由三部分组成：请求行、请求头部和请求体（如果有的话）。请求行包含了请求方法（如GET、POST等）、请求的URL以及使用的HTTP协议版本（如HTTP/1.1）。请求头部则包含了关于请求的附加信息，如浏览器类型、用户代理等。请求体则用于发送数据给服务器，通常在POST请求中使用。

HTTP响应也由三部分组成：响应行、响应头部和响应体。响应行包含了HTTP协议版本、状态码和状态消息。状态码用于表示请求的处理结果，如200表示成功，404表示未找到资源等。响应头部包含了关于响应的附加信息，如内容类型、内容长度等。响应体则包含了服务器返回给客户端的实际数据，如HTML页面、图片等。

在HTTP通信过程中，客户端首先向服务器发送一个HTTP请求，服务器接收到请求后进行处理，并返回一个HTTP响应给客户端。客户端再根据响应的状态码和内容执行相应的操作，如显示网页、下载文件等。

为了更深入地理解HTTP的请求和响应，可以使用工具如Fiddler或Postman来查看和分析实际的HTTP请求和响应。这些工具可以帮助你直观地看到请求的详细信息，如请求头、请求体等，以及响应的详细信息，如状态码、响应头等。

http请求

首行: [方法] + [url] + [版本]
Header: 请求的属性, 冒号分割的键值对;每组属性之间使用\n分隔;遇到空行表示Header部分结束
Body: 空行后面的内容都是Body. Body允许为空字符串. 如果Body存在, 则在Header中会有一个Content-Length属性来标识Body的长度;

http响应

首行: [版本号] + [状态码] + [状态码解释]
Header: 请求的属性, 冒号分割的键值对;每组属性之间使用\n分隔;遇到空行表示Header部分结束
Body: 空行后面的内容都是Body. Body允许为空字符串. 如果Body存在, 则在Header中会有一个Content-Length属性来标识Body的长度; 如果服务器返回了一个html页面, 那么html页面内容就是在body中.

http协议格式

HTTP报文主要由请求报文和响应报文两种类型组成。请求报文由客户端发送，用于请求服务器上的资源；响应报文则由服务器发送，用于将请求的资源返回给客户端。

请求报文

请求报文主要由请求行、请求头部和请求体（如有）三个部分组成。

请求行：包含了请求方法、请求的URL和HTTP协议版本。请求方法常见的有GET、POST、PUT、DELETE等，它们分别对应不同的操作类型。URL则指明了请求的具体资源位置。HTTP协议版本则告知服务器所使用的HTTP协议标准。
请求头部：包含了关于请求的附加信息，如User-Agent（用户代理，表示发出请求的浏览器类型）、Accept（客户端可识别的内容类型列表）、Host（请求的主机名）等。这些头部字段有助于服务器更好地理解客户端的需求和环境，从而做出更合适的响应。
请求体：主要用于POST、PUT等请求方法中，包含发送给服务器的数据。例如，在提交表单时，表单数据就会作为请求体发送给服务器。

响应报文

响应报文主要由状态行、响应头部和响应体三个部分组成。

状态行：包含了HTTP协议版本、状态码和状态消息。状态码用于表示请求的处理结果，如200表示请求成功，404表示未找到资源等。状态消息则是对状态码的简单描述。
响应头部：与请求头部类似，也包含了关于响应的附加信息。如Content-Type（内容类型）、Content-Length（内容长度）等，这些头部字段有助于客户端正确地解析和处理响应数据。
响应体：包含了服务器返回给客户端的实际数据，如HTML页面、图片、JSON数据等。这些数据是客户端请求的最终结果。

3.写一个简单的httpserver,用浏览器测试

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <pthread.h>
#include "Sock.h"
#include "Log.h"

const uint16_t defaultport = 8080;
const std::string wwwroot = "./www";
const std::string homepage = "index.html";

// 线程数据结构
struct ThreadData
{
    int _sockfd; // 客户端套接字
    ThreadData(int sockfd) : _sockfd(sockfd) {}
};

// HTTP请求类
class HttpRequest
{
public:
    void Deserialize(const std::string &data)
    {
        std::istringstream iss(data);
        std::string line;
        while (std::getline(iss, line))
        {
            if (line == "\r")
                break;
            req_header.push_back(line);
        }
        text = data.substr(data.find("\r\n\r\n") + 4);
    }

    void Parse()
    {
        std::istringstream iss(req_header[0]);
        iss >> method >> url >> http_version;

        file_path = wwwroot;
        if (url == "/" || url == "/index.html")
        {
            file_path += "/";
            file_path += homepage;
        }
        else
            file_path += url;
    }

    void DebugPrint()
    {
        for (auto &line : req_header)
        {
            std::cout << "-----------------------------" << std::endl;
            std::cout << line << "\n\n";
        }
        std::cout << "method: " << method << std::endl;
        std::cout << "url: " << url << std::endl;
        std::cout << "http_version: " << http_version << std::endl;
        std::cout << "file_path: " << file_path << std::endl;

        std::cout << text << std::endl;
    }

public:
    std::vector<std::string> req_header; // HTTP请求头
    std::string text;                    // HTTP请求体

    // 解析后的请求组件
    std::string method;
    std::string url;
    std::string http_version;
    std::string file_path; // 请求资源的文件路径
};

// HTTP服务器类
class HttpServer
{
public:
    HttpServer(uint16_t port = defaultport) : _port(port) {}

    // 启动HTTP服务器
    bool Start()
    {
        _listensock.Socket();   // 创建监听套接字
        _listensock.Bind(_port); // 绑定端口
        _listensock.Listen();    // 开始监听

        for (;;)
        {
            std::string clientip;
            uint16_t clientport;
            int sockfd = _listensock.Accept(&clientip, &clientport); // 接受新的客户端连接
            if (sockfd < 0)
                continue;
            log.LogMessage(INFO, "接收到新连接, sockfd: %d ", sockfd); // 记录新连接
            pthread_t tid; // 线程ID
            ThreadData *td = new ThreadData(sockfd); // 创建线程数据
            pthread_create(&tid, nullptr, ThreadRun, td); // 创建新线程处理连接
        }
    }

    // 读取HTML文件内容
    static std::string ReadHtmlContent(const std::string &htmlpath)
    {
        std::ifstream in(htmlpath);
        if (!in.is_open())
            return "404"; // 文件无法打开时返回404

        std::string content;
        std::string line;
        while (std::getline(in, line))
        {
            content += line;
        }
        in.close();

        return content; // 返回HTML文件内容
    }

    // 处理HTTP请求
    static void HandlerHttp(int sockfd)
    {
        char buffer[10240];
        ssize_t n = recv(sockfd, buffer, sizeof(buffer) - 1, 0); // 接收HTTP请求
        if (n > 0)
        {
            buffer[n] = 0;
            std::cout << buffer; // 打印接收到的HTTP请求

            // 处理HTTP请求
            HttpRequest req;
            req.Deserialize(buffer); // 反序列化HTTP请求
            req.Parse();             // 解析HTTP请求
            std::string text = ReadHtmlContent(req.file_path); // 读取请求资源的内容
            std::string response_line = "HTTP/1.0 200 OK\r\n"; // HTTP响应行
            std::string response_header = "Content-Length: ";  // HTTP响应头
            response_header += std::to_string(text.size());
            response_header += "\r\n";
            std::string blank_line = "\r\n"; // 空行

            std::string response = response_line;
            response += response_header;
            response += blank_line;
            response += text;

            send(sockfd, response.c_str(), response.size(), 0); // 发送HTTP响应
        }
        close(sockfd); // 关闭套接字
    }

    // 线程函数处理连接
    static void *ThreadRun(void *args)
    {
        pthread_detach(pthread_self()); // 分离线程
        ThreadData *td = static_cast<ThreadData *>(args); // 获取线程数据
        HandlerHttp(td->_sockfd); // 处理HTTP请求
        delete td; // 删除线程数据
        return nullptr;
    }

    ~HttpServer() {}

private:
    Sock _listensock; // 监听套接字
    uint16_t _port;   // 服务器端口
};

HttpRequest类：

Deserialize函数：将接收到的HTTP请求序列化为字符串。根据HTTP请求的格式，将请求头、请求体等信息序列化为字符串。
Parse函数：解析HTTP请求，提取出请求方法、URL、HTTP版本和请求资源的文件路径。根据HTTP请求的格式，解析出请求行中的方法、URL和HTTP版本，以及请求头中的其他信息。
DebugPrint函数：用于调试目的，打印HTTP请求的各个组件。将解析出的HTTP请求的各个组件打印输出，方便查看请求的具体内容。

HttpServer类：

Start函数：启动HTTP服务器，创建监听套接字、绑定端口、开始监听并接受新的客户端连接。在循环中接受新的客户端连接，并创建新线程处理连接。
ReadHtmlContent函数：读取HTML文件内容，返回文件内容的字符串表示。打开指定的HTML文件，逐行读取内容并拼接为字符串返回。
HandlerHttp函数：处理HTTP请求，接收HTTP请求，解析请求，读取请求资源的内容，构建HTTP响应并发送回客户端。接收客户端的HTTP请求，解析请求并读取请求资源的内容，构建HTTP响应并发送回客户端。
ThreadRun函数：线程函数，用于处理连接的线程函数，调用`HandlerHttp`处理HTTP请求并在处理完毕后释放资源。线程函数，接收一个套接字参数，调用`HandlerHttp`处理HTTP请求并在处理完毕后释放资源。

`HttpRequest`类负责解析和处理HTTP请求的相关操作，而`HttpServer`类负责启动HTTP服务器、处理HTTP请求和创建线程处理连接的相关操作。

Socket.hpp(套接字封装)

#pragma once

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "Log.hpp"
#include <cstring>

enum
{
    SocketErr = 2,
    BindErr,
    ListenErr,
};

const int backlog = 10;

class Sock
{
public:
    Sock() {}
    ~Sock() {}

public:
    void Socket()
    {
        _sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (_sockfd < 0)
        {
            log.LogMessage(FATAL, "socket error , %s : %d", strerror(errno), errno);
            exit(SocketErr);
        }
    }

    void Bind(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(_sockfd,(struct sockaddr*)&local,sizeof(local))<0)
        {
            log.LogMessage(FATAL, "bind error , %s : %d", strerror(errno), errno);
            exit(BindErr);
        }
    }

    void Listen()
    {
        if(listen(_sockfd,backlog)<0)
        {
            log.LogMessage(FATAL, "listen error , %s : %d", strerror(errno), errno);
            exit(ListenErr);
        }
    }

    int Accept(std::string *clientip,uint16_t * clientport)
    {   
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int newfd = accept(_sockfd,(struct sockaddr*)&peer,&len);
        if(newfd<0)
        {
            log.LogMessage(WARNING,"accep error, %s : %d",strerror(errno),errno);
            return -1;
        }
        *clientport = ntohs(peer.sin_port);
        char ipstr[64];
        inet_ntop(AF_INET,&(peer.sin_addr),ipstr,sizeof(ipstr));
        *clientip = ipstr;

        return newfd;
    }

    int Connect(const std::string & clientip,const uint16_t & clientport)
    {
        struct sockaddr_in peer;
        memset(&peer,0,sizeof(peer));
        peer.sin_family = AF_INET;
        peer.sin_port = htons(clientport);
        inet_pton(AF_INET,clientip.c_str(),&(peer.sin_addr));
        int n = connect(_sockfd,(struct sockaddr*)&peer,sizeof(peer));
        if(n<0)
        {
            std::cerr<<"connect to error ..."<<std::endl;
            return false;
        }

        return true;
    }

    int GetFd()
    {
        return _sockfd;
    }

    void Close()
    {
        close(_sockfd);
    }

private:
    int _sockfd;
};

HttpServer.cc

#include "HttpServer.hpp"
#include<memory>
#include<iostream>


int main(int argv,char *argc[])
{
    if(argv!=2)
    {
        std::cerr<<"Usage: "<<argc[0]<<" port[1024+]"<<std::endl;
        exit(0);
    }

    uint16_t serverport = std::stoi(argc[1]);
    std::unique_ptr<HttpServer> svr(new HttpServer(serverport));
    svr->Start();
    return 0;
}

提示：这只是用于测试的部分代码，如需要完整代码进行测试，请查看文章标题下的代码仓库。

访问我的云服务器公网ip+端口号可以看到如下结果：

测试结果：

通过点击去第二个有趣的文本的超链接跳转到第二个对应的页面如下：

点击回到首页即第一张图，如果点击看第三个有趣的文本，则如下图所示：

而服务端收到的请求信息如下：

4.谈http报文的细节

http的方法

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

1. GET：用于请求获取指定资源的信息。GET 请求只是获取数据，不会对服务器上的资源产生任何影响。

2. POST：向服务器提交数据，用于提交数据到指定的资源，常用于表单提交。POST 请求可能会导致服务器上的资源发生变化。

3. PUT：用于更新指定资源的信息。PUT 请求通常用于更新已有资源的信息，需要提供完整的资源信息。

4. DELETE：用于删除指定资源。DELETE 请求用于删除服务器上的指定的资源。

5. PATCH：用于更新部分资源的信息。PATCH 请求与 PUT 请求类似，但是 PATCH 请求用于更新部分资源的信息，而不是整个资源。

6. HEAD：类似于 GET 请求，但是服务器只返回请求头信息，不返回实际的资源内容。用于获取资源的元数据，如响应头信息、响应状态码等。

7. OPTIONS：用于查询服务器支持的请求方法。OPTIONS 请求用于获取服务器支持的请求方法，以及服务器支持的其他功能。

8. TRACE：用于追踪请求在服务器端的处理过程。TRACE 请求用于测试客户端与服务器之间的通信，以查看请求在服务器端的处理情况。

9. CONNECT：用于将服务器作为代理连接。CONNECT 请求用于在客户端和服务器之间建立隧道连接，通常用于加密通信。

http的状态码

HTTP 状态码是服务器对客户端请求的响应状态的一种表示，它包含了客户端发起请求后服务器返回的状态信息。每个状态码由三位数字组成，分为五个类别，分别代表不同的含义：

1. 1xx（Informational）：表示请求已接收，继续处理。
2. 2xx（Success）：表示请求已成功接收、理解和接受。
3. 3xx（Redirection）：表示需要客户端采取进一步的操作才能完成请求。
4. 4xx（Client Error）：表示客户端发送的请求有错误。
5. 5xx（Server Error）：表示服务器在处理请求时发生了错误。

一些常见的 HTTP 状态码包括：

- 200 OK：表示请求成功。
- 201 Created：表示请求已经被实现，而且有一个新的资源已经依据请求的需要而建立。

- 302 Found：表示临时重定向，告诉客户端请求的资源暂时被移动到另一个位置。
- 400 Bad Request：表示客户端发送的请求有错误。
- 401 Unauthorized：表示请求需要用户认证。
- 404 Not Found：表示请求的资源未找到。
- 500 Internal Server Error：表示服务器在处理请求时发生了错误。

通过查看 HTTP 状态码，可以了解请求的处理结果，从而进行相应的处理。在开发过程中，了解常见的状态码及其含义对于排查问题和调试非常有帮助。

HTTP常见Header

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

下面我们只详细介绍后面三个Header:

Referer（引用页）是HTTP头部中的一个字段，用于指示客户端请求的当前页面是从哪个页面跳转过来的。Referer头部通常在客户端发起HTTP请求时自动包含在请求中，告诉服务器当前请求的来源页面。

Referer头部的作用包括但不限于以下几个方面：
1. 统计分析：网站可以通过Referer头部来分析用户从哪些页面跳转过来访问当前页面，从而了解用户的流量来源和行为路径。
2. 安全性：服务器可以根据Referer头部判断请求的来源，防止恶意网站盗用资源或进行CSRF（跨站请求伪造）攻击。
3. 个性化推荐：根据用户的访问来源，网站可以提供个性化的内容或推荐。

Referer头部的格式通常为完整的URL地址，例如：
Referer: http://www.example.com/page1.html
需要注意的是，有些浏览器或防火墙可能会禁用或修改Referer头部，以保护用户的隐私和安全。因此，在实际开发中，不能完全依赖Referer头部来做安全验证或统计分析，应该结合其他手段来确保系统的安全性和稳定性。

总之，Referer头部是一个有用的HTTP头部，可以为网站提供一些额外的信息和功能，但开发者需要注意其可能存在的限制和安全隐患。

Location是一个HTTP响应头部字段，通常与3xx状态码一起使用，用于指示客户端应该重定向到的新位置。当服务器返回带有3xx状态码的响应时，可以在响应头部中包含Location字段，告诉客户端应该访问的新URL地址。

Location头部的作用包括但不限于以下几个方面：
1. 重定向：服务器可以通过返回带有Location头部的响应来实现重定向功能，将客户端自动引导到新的页面或资源。
2. URL规范化：可以通过Location头部将URL规范化，确保客户端访问的是统一的URL地址。
3. 负载均衡：在负载均衡和网站优化中，可以使用Location头部将请求分发到不同的服务器或CDN节点。

Location头部的格式通常为完整的URL地址，例如：
Location: http://www.example.com/newpage.html
常见的3xx状态码与Location头部的组合包括：
- 301 Moved Permanently：永久重定向，客户端应该记住新的URL地址。
- 302 Found / 303 See Other：临时重定向，客户端应该暂时访问新的URL地址。
- 307 Temporary Redirect：临时重定向，客户端应该保持原有的HTTP方法（GET、POST等）。
- 308 Permanent Redirect：永久重定向，客户端应该保持原有的HTTP方法。

需要注意的是，客户端在收到带有Location头部的响应后，会自动跳转到新的URL地址。开发者在使用重定向功能时，应该考虑好目标URL的合法性和安全性，避免出现无限重定向或安全漏洞。

总之，Location头部是一个重要的HTTP头部字段，用于实现重定向功能，帮助网站优化和改善用户体验。在开发过程中，需要正确使用Location头部，并考虑其可能带来的影响和风险。

Cookie是一种存储在用户计算机上的小型文本文件，由服务器生成并发送给客户端浏览器，用于在客户端和服务器之间传递数据。Cookie通常用于记录用户的身份认证、会话状态、个性化设置等信息，以便在用户访问同一网站时能够保持持久性和状态。

Cookie的特点和作用包括但不限于以下几个方面：
1. 身份认证：网站可以使用Cookie来记录用户的登录状态，实现持久性登录，避免用户重复输入用户名和密码。
2. 会话管理：Cookie可以用于记录用户的会话信息，如购物车内容、浏览历史等，在用户访问网站时保持会话状态。
3. 个性化体验：网站可以根据用户的Cookie信息提供个性化的内容和推荐，增强用户体验。
4. 跟踪分析：网站可以使用Cookie来跟踪用户的访问行为和偏好，进行统计分析和广告投放。
5. 安全性：Cookie可以设置HttpOnly和Secure属性，增强Cookie的安全性，防止被恶意脚本获取。

Cookie通常由服务器在HTTP响应头部中的Set-Cookie字段生成并发送给客户端浏览器，浏览器会将Cookie存储在本地的Cookie数据库中。当用户再次访问同一网站时，浏览器会自动将相应的Cookie发送给服务器，实现数据的传递和共享。

Cookie有一些属性，包括但不限于：
- Name：Cookie的名称
- Value：Cookie的值
- Domain：Cookie的域名范围
- Path：Cookie的路径范围
- Expires / Max-Age：Cookie的过期时间或持续时间
- Secure：指定Cookie只能通过HTTPS协议传输
- HttpOnly：指定Cookie只能通过HTTP协议访问，不能被JavaScript获取

需要注意的是，Cookie虽然在一定程度上方便了网站和用户之间的数据传递和共享，但也存在一些安全和隐私风险。开发者在使用Cookie时，应该注意保护用户的隐私信息，避免敏感数据泄露和恶意利用。

总之，Cookie是一种重要的Web技术，用于在客户端和服务器之间传递数据，实现身份认证、会话管理和个性化体验等功能。在开发过程中，需要合理使用Cookie，并注意其安全性和隐私保护。