构建单线程 Web 服务器 -- Rust教程|Rust中文文档|Rust编程|Rust官方文档

使用，我们可以侦听地址处的 TCP 连接。在地址中，冒号前面的部分是 IP 地址代表您的计算机（这在每台计算机上都是相同的，但不会专门表示作者的计算机），并且是端口。我们已经选择此端口有两个原因：此端口通常不接受 HTTP，因此我们的服务器不太可能与您可能拥有的任何其他 Web 服务器冲突运行，并且 7878 是在电话上打出 Rust 的。TcpListener127.0.0.1:78787878

此方案中的函数的工作方式与函数类似，因为它将返回一个新实例。调用该函数是因为，在网络中，连接到要侦听的端口称为“绑定到一个港口。bindnewTcpListenerbind

该函数返回一个，这表明它是可能会使绑定失败。例如，连接到端口 80 需要管理员权限（非管理员只能侦听更高的端口比 1023 多），因此如果我们尝试连接到端口 80 而不成为 administrator，则 binding 不起作用。绑定也不起作用，例如，如果我们运行程序的两个实例，因此有两个程序侦听相同的端口。因为我们编写一个基本的服务器只是为了学习目的，所以我们不会担心处理这些类型的错误;相反，我们习惯于 to 如果发生错误，请停止程序。bindResult<T, E>unwrap

方法 on 返回一个迭代器，它为我们提供了一个流序列（更具体地说，类型为流）。单个流表示客户端和服务器之间的开放连接。连接是完整请求和响应过程的名称，其中客户端连接到服务器，服务器生成响应，服务器关闭连接。因此，我们将从中阅读以查看客户端发送并将我们的响应写入流，以将数据发送回客户端。总的来说，这个循环将依次处理每个连接，并且生成一系列流供我们处理。incomingTcpListenerTcpStreamTcpStreamfor

目前，我们对流的处理包括调用 terminate 如果流有任何错误，我们的程序;如果没有任何错误，则程序打印一条消息。我们将为 Success case 添加更多功能下一个列表。我们可能从方法中收到错误的原因当客户端连接到服务器时，我们实际上并没有迭代连接。相反，我们正在迭代连接尝试。这连接不成功的原因有很多，其中许多特定于作系统。例如，许多作系统对他们可以支持的同时打开的连接数;新建连接超出该数量的尝试将产生错误，直到某些打开的连接已关闭。unwrapincoming

让我们尝试运行这段代码吧！在终端中调用，然后在 Web 浏览器中加载 127.0.0.1：7878。浏览器应显示错误消息例如“Connection reset”，因为服务器当前没有发回任何数据。但是，当您查看终端时，您应该会看到几条消息是当浏览器连接到服务器时打印的！cargo run

     Running `target/debug/hello`
Connection established!
Connection established!
Connection established!

有时，您会看到为一个浏览器请求打印了多条消息;这原因可能是浏览器正在请求该页面以及请求其他资源，favicon.ico例如 browser （浏览器）选项卡。

也可能是浏览器正在尝试连接到服务器多个次，因为服务器没有响应任何数据。外出时 of 范围，并在循环结束时删除，则连接将关闭为实现的一部分。浏览器有时会处理已关闭的连接，因为问题可能是暂时的。重要的因素是我们已成功获取 TCP 连接的句柄！streamdrop

请记住按 - 当您已完成运行特定版本的代码。然后重新启动程序在进行每组代码更改后调用命令以确保您运行的是最新的代码。ctrlccargo run

读取请求

让我们实现从浏览器读取请求的功能！自将先获得连接然后再采取一些行动的担忧分开有了 CONNECTION，我们将启动一个用于处理 CONNECTIONS 的新函数。在这个新功能，我们将从 TCP 流中读取数据，并且打印它，以便我们可以看到从浏览器发送的数据。将代码更改为如示例 20-2 所示。handle_connection

文件名： src/main.rs

use std::{
    io::{prelude::*, BufReader},
    net::{TcpListener, TcpStream},
};

fn main() {
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        handle_connection(stream);
    }
}

fn handle_connection(mut stream: TcpStream) {
    let buf_reader = BufReader::new(&stream);
    let http_request: Vec<_> = buf_reader
        .lines()
        .map(|result| result.unwrap())
        .take_while(|line| !line.is_empty())
        .collect();

    println!("Request: {http_request:#?}");
}

示例 20-2：从 TcpStream 读取并打印数据

我们将和带入范围以获取访问权限添加到允许我们从流中读取和写入的 trait 和类型。在函数的循环中，而不是打印一条消息，指出我们做了一个 connection，我们现在调用新函数并将传递给它。std::io::preludestd::io::BufReaderformainhandle_connectionstream

在该函数中，我们创建一个新实例，该实例将对 . 通过管理调用添加缓冲添加到 trait 方法中。handle_connectionBufReaderstreamBufReaderstd::io::Read

我们创建一个名为的变量来收集请求的行数浏览器发送到我们的服务器。我们表明我们想要收集这些行。http_requestVec<_>

BufReader实现 trait，该 trait 提供方法。该方法在看到换行符时通过拆分数据流返回一个迭代器字节。为了得到每个，我们映射和每个。如果数据不是有效的 UTF-8 或存在问题，则可能是错误从流中读取。同样，生产程序应该处理这些错误更优雅地，但我们选择在单纯。std::io::BufReadlineslinesResult<String, std::io::Error>StringunwrapResultResult

浏览器通过发送两个换行符来表示 HTTP 请求的结束字符，因此要从流中获取一个请求，我们采用行 until 我们得到一行是空字符串。将行收集到 vector，我们使用漂亮的调试格式将它们打印出来，以便我们可以获取查看 Web 浏览器发送到我们服务器的说明。

让我们试试这段代码吧！启动程序并在 Web 浏览器中发出请求再。请注意，我们仍然会在浏览器中看到一个错误页面，但是我们的程序在终端中的输出现在将类似于：

$ cargo run
   Compiling hello v0.1.0 (file:///projects/hello)
    Finished dev [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/hello`
Request: [
    "GET / HTTP/1.1",
    "Host: 127.0.0.1:7878",
    "User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:99.0) Gecko/20100101 Firefox/99.0",
    "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
    "Accept-Language: en-US,en;q=0.5",
    "Accept-Encoding: gzip, deflate, br",
    "DNT: 1",
    "Connection: keep-alive",
    "Upgrade-Insecure-Requests: 1",
    "Sec-Fetch-Dest: document",
    "Sec-Fetch-Mode: navigate",
    "Sec-Fetch-Site: none",
    "Sec-Fetch-User: ?1",
    "Cache-Control: max-age=0",
]

根据您的浏览器，您可能会得到略有不同的输出。既然我们正在打印请求数据，我们可以看到为什么我们会获得多个连接通过查看第一行中 next 的路径，从一个浏览器请求请求。如果重复的连接都是请求 /，则我们知道浏览器正在尝试获取 / 重复，因为它没有得到响应从我们的计划。GET

让我们分解这些请求数据，以了解浏览器的要求我们的计划。

仔细观察 HTTP 请求

HTTP 是一种基于文本的协议，请求采用以下格式：

Method Request-URI HTTP-Version CRLF
headers CRLF
message-body

第一行是请求行，其中包含有关客户端正在请求。请求行的第一部分指示正在使用的方法，例如 or ，它描述客户端如何进行这个请求。我们的客户使用了一个请求，这意味着它正在请求信息。GETPOSTGET

请求行的下一部分是 /，它表示 Uniform Resource 客户端请求的标识符 （URI）：URI 几乎但不完全是与统一资源定位符 （URL） 相同。URI 之间的区别和 URLs 对于我们在本章中的目的并不重要，但 HTTP 规范使用术语 URI，因此我们可以在这里将 URL 替换为 URI。

最后一部分是客户端使用的 HTTP 版本，然后是请求行以 CRLF 序列结尾。（CRLF 代表回车和换行，这些是打字机时代的术语！CRLF 序列也可以是编写为，其中是回车符，是换行符。这 CRLF 序列将请求行与其余请求数据分开。请注意，打印 CRLF 时，我们会看到一个新行 start 而不是。\r\n\r\n\r\n

查看到目前为止我们从运行程序中收到的请求行数据，我们看到是方法，/ 是请求 URI，是版本。GETHTTP/1.1

在请求行之后，从以后开始的其余行是头。请求没有正文。Host:GET

尝试从其他浏览器发出请求或请求其他浏览器 address，例如 127.0.0.1：7878/test，以查看请求数据的变化情况。

现在我们知道浏览器在请求什么，让我们发回一些数据！

编写响应

我们将实现响应客户端请求发送数据。响应采用以下格式：

HTTP-Version Status-Code Reason-Phrase CRLF
headers CRLF
message-body

第一行是状态行，其中包含 response，一个汇总请求结果的数字状态代码，以及一个 reason 短语，用于提供状态代码的文本描述。在 CRLF 序列是任何标头、另一个 CRLF 序列和响应。

下面是一个使用 HTTP 版本 1.1 的响应示例，其状态代码为 200，一个 OK 原因短语，没有标题，也没有正文：

HTTP/1.1 200 OK\r\n\r\n

状态代码 200 是标准成功响应。文本很小成功的 HTTP 响应。让我们将此写入流中，作为我们对请求成功！从函数中删除打印请求数据的内容，并将其替换为示例 20-3.handle_connectionprintln!

文件名： src/main.rs

use std::{
    io::{prelude::*, BufReader},
    net::{TcpListener, TcpStream},
};

fn main() {
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        handle_connection(stream);
    }
}

fn handle_connection(mut stream: TcpStream) {
    let buf_reader = BufReader::new(&stream);
    let http_request: Vec<_> = buf_reader
        .lines()
        .map(|result| result.unwrap())
        .take_while(|line| !line.is_empty())
        .collect();

    let response = "HTTP/1.1 200 OK\r\n\r\n";

    stream.write_all(response.as_bytes()).unwrap();
}

示例 20-3：将一个小小的成功 HTTP 响应写入溪流

第一个新行定义保存 success 的变量消息的数据。然后我们调用 our 来转换字符串 data 设置为 bytes。方法 on 接受 a 并发送这些字节直接通过连接。因为作可能会失败，我们会像以前一样对任何错误结果使用。同样，在真实的应用程序，您将在此处添加错误处理。responseas_bytesresponsewrite_allstream&[u8]write_allunwrap

通过这些更改，让我们运行代码并发出请求。我们不再是将任何数据打印到终端，因此我们不会看到除 Cargo 的输出。在 Web 浏览器中加载 127.0.0.1：7878 时，应获取空白页而不是错误。您刚刚手动编码接收 HTTP 请求并发送响应！

返回真实的 HTML

让我们实现返回多个空白页的功能。创造新文件hello.html项目目录的根目录中，而不是 src 目录中。您可以输入任何您想要的 HTML;示例 20-4 显示了一个可能性。

文件名： hello.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Hello!</title>
  </head>
  <body>
    <h1>Hello!</h1>
    <p>Hi from Rust</p>
  </body>
</html>

示例 20-4：在响应

这是一个最小的 HTML5 文档，带有一个标题和一些文本。要返回此当收到请求时，我们将修改为如示例 20-5 所示，要读取 HTML 文件，请将其作为正文添加到响应中，并发送它。handle_connection

文件名： src/main.rs

use std::{
    fs,
    io::{prelude::*, BufReader},
    net::{TcpListener, TcpStream},
};
// --snip--

fn main() {
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        handle_connection(stream);
    }
}

fn handle_connection(mut stream: TcpStream) {
    let buf_reader = BufReader::new(&stream);
    let http_request: Vec<_> = buf_reader
        .lines()
        .map(|result| result.unwrap())
        .take_while(|line| !line.is_empty())
        .collect();

    let status_line = "HTTP/1.1 200 OK";
    let contents = fs::read_to_string("hello.html").unwrap();
    let length = contents.len();

    let response =
        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");

    stream.write_all(response.as_bytes()).unwrap();
}

示例 20-5：将 hello.html 的内容作为响应的正文

我们已添加到语句中，以引入标准库的 filesystem 模块添加到作用域中。用于将文件内容读取到字符串应该看起来很熟悉;我们在第 12 章阅读内容时使用了它示例 12-4 中 I/O 项目的文件。fsuse

接下来，我们使用将文件的内容添加为成功的正文响应。为了确保 HTTP 响应有效，我们添加了标头它被设置为响应正文的大小，在本例中为 .format!Content-Lengthhello.html

在浏览器中运行此代码并加载 127.0.0.1：7878;你应该会看到你的 HTML 被渲染了！cargo run

目前，我们忽略了 request 数据，只发送无条件地返回 HTML 文件的内容。这意味着，如果您尝试在浏览器中请求 127.0.0.1：7878/something-else，您仍然会得到返回相同的 HTML 响应。目前，我们的服务器非常有限，并且不执行大多数 Web 服务器执行的作。我们希望自定义我们的响应，并且仅发回格式正确的 HTML 文件请求设置为 /。http_request

验证请求并选择性响应

现在，我们的 Web 服务器将返回文件中的 HTML，无论客户请求。让我们添加功能来检查浏览器是否在返回 HTML 文件之前请求 /，并在返回 HTML 文件时返回错误（如果 browser 请求任何其他内容。为此，我们需要修改，如示例 20-6 所示。此新代码检查请求的内容 received 根据我们知道的 / 请求 look like 和 adds 和 blocks 来区别对待请求。handle_connectionifelse

文件名： src/main.rs

use std::{
    fs,
    io::{prelude::*, BufReader},
    net::{TcpListener, TcpStream},
};

fn main() {
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        handle_connection(stream);
    }
}
// --snip--

fn handle_connection(mut stream: TcpStream) {
    let buf_reader = BufReader::new(&stream);
    let request_line = buf_reader.lines().next().unwrap().unwrap();

    if request_line == "GET / HTTP/1.1" {
        let status_line = "HTTP/1.1 200 OK";
        let contents = fs::read_to_string("hello.html").unwrap();
        let length = contents.len();

        let response = format!(
            "{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"
        );

        stream.write_all(response.as_bytes()).unwrap();
    } else {
        // some other request
    }
}

示例 20-6：以不同方式处理 / 不同于的请求其他请求

我们只看 HTTP 请求的第一行，所以而不是将整个请求读取到一个 vector 中，我们调用以获取 iterator 中的第一项。第一个处理和如果迭代器没有项，则停止程序。第二个处理 and 与添加的示例 20-2.nextunwrapOptionunwrapResultunwrapmap

接下来，我们检查 the 以查看它是否等于 GET 的请求行请求添加到 / 路径。如果是这样，则块返回 HTML 文件。request_lineif

如果 不等于 / 路径的 GET 请求，则表示我们收到了其他请求。我们将向回应所有其他请求的时刻。request_lineelse

现在运行此代码并请求 127.0.0.1：7878;您应该在 hello.html 中获取 HTML。如果您发出任何其他请求，例如 127.0.0.1：7878/something-else，您将收到与您在运行示例 20-1 和示例 20-2 中的代码时看到。

现在让我们将示例 20-7 中的代码添加到块中以返回响应状态代码为 404，这表示请求的内容为未找到。我们还将返回一些 HTML，以便页面在浏览器中呈现指示对最终用户的响应。else

文件名： src/main.rs

use std::{
    fs,
    io::{prelude::*, BufReader},
    net::{TcpListener, TcpStream},
};

fn main() {
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        handle_connection(stream);
    }
}

fn handle_connection(mut stream: TcpStream) {
    let buf_reader = BufReader::new(&stream);
    let request_line = buf_reader.lines().next().unwrap().unwrap();

    if request_line == "GET / HTTP/1.1" {
        let status_line = "HTTP/1.1 200 OK";
        let contents = fs::read_to_string("hello.html").unwrap();
        let length = contents.len();

        let response = format!(
            "{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"
        );

        stream.write_all(response.as_bytes()).unwrap();
    // --snip--
    } else {
        let status_line = "HTTP/1.1 404 NOT FOUND";
        let contents = fs::read_to_string("404.html").unwrap();
        let length = contents.len();

        let response = format!(
            "{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"
        );

        stream.write_all(response.as_bytes()).unwrap();
    }
}

示例 20-7：使用状态码 404 和错误页面（如果请求了 / 以外的任何内容）

在这里，我们的响应有一个状态行，其中状态代码为 404 和原因短语。响应的正文将是文件 404.html 中的 HTML。您需要在错误hello.html旁边创建一个 404.html 文件页;同样，请随意使用您想要的任何 HTML 或使用示例 HTML 示例 20-8.NOT FOUND

文件名： 404.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Hello!</title>
  </head>
  <body>
    <h1>Oops!</h1>
    <p>Sorry, I don't know what you're asking for.</p>
  </body>
</html>

示例 20-8：要发回的页面的示例内容具有任何 404 响应

进行这些更改后，请再次运行您的服务器。请求 127.0.0.1：7878 应返回 hello.html 的内容，任何其他请求（如 127.0.0.1：7878/foo）应返回来自 404.html 的错误 HTML。

一点重构

目前 and 块有很多重复：它们都是读取文件并将文件内容写入流。唯一的区别在于 Status 行和 filename。让我们让代码更通过将这些差异拉出单独的 AND 行来简洁它将 status 行和 filename 的值分配给 variables; 然后，我们可以在代码中无条件地使用这些变量来读取文件并编写响应。示例 20-9 显示了将大和块。ifelseifelseifelse

文件名： src/main.rs

use std::{
    fs,
    io::{prelude::*, BufReader},
    net::{TcpListener, TcpStream},
};

fn main() {
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        handle_connection(stream);
    }
}
// --snip--

fn handle_connection(mut stream: TcpStream) {
    // --snip--
    let buf_reader = BufReader::new(&stream);
    let request_line = buf_reader.lines().next().unwrap().unwrap();

    let (status_line, filename) = if request_line == "GET / HTTP/1.1" {
        ("HTTP/1.1 200 OK", "hello.html")
    } else {
        ("HTTP/1.1 404 NOT FOUND", "404.html")
    };

    let contents = fs::read_to_string(filename).unwrap();
    let length = contents.len();

    let response =
        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");

    stream.write_all(response.as_bytes()).unwrap();
}

示例 20-9：将 if 和 else 块重构为仅包含两种情况之间不同的代码

现在，and 块仅返回状态行和文件名;然后我们使用解构来分配这些两个值添加到语句中使用模式，如第 18 章所述。ifelsestatus_linefilenamelet

以前复制的代码现在位于 and 块之外，使用和变量。这样更容易看到这两种情况之间的差异，这意味着我们只有一个地方可以如果我们想改变文件读取和响应写入的方式，请更新代码工作。示例 20-9 中代码的行为将与示例 20-7.ifelsestatus_linefilename

棒！我们现在有一个简单的 Web 服务器，大约有 40 行 Rust 代码使用内容页面响应一个请求，并响应所有其他请求请求，响应为 404。

目前，我们的服务器在单个线程中运行，这意味着它只能为一个请求。让我们通过模拟一些慢请求。然后我们将修复它，以便我们的服务器可以在一次。

Rust 编程语言