原文:
annas-archive.org/md5/f8130c086c32d8a769f8fc5df1fb7bb7译者:飞龙
第十三章:使用 Rust 构建 Web 应用程序
在本章中,我们将探讨使用 Rust 构建网络应用。我们将了解使用静态类型系统构建网络应用时的好处,以及编译语言的速度。我们还将探索 Rust 的强类型 HTTP 库,并通过练习构建一个 URL 缩短器。在此之后,我们将研究一个非常流行的框架 Actix-web,并使用它构建一个书签 API 服务器。
本章将涵盖以下主题:
-
Rust 中的网络应用
-
使用 Hyper Crate 构建 URL 缩短器
-
网络框架的需求
-
理解 Actix-web 框架
-
使用 Actix-web 构建 HTTP Rest API
Rust 中的网络应用
“程序最重要的属性是它是否实现了用户的意图。”
– C. A. R. 霍尔
低级语言通常难以同时让开发者使用它编写网络应用并提供动态语言那样的高级人机工程学。然而,使用 Rust 则恰恰相反。用 Rust 开发网络应用与动态语言如 Ruby 或 Python 的体验相似,这得益于其高级抽象。
尽管在动态语言中开发的网络应用可以走得很远,但许多开发者发现,当他们的代码库达到大约 10 万行代码时,他们开始看到动态语言的脆弱本质。随着你做的每一个小改动,你都需要有测试来告诉你应用程序的哪些部分受到影响。随着应用程序的增长,在测试和更新方面,它变成了一个打地鼠的情况。
在像 Rust 这样的静态类型语言中构建网络应用是另一种层次的经验。在这里,你可以在代码编译时进行检查,从而大大减少你需要编写的单元测试数量。你也不需要像动态语言那样运行时(如运行 GC 的解释器)的开销。使用静态类型语言编写的网络应用可以编译为一个单一的静态二进制文件,只需最少的设置即可部署。此外,你从类型系统中获得速度和准确性的保证,并且在代码重构期间,编译器提供了大量帮助。Rust 给你所有这些保证,同时保持了动态语言的高层感觉。
网络应用主要位于应用层协议之上,并使用 HTTP 协议进行通信。HTTP 是一种无状态协议,其中每个消息要么是客户端或服务器发送的请求,要么是响应。HTTP 协议中的消息由头部和有效负载组成。头部提供了 HTTP 消息的上下文信息,例如其来源或有效负载的长度,而有效负载包含实际数据。HTTP 是一种基于文本的协议,我们通常使用库来执行将字符串解析为适当的 HTTP 消息的繁重工作。这些库进一步用于在其之上构建高级抽象,例如 Web 框架。
在 Rust 中,我们使用hypercrate 来使用 HTTP,我们将在下一节中对其进行探讨。
使用 Hyper 的强类型 HTTP
hypercrate 可以解析 HTTP 消息,并具有优雅的设计,专注于强类型 API。它被设计为原始 HTTP 请求的类型安全抽象,与 HTTP 库中的常见主题相反:将一切描述为字符串。例如,Hyper 中的 HTTP 状态码被定义为枚举,例如,类型StatusCode。对于几乎所有可以强类型化的内容,例如 HTTP 方法、MIME 类型、HTTP 头部等,都是如此。
Hyper 将客户端和服务器功能分别拆分为独立的模块。客户端允许你使用可配置的请求体、头部和其他低级配置来构建和发送 HTTP 请求。服务器端允许你打开监听套接字并将其请求处理器附加到它。然而,它不包括任何请求路由处理器实现——这留给了 Web 框架。它被设计成作为构建更高层次 Web 框架的基础 crate。它底层使用相同的tokio和futures异步抽象,因此性能非常出色。
在其核心,Hyper 具有Service特质概念:
pub trait Service {
type ReqBody: Payload;
type ResBody: Payload;
type Error: Into<Box<dyn StdError + Send + Sync>>;
type Future: Future<Item = Response<Self::ResBody>, Error = Self::Error>;
fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future;
}
Service特质代表一种处理来自任何客户端发送的 HTTP 请求并返回Response(一个 future)的类型。该特质的核心 API,类型需要实现的是call方法,它接受一个参数化泛型类型Body的Request,并返回一个解析为参数化关联类型ResBody的Response的Future。我们不需要手动实现这个特质,因为 Hyper 包含一系列可以为你实现Service特质的工厂方法。你只需要提供一个函数,该函数接受 HTTP 请求并返回响应。
在下一节中,我们将探讨 hyper 的客户端和服务器 API。让我们从从头开始构建 URL 缩短器来探索服务器 API。
Hyper 服务器 API——构建 URL 缩短器
在本节中,我们将构建一个 URL 缩短服务器,该服务器公开一个/shorten端点。此端点接受一个包含要缩短的 URL 的POST请求。让我们通过运行cargo new hyperurl并使用以下依赖项在Cargo.toml中启动一个新的项目:
# hyperurl/Cargo.toml
[dependencies]
hyper = "0.12.17"
serde_json = "1.0.33"
futures = "0.1.25"
lazy_static = "1.2.0"
rust-crypto = "0.2.36"
log = "0.4"
pretty_env_logger = "0.3"
我们将命名我们的 URL 缩短服务器为hyperurl。URL 缩短服务是一种提供为任何给定 URL 创建更短 URL 的功能的服务。当你有一个非常长的 URL 时,与某人分享它变得很麻烦。今天存在许多 URL 缩短服务,例如bit.ly。如果你使用过 Twitter,用户在推文中经常使用短 URL,以节省空间。
这是我们的main.rs中的初始实现:
// hyperurl/src/main.rs
use log::{info, error};
use std::env;
use hyper::Server;
use hyper::service::service_fn;
use hyper::rt::{self, Future};
mod shortener;
mod service;
use crate::service::url_service;
fn main() {
env::set_var("RUST_LOG","hyperurl=info");
pretty_env_logger::init();
let addr = "127.0.0.1:3002".parse().unwrap();
let server = Server::bind(&addr)
.serve(|| service_fn(url_service))
.map_err(|e| error!("server error: {}", e));
info!("URL shortener listening on http://{}", addr);
rt::run(server);
}
在main中,我们创建了一个Server实例,并将其绑定到我们的回环地址和端口号字符串"127.0.0.1:3002"。这返回了一个 builder 实例,我们在其中调用serve,然后传递实现Service特质的函数url_service。函数url_service将Request映射到Response的 future。service_fn是一个具有以下签名的工厂函数:
pub fn service_fn<F, R, S>(f: F) -> ServiceFn<F, R> where
F: Fn(Request<R>) -> S,
S: IntoFuture,
如您所见,F 需要是一个 Fn 闭包,
我们的url_service函数实现了Service特质。接下来,让我们看看service.rs中的代码:
// hyperurl/src/service.rs
use std::sync::RwLock;
use std::collections::HashMap;
use std::sync::{Arc};
use std::str;
use hyper::Request;
use hyper::{Body, Response};
use hyper::rt::{Future, Stream};
use lazy_static::lazy_static;
use crate::shortener::shorten_url;
type UrlDb = Arc<RwLock<HashMap<String, String>>>;
type BoxFut = Box<Future<Item = Response<Body>, Error = hyper::Error> + Send>;
lazy_static! {
static ref SHORT_URLS: UrlDb = Arc::new(RwLock::new(HashMap::new()));
}
pub(crate) fn url_service(req: Request<Body>) -> BoxFut {
let reply = req.into_body().concat2().map(move |chunk| {
let c = chunk.iter().cloned().collect::<Vec<u8>>();
let url_to_shorten = str::from_utf8(&c).unwrap();
let shortened_url = shorten_url(url_to_shorten);
SHORT_URLS.write().unwrap().insert(shortened_url, url_to_shorten.to_string());
let a = &*SHORT_URLS.read().unwrap();
Response::new(Body::from(format!("{:#?}", a)))
});
Box::new(reply)
}
此模块公开一个名为url_service的单个函数,它实现了Service特质。我们的url_service方法通过接受一个Request<Body>类型的 req 并返回一个位于Box之后的 future 来实现call方法。
接下来是我们的shortener模块:
// hyperurl/src/shortener.rs
use crypto::digest::Digest;
use crypto::sha2::Sha256;
pub(crate) fn shorten_url(url: &str) -> String {
let mut sha = Sha256::new();
sha.input_str(url);
let mut s = sha.result_str();
s.truncate(5);
format!("https://u.rl/{}", s)
}
我们的shorten_url函数接受一个要缩短的 URL 作为&str。然后它计算 URL 的 SHA-256 哈希值并将其截断为长度为五的字符串。这显然不是真正的 URL 缩短器的工作方式,也不是一个可扩展的解决方案。然而,对于我们的演示目的来说,这已经足够了。
让我们试一试:
我们的服务器正在运行。在这个时候,我们可以通过 curl 发送 POST 请求。我们将通过构建一个用于向此服务器发送 URL 以缩短的命令行客户端来实现这一点。
虽然 Hyper 推荐用于复杂的 HTTP 应用程序,但每次创建处理程序服务、注册它并在运行时中运行它都相当繁琐。通常,为了构建需要执行几个GET请求的小型工具,如 CLI 应用程序,这会显得有些过度。幸运的是,我们有一个名为reqwest的 hyper 的包装器,它具有自己的观点。正如其名所示,它受到了 Python 的 Requests 库的启发。我们将使用它来构建我们的 hyperurl 客户端,该客户端发送 URL 缩短请求。
hyper 作为客户端 – 构建 URL 缩短客户端
现在我们已经准备好了 URL 缩短服务,让我们探索 hyper 的客户端。尽管我们可以构建一个用于缩短 URL 的 Web UI,但我们将保持简单,并构建一个 命令行界面 (CLI) 工具。CLI 可以用来传递任何需要缩短的 URL。作为回应,我们将从我们的 hyperurl 服务器获得缩短后的 URL。
虽然 hyper 推荐用于构建复杂网络应用程序,但每次需要创建处理程序服务、注册它并在运行时实例中运行它时,都需要进行大量设置。当构建较小的工具,如需要执行几个 GET 请求的 CLI 应用程序时,所有这些步骤都显得过于繁琐。幸运的是,我们有一个方便的 hyper 包装 crate,名为 reqwest,它抽象了 hyper 的客户端 API。正如其名所示,它受到了 Python 的 Requests 库的启发。
让我们通过在 Cargo.toml 文件中添加以下依赖项来运行 cargo new shorten 创建一个新的项目:
# shorten/Cargo.toml
[dependencies]
quicli = "0.4"
structopt = "0.2"
reqwest = "0.9"
serde = "1"
为了构建 CLI 工具,我们将使用 quicli 框架,这是一个高质量 crate 的集合,有助于构建 CLI 工具。structopt crate 与 quicli 一起使用,而 serde crate 则用于 structopt crate 的 derive 宏。为了向我们的 hyperurl 服务器发送 POST 请求,我们将使用 reqwest crate。
我们的 main.rs 文件内部有以下代码:
// shorten/src/main.rs
use quicli::prelude::*;
use structopt::StructOpt;
const CONN_ADDR: &str = "127.0.0.1:3002";
/// This is a small CLI tool to shorten urls using the hyperurl
/// url shortening service
#[derive(Debug, StructOpt)]
struct Cli {
/// The url to shorten
#[structopt(long = "url", short = "u")]
url: String,
// Setting logging for this CLI tool
#[structopt(flatten)]
verbosity: Verbosity,
}
fn main() -> CliResult {
let args = Cli::from_args();
println!("Shortening: {}", args.url);
let client = reqwest::Client::new();
let mut res = client
.post(&format!("http://{}/shorten", CONN_ADDR))
.body(args.url)
.send()?;
let a: String = res.text().unwrap();
println!("http://{}", a);
Ok(())
}
在我们的 hyperurl 服务器仍然运行的情况下,我们将打开一个新的终端窗口,并使用 cargo run -- --url https://rust-lang.org 调用 shorten:
让我们转到浏览器,使用缩短后的 URL,即 http://127.0.0.1:3002/abf27:
在探索了 hyper 之后,让我们提高一点层次。在下一节中,我们将探索基于 actix 包中 actor 模型实现的快速网络应用程序框架 Actix-web。但是,首先让我们谈谈为什么我们需要网络框架。
网络框架
在我们开始探索 actix-web 之前,我们需要了解一些动机,即为什么我们最初需要网络框架。正如我们许多人所知,网络是一个复杂且不断发展的空间。在编写网络应用程序时,有许多细节需要处理。你需要设置路由规则和认证策略。除此之外,随着应用程序的发展,还有一些最佳实践和类似的模式,如果你不使用网络框架,你将不得不重复实现。
每次自己构建网络应用程序时,都需要重新发明这些网络应用程序的基础属性,这相当繁琐。一个具体的例子是,当你在应用程序中提供不同的路由时。在一个从头开始构建的网络应用程序中,你必须从请求中解析资源路径,对其进行一些匹配,并对请求采取行动。网络框架通过提供 DSLs 自动化路由和路由处理程序的匹配,允许你以更干净的方式配置路由规则。网络框架还抽象了围绕构建网络应用程序的所有最佳实践、常见模式和惯例,为开发者提供一个先发优势,使他们能够专注于业务逻辑,而不是重新发明已经解决的问题的解决方案。
Rust 社区最近出现了很多正在开发中的网络框架,如 Tower、Tide、Rocket、actix-web、Gotham 等。在撰写本书时,功能最丰富且最活跃的框架是 Rocket 和 actix-web。虽然 Rocket 非常简洁且是一个完善的框架,但它需要 Rust 编译器的 nightly 版本。不过,随着 Rocket 所依赖的 API 的稳定,这个限制很快就会被移除。目前它的直接竞争对手是 actix-web,它运行在稳定的 Rust 上,并且与 Rocket 框架提供的用户体验非常接近。接下来我们将介绍 actix-web。
Actix-web 基础
Actix-web 框架建立在 actix crate 实现的 actor 模型之上,我们已经在第七章“高级概念”中介绍过。Actix-web 自称是一个小巧、快速且实用的 HTTP 网络框架。它主要是一个异步框架,内部依赖于 tokio 和 futures crate,同时也提供了同步 API,并且这两个 API 可以无缝组合。
使用 actix-web 编写的任何网络应用程序的入口点是 App 结构体。在 App 实例上,我们可以配置各种路由处理程序和中间件。我们还可以使用任何需要跨请求/响应维护的状态初始化我们的 App。App 上提供的路由处理程序实现了 Handler 特性,它们只是将请求映射到响应的函数。它们还可以包括请求过滤器,根据谓词禁止对特定路由的访问。
Actix-web 内部会启动多个工作线程,每个线程都有自己的 tokio 运行时。
基本概念介绍完毕,现在让我们直接进入主题,通过 Actix-web 实现一个 REST API 服务器。
使用 Actix-web 构建 Bookmarks API
我们将创建一个 REST API 服务器,允许您存储您希望稍后阅读的任何博客或网站的收藏夹和链接。我们将我们的服务器命名为 linksnap。 让我们通过运行 cargo new linksnap 创建一个新的项目。在这个实现中,我们不会为发送到我们的 API 的任何链接使用数据库进行持久化,而将简单地使用内存中的 HashMap 来存储我们的条目。这意味着每次我们的服务器重启时,所有存储的收藏夹都将被删除。在 第十四章,在 Rust 中与数据库交互,我们将集成数据库与 linksnap,这将允许我们持久化收藏夹。
在 linksnap/ 目录下,Cargo.toml 中有以下内容:
# linksnap/Cargo.toml
[dependencies]
actix = "0.7"
actix-web = "0.7"
futures = "0.1"
env_logger = "0.5"
bytes = "0.4"
serde = "1.0.80"
serde_json = "1.0.33"
serde_derive = "1.0.80"
url = "1.7.2"
log = "0.4.6"
chrono = "0.4.6"
我们将在我们的 API 服务器中实现以下端点:
-
/links是一个GET方法,用于检索服务器上存储的所有链接列表。 -
/add是一个POST方法,用于存储链接条目并返回一个类型为LinkId的响应。这可以用来从服务器上删除链接。 -
/rm是一个DELETE方法,用于删除具有给定LinkId的链接。
我们将我们的服务器实现分为三个模块:
-
links:此模块提供了Links和Link类型,分别代表链接集合和单个链接。 -
route_handlers:此模块包含我们所有的路由处理器。 -
state:此模块包含了一个 actor 的实现以及它可以在我们的Db结构体上接收的所有消息。
从用户请求到 actor 的示例流程在 /links 端点如下:
让我们通过查看 main.rs 中的内容来了解实现:
// linksnap/src/main.rs
mod links;
mod route_handlers;
mod state;
use std::env;
use log::info;
use crate::state::State;
use crate::route_handlers::{index, links, add_link, rm_link};
use actix_web::middleware::Logger;
use actix_web::{http, server, App};
fn init_env() {
env::set_var("RUST_LOG", "linksnap=info");
env::set_var("RUST_BACKTRACE", "1");
env_logger::init();
info!("Starting http server: 127.0.0.1:8080");
}
fn main() {
init_env();
let system = actix::System::new("linksnap");
let state = State::init();
let web_app = move || {
App::with_state(state.clone())
.middleware(Logger::default())
.route("/", http::Method::GET, index)
.route("/links", http::Method::GET, links)
.route("/add", http::Method::POST, add_link)
.route("/rm", http::Method::DELETE, rm_link)
};
server::new(web_app).bind("127.0.0.1:8080").unwrap().start();
let _ = system.run();
}
在 main 中,我们首先调用 init_env,这为我们设置从服务器获取日志的环境,打开 RUST_BACKTRACE 变量以打印任何错误的详细跟踪,并通过调用 env_logger::init() 初始化我们的日志记录器。然后我们创建我们的系统 actor,它是 actor 模型中所有 actor 的父 actor。然后我们通过调用 State::init() 创建我们的服务器状态并将其存储在 state 中。这将在 state.rs 中封装我们的内存数据库 actor 类型 Db。我们稍后会详细介绍。
然后,我们通过调用 App::with_state 在闭包中创建我们的 App 实例,从而传递我们的应用程序 state 的克隆。这里的 clone 调用很重要,因为我们需要在多个 actix 工作线程之间共享单个共享状态。Actix-web 内部使用新的 App 实例启动多个线程来处理请求,并且每次调用此状态都将有自己的应用程序状态副本。如果我们不共享单个真相来源的引用,那么每个 App 都将有自己的 HashMap 条目副本,这是我们不想看到的。
然后,我们通过传递一个 Logger 来使用 middleware 方法将我们的 App 链接起来。这样,当客户端击中我们配置的任何一个端点时,都会记录任何请求。然后我们添加了一堆 route 方法调用。route 方法接受一个作为字符串的 HTTP 路径,一个 HTTP 方法,以及一个将 HttpRequest 映射到 HttpResponse 的 handler 函数。我们稍后会探讨 handler 函数。
在配置并存储 web_app 实例后,我们将其传递给 server::new(),然后将其绑定到地址字符串 "127.0.0.1:8080"。然后我们调用 start 来在一个新的 Arbiter 实例中启动应用,这只是一个新的线程。根据 actix,Arbiter 是运行 actors 并可以访问事件循环的线程。最后,我们通过调用 system.run() 来运行我们的系统 actor。run 方法内部启动一个 tokio 运行时并启动所有 arbiter 线程。
接下来,让我们看看 route_handlers.rs 中的路由处理器。此模块定义了我们服务器实现中可用的所有类型的路由:
// linksnap/src/route_handlers.rs
use actix_web::{Error, HttpRequest, HttpResponse};
use crate::state::{AddLink, GetLinks, RmLink};
use crate::State;
use actix_web::AsyncResponder;
use actix_web::FromRequest;
use actix_web::HttpMessage;
use actix_web::Query;
use futures::Future;
type ResponseFuture = Box<Future<Item = HttpResponse, Error = Error>>;
macro_rules! server_err {
($msg:expr) => {
Err(actix_web::error::ErrorInternalServerError($msg))
};
}
首先,我们有一堆导入,然后定义了几个辅助类型。ResponseFuture 是一个方便的类型别名,用于一个解析为 HttpResponse 的装箱 Future。然后我们有一个名为 server_err! 的辅助宏,它返回一个带有给定描述的 actix_web::error 类型。我们使用这个宏作为在客户端请求处理失败时返回错误的方便方式。
接下来,我们拥有处理 / 端点 get 请求的最简单路由处理器:
linksnap/src/route_handlers.rs
pub fn index(_req: HttpRequest<State>) -> HttpResponse {
HttpResponse::from("Welcome to Linksnap API server")
}
index 函数接受一个 HttpRequest 并简单地返回一个由字符串构造的 HttpResponse。HttpRequest 类型可以参数化任何类型。默认情况下,它是一个 ()。对于我们的路由处理器,我们将其参数化为我们的 State 类型。这个 State 封装了我们的内存数据库,该数据库作为 actor 实现。State 是 Addr<Db> 的包装器,它是我们的 Db actor 的地址。
这是一个对我们内存数据库的引用。我们将使用它来向我们的内存数据库发送消息以插入、删除或获取链接。我们稍后会探讨这些 API。让我们看看同一文件中的其他处理器:
// linksnap/src/route_handlers.rs
pub fn add_link(req: HttpRequest<State>) -> ResponseFuture {
req.json()
.from_err()
.and_then(move |link: AddLink| {
let state = req.state().get();
state.send(link).from_err().and_then(|e| match e {
Ok(_) => Ok(HttpResponse::Ok().finish()),
Err(_) => server_err!("Failed to add link"),
})
})
.responder()
}
我们的 add_link 函数处理添加链接的 POST 请求。此处理器期望一个具有以下格式的 JSON 主体:
{
title: "Title of the link or bookmark",
url: "The URL of the link"
}
在这个函数中,我们首先通过调用req.json()获取请求体作为 JSON。这返回一个 future。然后我们使用from_err方法将来自 json 方法的任何错误映射到与 actix 兼容的错误。json方法可以从请求的有效负载中提取类型化信息,因此返回一个JsonBody<T> future。这个T由下一个方法链and_then推断为AddLink,我们将解析的值发送到我们的Db演员。向我们的演员发送消息可能会失败,所以如果发生这种情况,我们再次匹配返回的值。在Ok的情况下,我们回复一个空的 HTTP 成功响应,否则我们使用server_err!宏传递错误描述来失败。
接下来,我们有一个"/links"端点:
// linksnap/src/route_handlers.rs
pub fn links(req: HttpRequest<State>) -> ResponseFuture {
let state = &req.state().get();
state
.send(GetLinks)
.from_err()
.and_then(|res| match res {
Ok(res) => Ok(HttpResponse::Ok().body(res)),
Err(_) => server_err!("Failed to retrieve links"),
})
.responder()
}
links处理程序简单地发送一个GetLinks消息到Db演员,并在使用body方法将其发送回客户端之前返回接收到的响应。然后我们有我们的rm_link处理程序,其定义如下:
// linksnap/src/route_handlers.rs
pub fn rm_link(req: HttpRequest<State>) -> ResponseFuture {
let params: Query<RmLink> = Query::extract(&req).unwrap();
let state = &req.state().get();
state
.send(RmLink { id: params.id })
.from_err()
.and_then(|e| match e {
Ok(e) => Ok(HttpResponse::Ok().body(format!("{}", e))),
Err(_) => server_err!("Failed to remove link"),
})
.responder()
}
要删除一个链接,我们需要将链接 ID(一个i32)作为查询参数传递。rm_link方法使用方便的Query::extract方法将查询参数提取到RmLink类型中,该方法接受一个HttpRequest实例。接下来,我们获取对Db演员的引用,并向其发送一个带有 ID 的RmLink消息。我们通过使用HttpRespnse的body方法构造返回的字符串来返回回复。
这里是我们的State和Db类型在state.rs中的定义:
// linksnap/src/state.rs
use actix::Actor;
use actix::SyncContext;
use actix::Message;
use actix::Handler;
use actix_web::{error, Error};
use std::sync::{Arc, Mutex};
use crate::links::Links;
use actix::Addr;
use serde_derive::{Serialize, Deserialize};
use actix::SyncArbiter;
const DB_THREADS: usize = 3;
#[derive(Clone)]
pub struct Db {
pub inner: Arc<Mutex<Links>>
}
impl Db {
pub fn new(s: Arc<Mutex<Links>>) -> Db {
Db { inner: s }
}
}
impl Actor for Db {
type Context = SyncContext<Self>;
}
#[derive(Clone)]
pub struct State {
pub inner: Addr<Db>
}
impl State {
pub fn init() -> Self {
let state = Arc::new(Mutex::new(Links::new()));
let state = SyncArbiter::start(DB_THREADS, move || Db::new(state.clone()));
let state = State {
inner: state
};
state
}
pub fn get(&self) -> &Addr<Db> {
&self.inner
}
}
首先,我们将DB_THREADS设置为3这个值,这是我们任意选择的。我们将通过一个线程池来向内存数据库发送请求。在这种情况下,我们也可以使用一个普通的演员,但由于我们将在第十四章“使用 Rust 与数据库交互”中将其与数据库集成,我们选择了SyncArbiter线程。
接下来,我们有一个Db结构体定义,它将Links类型封装在一个线程安全的包装器Arc<Mutex<Links>>中。然后我们在其上实现Actor特质,其中我们指定关联类型Context为SyncContext<Self>。
然后,我们有一个State结构体定义,它是一个Addr<Db>,即对Db演员实例的句柄。我们还在State上定义了两个方法 - init用于创建一个新的State实例,get用于返回对Db演员句柄的引用。
接下来,我们有一系列将要发送到我们的Db演员的消息类型。我们的Db是一个演员,将接收三个消息:
GetLinks:这是由/links路由处理程序发送的,用于检索服务器上存储的所有链接。它定义如下:
// linksnap/src/state.rs
pub struct GetLinks;
impl Message for GetLinks {
type Result = Result<String, Error>;
}
impl Handler<GetLinks> for Db {
type Result = Result<String, Error>;
fn handle(&mut self, _new_link: GetLinks, _: &mut Self::Context) -> Self::Result {
Ok(self.inner.lock().unwrap().links())
}
}
首先是 GetLinks 消息,它是由 /links 路由处理器发送到 Db actor 的。为了使这成为一个 actor 消息,我们将为它实现 Message 特性。Message 特性定义了一个关联类型 Result,这是消息处理器的返回类型。接下来,我们为 Db actor 实现了参数化于消息 GetLinks 的 Handler 特性。
// linksnap/src/state.rs
pub struct GetLinks;
impl Message for GetLinks {
type Result = Result<String, Error>;
}
impl Handler<GetLinks> for Db {
type Result = Result<String, Error>;
fn handle(&mut self, _new_link: GetLinks, _: &mut Self::Context) -> Self::Result {
Ok(self.inner.lock().unwrap().links())
}
}
我们为它实现了 Message 特性,它返回所有链接的字符串作为响应。
AddLink:这是由 /add 路由处理器在客户端发送的任何新链接时发送的。它定义如下:
// linksnap/src/state.rs
#[derive(Debug, Serialize, Deserialize)]
pub struct AddLink {
pub title: String,
pub url: String
}
impl Message for AddLink {
type Result = Result<(), Error>;
}
impl Handler<AddLink> for Db {
type Result = Result<(), Error>;
fn handle(&mut self, new_link: AddLink, _: &mut Self::Context) -> Self::Result {
let mut db_ref = self.inner.lock().unwrap();
db_ref.add_link(new_link);
Ok(())
}
}
AddLink 类型具有双重功能。当实现了 Serialize 和 Deserialize 特性时,它作为一个可以从 add_link 路由的入站 json 响应体中提取的类型。其次,它还实现了 Message 特性,我们可以将其发送到我们的 Db actor。
RmLink:这是由 /rm 路由处理器发送的。它定义如下:
// linksnap/src/state.rs
#[derive(Serialize, Deserialize)]
pub struct RmLink {
pub id: LinkId,
}
impl Message for RmLink {
type Result = Result<usize, Error>;
}
impl Handler<RmLink> for Db {
type Result = Result<usize, Error>;
fn handle(&mut self, link: RmLink, _: &mut Self::Context) -> Self::Result {
let db_ref = self.get_conn()?;
Link::rm_link(link.id, db_ref.deref())
.map_err(|_| error::ErrorInternalServerError("Failed to remove links"))
}
}
这是当想要删除链接条目时发送的消息。它接收 RmLink 消息并将其转发
我们可以使用以下 curl 命令插入一个链接:
curl --header "Content-Type: application/json" \
--request POST \
--data '{"title":"rust blog","url":"https://rust-lang.org"}' \
127.0.0.1:8080/add
要查看插入的链接,我们可以发出:
curl 127.0.0.1:8080/links
要删除一个链接,给定其 Id,我们可以使用 curl 发送一个 DELETE 请求,如下所示:
curl -X DELETE 127.0.0.1:8080/rm?id=1
摘要
在本章中,我们探讨了使用 Rust 构建 Web 应用程序的很多内容,以及鉴于我们可用的优质 crate,开始使用是多么容易。作为一个编译型语言,用 Rust 编写的 Web 应用程序通常比用动态语言编写的其他框架小得多。大多数 Web 框架空间由可以占用大量 CPU 但资源效率不高的解释型动态语言主导。然而,人们使用它们,因为使用它们编写 Web 应用程序非常方便。
用 Rust 编写的 Web 应用程序在运行时占用的空间要小得多。Rust 在运行时也占用更少的内存,因为不需要解释器,这与动态语言的情况一样。使用 Rust,你可以同时获得动态语言的感受和 C 语言的性能。这对 Web 来说是一笔大交易。
在下一章中,我们将探讨 Rust 如何与数据库通信,并通过使用名为 diesel 的类型安全 对象关系映射器 (ORM) 库来为我们的 read_list 服务器添加数据持久性。
第十四章:使用 Rust 与数据库交互
在本章中,我们将讨论为什么数据库对现代应用程序至关重要。我们将介绍 Rust 生态系统中的几个 crate,这些 crate 允许与数据库交互。然后,我们将继续讨论我们在上一章中开发的 linksnap API 服务器,并通过一个方便的库将其数据库支持集成进去。这将使我们能够持久化发送到我们 API 的新书签。
在本章中,我们将涵盖以下主题:
-
使用
rusqlite进行 SQLite 集成 -
使用 Rust 与 PostgreSQL 交互
-
数据库连接池
-
使用
dieselcrate 进行对象关系映射 -
将 diesel 与 linksnap API 服务器集成
我们为什么需要数据持久化?
“有时,优雅的实现仅仅是一个函数。不是一个方法。不是一个类。不是一个框架。仅仅是一个函数。” —— 约翰·卡马克
现代应用程序通常数据密集。正如许多人所说,数据是新石油。数据库支持的服务无处不在,从社交游戏到云存储,再到电子商务,以及医疗保健等等。所有这些服务都需要正确地存储和检索数据。它们存储的数据必须易于检索,并且必须保证一致性和持久性。
数据库是构建基于数据的应用程序并提供用户期望的强大基础的解决方案。在我们用 Rust 构建涉及数据库的任何东西之前,我们需要了解一些基础知识。一般来说,数据库是一组表。表是数据组织的单元。
组织到表中的数据仅适用于关系数据库。其他数据库,如 NoSQL 和基于图的数据库,使用更灵活的文档模型来存储和组织数据。
数据被组织成逻辑实体,称为表。表通常代表现实世界中的实体。这些实体可以具有各种属性,这些属性在表中取代了列的位置。这些实体还可以与其他实体有联系。一个表中的列可以引用另一个表中的列。对任何数据库的更改都通过一个特定的 DSL(领域特定语言)执行,称为结构化查询语言(SQL)。SQL 查询还允许您使用查询子句(如 JOIN)将查询扩展到多个表。这些都是基础知识。用户与数据库支持的应用程序交互的常见模式是CRUD模式,即创建、读取、更新和删除。这些是用户在应用程序中对数据库执行的最常见操作。
SQL 是一种声明式的方法,用于在数据库上执行事务。事务是一组对数据库的修改,这些修改必须原子性地发生,或者在中间出现任何故障时根本不发生。在任何应用程序中编写数据库事务的直观方法是使用原始 SQL 查询。然而,有一种更好的方法来做这件事,它被称为对象关系映射(ORM)。这是一种使用本地语言抽象和类型访问数据库的技术,这些类型几乎与 SQL 语法和语义一一对应。语言提供了用于与 SQL 对话的高级库,允许你用它们的本地语言编写查询,然后这些查询被翻译成原始 SQL 查询。在传统的面向对象语言中,你的对象变成了会说话的 SQL 对象。这些库被称为对象关系映射器。许多这些库存在于主流语言中,如 Java 的 Hibernate、Ruby 的 Active Record、Python 的 SQLAlchemy 等。使用 ORM 可以减少在使用原始 SQL 查询时出现任何错误的可能性。然而,ORM 也受到无法将自身完全映射到语言的对象模型和数据库模型的限制。因此,ORM 库应尽量减少它们在交互数据库时提供的抽象量,并将一些部分留给原始 SQL 查询。
Rust 生态系统提供了许多高质量解决方案来管理和构建持久化应用程序。我们将在下一节中探讨其中的一些。
SQLite
SQLite 是一个非常轻量级的嵌入式数据库。它不需要特殊的数据库管理系统,你就可以使用它。SQLite 创建的数据库可以表示为文件或内存中的数据库,你不需要连接到外部远程端点或本地套接字连接来使用数据库。它服务于与传统客户端-服务器数据库引擎(如 MySQL 或 PostgreSQL)不同的目标受众,并且是应用需要本地存储数据但又要安全且高效检索的用例的首选解决方案。Android 平台是 SQLite 的重度使用者,允许移动应用程序在应用程序内存储用户的偏好或配置。它也被许多需要存储任何类型状态并保证持久性的桌面应用程序所使用。
Rust 社区为我们提供了连接和与 SQLite 数据库交互的几种选择。我们将选择 rusqlite crate,该 crate 可在 crates.io 上找到,网址为 crates.io/crates/rusqlite。此 crate 支持 SQLite 版本 3.6.8 及以上。其 API 不能被视为 ORM,但可以被视为 ORM 提供的中间层抽象,因为它有助于隐藏实际 SQLite API 的许多细节。与许多其他关系型数据库系统相比,SQLite 的类型系统是动态的。这意味着列没有类型,但每个单独的值都有类型。技术上,SQLite 将存储类和数据类型分开,但这主要是实现细节,我们可以简单地从类型的角度思考,而不会离真相太远。
rusqlite crate 提供了 FromSql 和 ToSql 特性,用于在 SQLite 和 Rust 类型之间转换对象。它还提供了以下开箱即用的实现,用于大多数标准库类型和原语:
| 描述 | SQLite | Rust |
|---|---|---|
| 空值 | NULL | rusqlite::types::Null |
| 1、2、3、4、6 或 8 字节有符号整数 | INTEGER | i32(可能截断)和 i64 |
| 8 字节 IEEE 浮点数 | REAL | f64 |
| UTF-8、UTF-16BE 或 UTF-16LE 字符串 | TEXT | String 和 &str |
| 字节字符串 | BLOB | Vec<u8> 和 &[u8] |
在掌握了 rusqlite crate 的基础知识之后,让我们看看它是如何应用的。
我们将通过运行 cargo new rusqlite_demo 来创建一个新的项目。我们的程序从标准输入接收一个格式正确的逗号分隔值(CSV)格式的书籍列表,将其存储在 SQLite 中,然后使用 SQL 查询的过滤器检索数据子集。首先,让我们创建我们的表创建和删除查询以及我们的 Book 结构体,它将存储从查询中检索到的数据:
// rusqlite_demo/src/main.rs
use std::io;
use std::io::BufRead;
use rusqlite::Error;
use rusqlite::{Connection, NO_PARAMS};
const CREATE_TABLE: &str = "CREATE TABLE books
(id INTEGER PRIMARY KEY,
title TEXT NOT NULL,
author TEXT NOT NULL,
year INTEGER NOT NULL)";
const DROP_TABLE: &str = "DROP TABLE IF EXISTS books";
#[derive(Debug)]
struct Book {
id: u32,
title: String,
author: String,
year: u16
}
我们定义了两个常量,CREATE_TABLE 和 DROP_TABLE,分别包含创建 books 表和删除它的原始 SQL 查询。然后我们有书籍结构体,它包含以下字段:
-
id: 它作为主键使用,可以在将书籍插入我们的书籍表中时区分不同的书籍 -
title: 书籍的标题 -
author: 该书的作者 -
year: 出版年份
接下来,让我们看看我们的 main 函数:
// rusqlite_demo/src/main.rs
fn main() {
let conn = Connection::open("./books").unwrap();
init_database(&conn);
insert(&conn);
query(&conn);
}
首先,我们通过调用 Connection::open 并提供一个路径,"./books",来创建当前目录中的数据库,从而打开我们的 SQLite 数据库连接。接下来,我们调用 init_database(),传递对 conn 的引用,它如下定义:
fn init_database(conn: &Connection) {
conn.execute(CREATE_TABLE, NO_PARAMS).unwrap();
}
然后,我们调用 insert 方法,传递我们的 conn。最后,我们调用 query 方法,查询我们的 books 数据库。
这是我们的 insert 函数方法:
fn insert(conn: &Connection) {
let stdin = io::stdin();
let lines = stdin.lock().lines();
for line in lines {
let elems = line.unwrap();
let elems: Vec<&str> = elems.split(",").collect();
if elems.len() == 4 {
let _ = conn.execute(
"INSERT INTO books (id, title, author, year) VALUES (?1, ?2, ?3, ?4)",
&[&elems[0], &elems[1], &elems[2], &elems[3]],
);
}
}
}
在insert中,我们首先锁定stdout,然后遍历行。每行用逗号分隔。随后,我们在conn上调用execute方法,传入一个插入查询字符串。在查询字符串中,我们使用模板变量?1、?2等,其对应的值是从elems向量中取出的。如果收集到的元素数量达到4,我们使用原始 SQL 查询插入书籍,并为模板变量提供elems Vec中的相应值。
接下来,我们的query函数定义如下:
fn query(conn: &Connection) {
let mut stmt = conn
.prepare("SELECT id, title, author, year FROM books WHERE year >= ?1")
.unwrap();
let movie_iter = stmt
.query_map(&[&2013], |row| Book {
id: row.get(0),
title: row.get(1),
author: row.get(2),
year: row.get(3),
})
.unwrap();
for movie in movie_iter.filter_map(extract_ok) {
println!("Found book {:?}", movie);
}
}
查询函数接收conn参数,我们在其上调用prepare方法,传入原始的 SQL 查询字符串。在这里,我们正在过滤那些出版年份大于给定年份的书籍。我们将这个查询存储在stmt中。接下来,我们在这个类型上调用query_map,传入一个只包含数字2013的数组引用,这个数字代表我们要过滤书籍的年份。正如你所见,这里的 API 有点不自然。query_map的第二个参数是一个闭包,它是一个Row类型。在闭包内部,我们从row实例中提取相应的字段,并从中构建一个Book实例。这返回一个迭代器,我们将其存储在movie_iter中。最后,我们遍历movie_iter,使用extract_ok辅助方法过滤任何失败的值。这个方法定义如下:
fn extract_ok(p: Result<Book, Error>) -> Option<Book> {
if p.is_ok() {
Some(p.unwrap())
} else {
None
}
}
然后,我们打印书籍。完整的代码如下:
// rusqlite_demo/src/main.rs
use std::io;
use std::io::BufRead;
use rusqlite::Error;
use rusqlite::{Connection, NO_PARAMS};
const CREATE_TABLE: &str = "CREATE TABLE IF NOT EXISTS books
(id INTEGER PRIMARY KEY,
title TEXT NOT NULL,
author TEXT NOT NULL,
year INTEGER NOT NULL)";
#[derive(Debug)]
struct Book {
id: u32,
title: String,
author: String,
year: u16,
}
fn extract_ok(p: Result<Book, Error>) -> Option<Book> {
if p.is_ok() {
Some(p.unwrap())
} else {
None
}
}
fn insert(conn: &Connection) {
let stdin = io::stdin();
let lines = stdin.lock().lines();
for line in lines {
let elems = line.unwrap();
let elems: Vec<&str> = elems.split(",").collect();
if elems.len() > 2 {
let _ = conn.execute(
"INSERT INTO books (id, title, author, year) VALUES (?1, ?2, ?3, ?4)",
&[&elems[0], &elems[1], &elems[2], &elems[3]],
);
}
}
}
fn init_database(conn: &Connection) {
conn.execute(CREATE_TABLE, NO_PARAMS).unwrap();
}
fn query(conn: &Connection) {
let mut stmt = conn
.prepare("SELECT id, title, author, year FROM books WHERE year >= ?1")
.unwrap();
let movie_iter = stmt
.query_map(&[&2013], |row| Book {
id: row.get(0),
title: row.get(1),
author: row.get(2),
year: row.get(3),
})
.unwrap();
for movie in movie_iter.filter_map(extract_ok) {
println!("Found book {:?}", movie);
}
}
fn main() {
let conn = Connection::open("./books").unwrap();
init_database(&conn);
insert(&conn);
query(&conn);
}
我们在同一目录下还有一个 books.csv 文件。我们可以通过以下命令运行它:
cargo run < books.csv
下面是程序运行后的输出:
这远非一个代表性的真实世界数据库支持的应用程序,它只是为了演示库的使用。一个真实世界的应用程序不会从标准输入读取,查询例程会有更好的错误处理。
这只是一个简要的演示,说明如何使用rusqlitecrate 通过 Rust 使用 SQLite 数据库。API 不是非常强类型,但这是我们目前唯一的选择。接下来,我们将看看 SQLite 的“大哥”——PostgreSQL 数据库管理系统。
PostgreSQL
虽然 SQLite 适合原型设计和简单的用例,但一个真正的关系型数据库管理系统可以使开发者的生活更加轻松。这样一个复杂的数据库系统是 PostgreSQL。要在 Rust 中集成 PostgreSQL,我们可以在crates.io上找到postgrescrate。它是一个本地的 Rust 客户端,这意味着它不依赖于 C 库,而是在 Rust 中实现了整个协议。如果 API 看起来与rusqlitecrate 相似,这是故意的;SQLite 客户端的 API 实际上是基于 PostgreSQL 客户端的。postgrescrate 支持一些 PostgreSQL 的独特功能,如位向量、时间字段、JSON 支持和 UUID。
在本节中,我们将通过创建一个初始化 PostgreSQL 数据库并在数据库上进行一些插入和查询的示例程序来探索与 PostgreSQL 的交互。我们假设您已经在系统上设置了数据库。本例中使用的 PostgreSQL 版本是 9.5。
要安装 PostgreSQL 数据库系统,以下 DigitalOcean 文章推荐:www.digitalocean.com/community/tutorials/how-to-install-and-use-postgresql-on-ubuntu-16-04。
Postgres 自带一个名为psql的命令行工具,可以用来运行查询、检查表、管理角色、查看系统信息等等。您可以通过在 psql 提示符内运行以下命令来查看您系统上运行的 PostgreSQL 版本。首先,我们将通过运行以下命令来启动psql:
$ sudo -u postgres psql
一旦我们进入 psql,我们就在提示符下运行以下命令:
postgres=# SELECT version();
运行上述命令,会得到以下输出:
PostgreSQL 9.5.14 on x86_64-pc-linux-gnu, compiled by gcc (Ubuntu 5.4.0-6ubuntu1~16.04.10) 5.4.0 20160609, 64-bit
为了使这个例子更简单,我们将重用我们在rusqlite演示中使用的相同的书籍数据。在以下示例中,我们将使用默认的"postgres"用户,密码为"postgres"。您需要将以下示例修改以匹配您的新用户。让我们通过运行cargo new postgres_demo来启动一个新的项目。以下是我们的Cargo.toml中的依赖项:
# postgres_demo/Cargo.toml
[dependencies]
postgres = "0.15.2"
serde = { version = "1.0.82"}
serde_derive = "1.0.82"
serde_json = "1.0.33"
让我们逐行查看main.rs中的代码:
// postgres_demo/src/main.rs
use postgres::{Connection, TlsMode};
const DROP_TABLE: &str = "DROP TABLE IF EXISTS books";
const CONNECTION: &str = "postgres://postgres:postgres@localhost:5432";
const CREATE_TABLE: &str = "CREATE TABLE IF NOT EXISTS books
(id SERIAL PRIMARY KEY,
title VARCHAR NOT NULL,
author VARCHAR NOT NULL,
year SERIAL)";
#[derive(Debug)]
struct Book {
id: i32,
title: String,
author: String,
year: i32
}
fn reset_db(conn: &Connection) {
let _ = conn.execute(DROP_TABLE, &[]).unwrap();
let _ = conn.execute(CREATE_TABLE, &[]).unwrap();
}
我们有一系列用于连接数据库以及创建和删除书籍表的字符串常量。接下来是我们的main函数:
// postgres_demo/src/main.rs
fn main() {
let conn = Connection::connect(CONNECTION, TlsMode::None).unwrap();
reset_db(&conn);
let book = Book {
id: 3,
title: "A programmers introduction to mathematics".to_string(),
author: "Dr. Jeremy Kun".to_string(),
year: 2018
};
conn.execute("INSERT INTO books (id, title, author, year) VALUES ($1, $2, $3, $4)",
&[&book.id, &book.title, &book.author, &book.year]).unwrap();
for row in &conn.query("SELECT id, title, author, year FROM books", &[]).unwrap() {
let book = Book {
id: row.get(0),
title: row.get(1),
author: row.get(2),
year: row.get(3)
};
println!("{:?}", book);
}
}
由于我们在这里没有使用 ORM,而是一个低级接口,我们需要手动将值解包到数据库查询中。让我们运行这个程序:
这是程序的输出,以及随后在psql中对表的查询,以显示其内容:
首先,我们在 psql 提示符下使用\dt命令列出我们的数据库。之后,我们使用查询,即"select * from books"。
这就是使用 Rust 与 PostgreSQL 交互的基础。接下来,让我们探索如何通过使用连接池的概念来提高我们的数据库查询效率。
使用 r2d2 进行连接池
每次新事务发生时都打开和关闭数据库连接很快就会成为瓶颈。通常,打开数据库连接是一个昂贵的操作。这主要是因为需要在两端的套接字连接上创建所需的 TCP 握手。如果数据库托管在远程服务器上,这通常是情况,开销就更加昂贵。如果我们能够为发送到我们数据库的每个后续请求重用连接,我们可能会大大减少延迟。缓解这种开销的有效方法之一是采用数据库连接池。当进程需要新的连接时,它从连接池中获取现有的连接。当进程完成与数据库的必要操作后,这个连接句柄就会回到池中以便以后使用。
在 Rust 中,我们有r2d2crate,它利用特质提供了一种通用的方式来维护各种数据库的连接池。它提供了各种后端作为子 crate,并支持 PostgreSQL、Redis、MySQL、MongoDB、SQLite 以及一些其他已知的数据库系统。r2d2的架构由两部分组成:一个通用部分和一个特定后端部分。后端代码通过实现 r2d2 的ManageConnection特质,并为特定后端添加连接管理器来附加到通用部分。特质如下:
pub trait ManageConnection: Send + Sync + 'static {
type Connection: Send + 'static;
type Error: Error + 'static;
fn connect(&self) -> Result<Self::Connection, Self::Error>;
fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Self::Error>;
fn has_broken(&self, conn: &mut Self::Connection) -> bool;
}
查看特质定义,我们需要指定一个Connection类型,它必须是Send和'static,以及一个Error类型。我们还有三个方法:connect、is_valid和has_broken。connect方法返回来自底层后端 crate 的Connection类型;例如,对于 Postgres 后端,它将是postgres::Connection类型。Error类型是一个枚举,它指定了在连接阶段或检查连接有效性期间可能发生的所有可能的Error情况。
为了演示目的,我们将查看如何使用r2d2crate,首先检查如何使用池连接到 PostgreSQL。我们将从上一节中的代码开始,并修改它以使用连接池,其中我们从8个线程中执行 SQL 查询。
下面是使用r2d2-postgres后端 crate 的池化和线程化实现的完整代码:
// r2d2_demo/src/main.rs
use std::thread;
use r2d2_postgres::{TlsMode, PostgresConnectionManager};
use std::time::Duration;
const DROP_TABLE: &str = "DROP TABLE IF EXISTS books";
const CREATE_TABLE: &str = "CREATE TABLE IF NOT EXISTS books
(id SERIAL PRIMARY KEY,
title VARCHAR NOT NULL,
author VARCHAR NOT NULL,
year SERIAL)";
#[derive(Debug)]
struct Book {
id: i32,
title: String,
author: String,
year: i32
}
fn main() {
let manager = PostgresConnectionManager::new("postgres://postgres:postgres@localhost:5432",
TlsMode::None).unwrap();
let pool = r2d2::Pool::new(manager).unwrap();
let conn = pool.get().unwrap();
let _ = conn.execute(DROP_TABLE, &[]).unwrap();
let _ = conn.execute(CREATE_TABLE, &[]).unwrap();
thread::spawn(move || {
let book = Book {
id: 3,
title: "A programmers introduction to mathematics".to_string(),
author: "Dr. Jeremy Kun".to_string(),
year: 2018
};
conn.execute("INSERT INTO books (id, title, author, year) VALUES ($1, $2, $3, $4)",
&[&book.id, &book.title, &book.author, &book.year]).unwrap();
});
thread::sleep(Duration::from_millis(100));
for _ in 0..8 {
let conn = pool.get().unwrap();
thread::spawn(move || {
for row in &conn.query("SELECT id, title, author, year FROM books", &[]).unwrap() {
let book = Book {
id: row.get(0),
title: row.get(1),
author: row.get(2),
year: row.get(3)
};
println!("{:?}", book);
}
});
}
}
代码与上一个示例相比相当直接,除了我们现在会启动 8 个线程来对我们的数据库执行选择查询。池的大小被配置为8,这意味着SELECT查询线程可以通过重用连接来并发执行 8 个查询。
到目前为止,我们主要使用原始 SQL 查询从 Rust 与数据库交互。但是,有一个更方便的强类型方法,通过一个名为 diesel 的 ORM 库与数据库交互。让我们接下来探索一下。
Postgres 和 diesel ORM
使用低级数据库库和原始 SQL 查询编写复杂的应用程序是犯许多错误的原因。Diesel 是一个 Rust 的 ORM(对象关系映射器)和查询构建器。它大量使用过程宏。它在编译时检测大多数数据库交互错误,并且在大多数情况下能够生成非常高效的代码,有时甚至能超越 C 语言的底层访问。这是因为它能够将通常在运行时进行的检查移动到编译时。在撰写本文时,diesel 支持开箱即用的 PostgreSQL、MySQL 和 SQLite。
我们将把数据库支持集成到我们在 第十三章,使用 Rust 构建 Web 应用程序 中开发的 linksnap 服务器中。我们将使用 diesel 以类型安全的方式与我们的 postgres 数据库通信。我们将从 第十三章,使用 Rust 构建 Web 应用程序 中复制 linksnap 项目,并将其重命名为 linksnap_v2。我们不会详细介绍完整的源代码,只会介绍影响数据库与 diesel 集成的部分。其余的代码库与上一章完全相同。
diesel 项目由许多组件组成。首先,我们有一个名为 diesel-cli 的命令行工具,它可以自动化创建数据库和执行任何必要的数据库迁移的过程。
现在,在我们开始实现与数据库通信的例程之前,我们需要安装 diesel-cli 工具,这将设置我们的数据库及其内部的表。我们可以通过运行以下命令来安装它:
cargo install diesel_cli --no-default-features --features postgres
我们只使用此 CLI 工具的 postgres 功能和 --features 标志。Cargo 将获取并构建 diesel_cli 及其依赖项,并将其安装到用户 Cargo 的默认二进制位置,通常是 ~/.cargo/bin/ 目录。
在我们的 linksnap_v2 目录中,我们将在目录根部的 .env 文件中添加数据库的连接 URL,其内容如下:
DATABASE_URL=postgres://postgres:postgres@localhost/linksnap
我们在 postgres 中的数据库名为 linksnap,用户名和密码都是 postgres。这绝对不是访问数据库的安全方式,建议您在生产环境中使用最佳安全实践来设置您的 postgres 数据库。
我们还需要在 Cargo.toml 文件中添加 diesel 作为依赖项,以及 dotenv 库。dotenv 包通过 dotfiles 处理本地配置。以下是我们的 Cargo.toml 文件:
# linksnap_v2/Cargo.toml
[dependencies]
actix = "0.7"
actix-web = "0.7"
futures = "0.1"
env_logger = "0.5"
bytes = "0.4"
serde = "1.0.80"
serde_json = "1.0.33"
serde_derive = "1.0.80"
url = "1.7.2"
lazy_static = "1.2.0"
log = "0.4.6"
chrono = { version="0.4" }
diesel = { version = "1.3.3", features = ["extras", "postgres", "r2d2"] }
dotenv = "0.13.0"
注意 diesel 包中我们使用的 "postgres" 和 "r2d2" 功能。接下来,我们将运行 diesel setup:
Creating migrations directory at: /home/creativcoder/book/Mastering-RUST-Second-Edition/Chapter14/linksnap_v2/migrations
这将在根目录下创建一个 diesel.toml 文件,其内容如下:
# linksnap_v2/diesel.toml
# For documentation on how to configure this file,
# see diesel.rs/guides/configuring-diesel-cli
[print_schema]
file = "src/schema.rs"
Diesel 依赖于宏来提供一些出色的功能,例如在编译时提供额外的安全和性能。为了能够做到这一点,它需要编译时对数据库的访问。这就是为什么 .env 文件很重要的原因。diesel setup 命令通过读取数据库并将其写入一个名为 schema.rs 的文件来自动生成模型类型。模型通常分为查询和插入结构体。两者都使用 derive 宏来为不同的用例生成模型代码。此外,基于 diesel 的应用程序需要代码来连接到数据库,以及一组数据库迁移来构建和维护数据库表。
现在,让我们添加一个迁移,通过运行以下代码来创建我们的表:
diesel migration generate linksnap
此命令生成一个新的迁移,包含两个空的 up.sql 和 down.sql 迁移文件:
Creating migrations/2019-01-30-045330_linksnap/up.sql
Creating migrations/2019-01-30-045330_linksnap/down.sql
迁移文件只是普通的 SQL,所以我们可以直接放入我们之前的 CREATE TABLE 命令:
-- linksnap_v2/migrations/2019-01-30-045330_linksnap_db/up.sql
CREATE TABLE linksnap (
id SERIAL PRIMARY KEY,
title VARCHAR NOT NULL,
url TEXT NOT NULL,
added TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
)
down.sql 文件应该包含相应的 DROP TABLE:
-- linksnap_v2/migrations/2019-01-30-045330_linksnap_db/down.sqlDROP TABLE linksnap
一旦我们这样做,我们就必须运行:
$ diesel migration run
这将通过从数据库中读取来创建一个 schema.rs 文件:
// linksnap_v2/src/schema.rs
table! {
linksnap (id) {
id -> Int4,
title -> Varchar,
url -> Text,
added -> Timestamp,
}
}
table! 宏为具有 id 作为主键的 linksnap 表生成代码。它还指定了列名,包括 id、title、url 和 added。
现在,我们可以为这个表编写一个模型。在 diesel 中,模型可以存在于任何可见的模块中,但我们将遵循将它们放在 src/models.rs 中的约定。以下是我们的 Link 模型的内容:
// linksnap_v2/src/models.rs
use chrono::prelude::*;
use diesel::prelude::Queryable;
use chrono::NaiveDateTime;
use diesel;
use diesel::pg::PgConnection;
use diesel::prelude::*;
use crate::state::AddLink;
use crate::schema::linksnap;
use crate::schema::linksnap::dsl::{linksnap as get_links};
use serde_derive::{Serialize, Deserialize};
pub type LinkId = i32;
#[derive(Queryable, Debug)]
pub struct Link {
pub id: i32,
pub title: String,
pub url: String,
pub added: NaiveDateTime,
}
impl Link {
pub fn add_link(new_link: AddLink, conn: &PgConnection) -> QueryResult<usize> {
diesel::insert_into(linksnap::table)
.values(&new_link)
.execute(conn)
}
pub fn get_links(conn: &PgConnection) -> QueryResult<Vec<Link>> {
get_links.order(linksnap::id.desc()).load::<Link>(conn)
}
pub fn rm_link(id: LinkId, conn: &PgConnection) -> QueryResult<usize> {
diesel::delete(get_links.find(id)).execute(conn)
}
}
我们创建了一个 Link 结构体,它可以用来查询数据库。它还包含各种方法,当我们的服务器在相应的端点上收到请求时会被调用。
接下来,state.rs 文件包含 diesel 和 postgres 特定的代码:
// linksnap_v2/src/state.rs
use diesel::pg::PgConnection;
use actix::Addr;
use actix::SyncArbiter;
use std::env;
use diesel::r2d2::{ConnectionManager, Pool, PoolError, PooledConnection};
use actix::{Handler, Message};
use crate::models::Link;
use serde_derive::{Serialize, Deserialize};
use crate::schema::linksnap;
use std::ops::Deref;
const DB_THREADS: usize = 3;
use actix_web::{error, Error};
use actix::Actor;
use actix::SyncContext;
// Using this we create the connection pool.
pub type PgPool = Pool<ConnectionManager<PgConnection>>;
type PgPooledConnection = PooledConnection<ConnectionManager<PgConnection>>;
pub struct Db(pub PgPool);
// We define a get conn a convenient method to get
impl Db {
pub fn get_conn(&self) -> Result<PgPooledConnection, Error> {
self.0.get().map_err(|e| error::ErrorInternalServerError(e))
}
}
首先,我们为我们的 PostgreSQL 连接池创建了一组方便的别名。我们有一个相同的 Db 结构体,它封装了 PgPool 类型。PgPool 类型是 diesel 中 r2d2 模块的一个 ConnectionManager。在 Db 结构体上,我们还定义了 get_conn 方法,它返回一个指向池连接的引用。
继续阅读同一文件:
// We then implement the Actor trait on the actor.
impl Actor for Db {
type Context = SyncContext<Self>;
}
pub fn init_pool(database_url: &str) -> Result<PgPool, PoolError> {
let manager = ConnectionManager::<PgConnection>::new(database_url);
Pool::builder().build(manager)
}
// This type is simply wraps a Addr what we
#[derive(Clone)]
pub struct State {
pub inner: Addr<Db>
}
impl State {
// The init method creates
pub fn init() -> State {
let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
let pool = init_pool(&database_url).expect("Failed to create pool");
let addr = SyncArbiter::start(DB_THREADS, move || Db(pool.clone()));
let state = State {
inner: addr.clone()
};
state
}
pub fn get(&self) -> &Addr<Db> {
&self.inner
}
}
我们有熟悉的 State 类型,但这里的 init 方法不同。它首先访问 DATABASE_URL 环境变量,并尝试使用 pool 中的 database_url 来建立一个池连接。然后我们启动一个 SyncArbiter 线程,克隆 pool。最后,我们将 state 实例返回给调用者。
除了这些,我们不需要对之前的 linksnap 代码库做太多修改。让我们试运行一下我们的新服务器。我们将使用 curl 将一个 Link 插入到我们的服务器中,如下所示:
curl --header "Content-Type: application/json" \
--request POST \
--data '{"title":"rust webpage","url":"https://rust-lang.org"}' \
127.0.0.1:8080/add
现在为了确认这个链接已经到达我们的 postgres 数据库,让我们从 psql 提示符中查询这个条目:
太棒了!我们的 curl 请求已经到达了 postgres 数据库。
虽然 Diesel 的入门门槛有点高,但随着越来越多的示例和文献出现,情况应该会得到改善。
摘要
在本章中,我们简要地探讨了使用 Rust 通过低级别的 SQLite 和 PostgreSQL 库 crate 来执行基本数据库交互的几种方法。我们看到了如何使用 r2d2 来增强数据库连接性,并使用连接池。最后,我们使用 Diesel,一个安全且高效的 ORM,创建了一个小型应用程序。
在下一章中,我们将探讨如何使用名为 WebAssembly 的前沿技术使 Rust 能够在网络上运行。
第十五章:使用 WebAssembly 在 Web 上构建 Rust
Rust 超出了其系统编程领域,也可以在 Web 上运行。在本章中,我们将探讨一种实现这一目标的技术,称为 WebAssembly。我们将详细介绍 WebAssembly 究竟是什么,以及如何使用这项技术使 Rust 能够与 JavaScript 一起运行。能够在 Web 浏览器上运行解锁了一个领域,使得 Rust 能够被更广泛的受众使用,即 Web 开发者社区,并使他们能够在应用程序中利用系统语言的功能。在本章的后面部分,我们将探讨提供 WebAssembly 支持的工具和库,并构建一个实时 Markdown 编辑器,该编辑器调用在 Rust 中实现的 API,将 Markdown 文档渲染到 HTML 页面上。
在本章中,我们将涵盖以下主题
-
什么是 WebAssembly?
-
WebAssembly 的目标
-
如何使用 WebAssembly?
-
Rust 和 WebAssembly 的故事以及可用的 crate
-
在 Rust 中构建基于 WebAssembly 的 Web 应用程序
什么是 WebAssembly?
“保持好奇心。广泛阅读。尝试新事物。我认为人们所说的许多所谓的智力都归结为好奇心。” – 阿伦·斯沃茨
WebAssembly 是一套技术和规范,它允许通过编译成名为 wasm 的低级编程语言来在 Web 上运行原生代码。从可用性的角度来看,它是一套技术,允许用其他非 Web 编程语言编写的程序在 Web 浏览器上运行。从技术角度来看,WebAssembly 是一个具有二进制、加载时高效的 指令集架构 (ISA) 的虚拟机规范。好吧,这是术语过载。让我们稍微简化一下这个定义。正如我们所知,编译器是一个复杂的程序,它将人类可读的编程语言编写的代码转换为由零和一组成的机器代码。然而,这种转换发生在多步过程中。它通过编译的几个阶段来完成,最终编译成特定于机器的汇编语言。随后,特定于机器的汇编器根据目标机器的 ISA 规则将其编码为机器代码。在这里,编译器针对的是真实机器。然而,它不总是必须是真实机器。它也可以是一个虚拟机 (VM),在真实机器上执行自己的虚拟指令集。虚拟机的一个例子是视频游戏模拟器,如运行在普通计算机上的 Gameboy 模拟器,它模拟 Gameboy 硬件。WebAssembly 虚拟机与此类似!在这里,浏览器引擎实现了 WebAssembly 虚拟机,使我们能够在 JavaScript 旁边运行 wasm 代码。
指令集架构或 ISA 定义了计算机如何执行指令以及它在最低级别支持的操作类型。这个 ISA 不一定要总是为真实的物理机器定义;它也可以为虚拟机定义。Wasm 是 WebAssembly 虚拟机的 ISA。
过去 5 年中,对网络及其各种应用的日益依赖导致了开发者们努力将他们的代码转换为 JavaScript。这是因为 JavaScript 是最受欢迎的,也是网络上的唯一跨平台技术。一个名为asm.js的项目,由 Mozilla(JavaScript 的一个更快的子集)发起,是第一个努力使网络更高效、足够快以满足不断增长需求的项目。从asm.js及其创立原则和所学经验中,WebAssembly 应运而生。
WebAssembly 是来自各大公司浏览器委员会的共同努力,包括 Mozilla、Google、Apple 和 Microsoft。自 2018 年初以来,它作为各种语言的编译目标而受到极大的欢迎,这些语言从使用 Emscripten 工具链的C++,到使用 LLVM/Emscripten 的 Rust,使用 AssemblyScript 的 TypeScript,以及其他许多语言。截至 2019 年,所有主要浏览器都在其网络浏览器引擎中实现了 WebAssembly 虚拟机。
WebAssembly 的名字中有 assembly,因为它是一种类似于汇编指令的低级编程语言。它有一组有限的原始类型,这使得语言易于解析和运行。它支持以下类型:
-
i32: 32 位整数
-
i64: 64 位整数
-
f32: 32 位浮点数
-
f64: 64 位浮点数
它不像 JavaScript 那样是你每天都会编写的编程语言,而更像是一个编译目标,供编译器使用。WebAssembly 平台和生态系统目前专注于在网络上运行这项技术,但它并不局限于网络。如果一个平台将 WebAssembly 虚拟机规范实现为一个程序,那么 wasm 程序就能在该虚拟机上运行。
为了在任何平台上支持 WebAssembly,需要用该平台支持的语言实现一个虚拟机。这就像 JVM 的平台无关代码——一次编写,运行更快,安全在任何地方!但它的主要目标,到目前为止,是浏览器。大多数网络浏览器都带有 JavaScript 解析器,可以在其浏览器引擎中解析.js文件,以使用户能够进行各种交互。为了允许网络也能解释 wasm 文件,这些引擎在其内部实现了 WebAssembly VM,允许浏览器在 JavaScript 代码旁边解释和运行 wasm 代码。
解析 JavaScript 和解析 WebAssembly 代码之间的一个显著差异是,由于其紧凑的表示,wasm 代码的解析速度要快一个数量级。在动态网站上,大多数初始页面加载时间都花在解析 JavaScript 代码上,而使用 WebAssembly 可以为这些网站提供巨大的性能提升。然而,WebAssembly 的目标并不是取代 JavaScript,而是在性能重要时成为 JavaScript 的助手。
根据webassembly.org/上的规范,WebAssembly 的语言有两种格式:人类可读的文本格式,.wat,适合在最终部署前查看和调试 WebAssembly 代码,以及称为 wasm 的紧凑、低级机器格式。.wasm 格式是 WebAssembly VM 解释和执行的一种格式。
一个 WebAssembly 程序从模块开始。在模块内部,你可以定义变量、函数、常量等。Wasm 程序以 s-表达式编写。S-表达式是通过嵌套括号分隔的块序列来表示程序的简洁方式。例如,单个 (1) 是一个返回值 1 的 s-表达式。WebAssembly 中的每个 s-表达式都返回一个值。让我们看看一个非常简单的 WebAssembly 程序,以可读的 .wat 格式:
(module
(table 0 anyfunc)
(memory $0 1)
(export "memory" (memory $0))
(export "one" (func $one))
(func $one (; 0 ;) (result i32)
(i32.const 1)
)
)
在前面的 wat 代码中,我们有一个包含其他嵌套 s-表达式的父 s-表达式块 (module)。在 module 内部,我们有名为 table、memory 和 export 的部分,以及一个返回 i32 的 func 定义 $one。我们不会深入探讨它们的细节,因为这会让我们偏离主题太远。
关于 wasm 程序的一个重要点是,它们在表示上非常高效,可以在浏览器中比 JavaScript 快得多地发送和解析。话虽如此,WebAssembly 是为了实现一系列目标而设计的,而不是作为一个通用编程语言。
WebAssembly 的设计目标
WebAssembly 的设计是主要浏览器供应商之间联合协作的结果。他们共同的目标是以下目标来塑造其设计:
-
像 JavaScript 一样安全和通用:网络平台是一个不安全的环境,运行不受信任的代码对网络用户的安全是有害的。
-
以原生代码的速度运行:由于语言相当紧凑,WebAssembly 可以比 JavaScript 代码加载得更快,并且可以比 JavaScript 快五倍的速度进行解释。
-
提供一致、可预测的性能:作为静态类型,并且在运行时进行非常少的分析,WebAssembly 能够在网络上提供一致的性能,而 JavaScript 由于其动态性质而在这方面表现不足。
-
允许在 Web 和本地之间重用代码:许多现有的 C/C++、Rust 和其他语言的代码库现在可以在编译成 WebAssembly 后重用并在网络上运行。
开始使用 WebAssembly
虽然可以手动编写 WebAssembly 模块,但这样做并不建议,因为代码难以维护且不便于人类使用。它是一种相当低级的语言,因此,使用原始 wasm 代码创建复杂的应用程序可能会具有挑战性且耗时。相反,它通常被编译成或从各种语言生成。让我们看看我们可以使用的可用工具,以探索 WebAssembly 程序的编写和运行细节。
在线尝试
在我们讨论 WebAssembly 如何作为不同语言生态系统的编译目标之前,我们可以在网上探索它,而无需在我们的机器上做任何设置。以下是一些可以用来做这件事的工具:
-
WebAssembly Studio:Mozilla 的人们创建了一个非常实用的工具,可以快速尝试 WebAssembly,它托管在
webassembly.studio。使用这个工具,我们可以快速实验和原型设计 WebAssembly 的想法。 -
Wasm Fiddle:这是另一个方便的工具,可以在线尝试 wasm 代码,可以在
wasdk.github.io/WasmFiddle/找到。
在线还有其他工具和社区资源供您探索,您都可以在 github.com/mbasso/awesome-wasm 找到。
生成 WebAssembly 的方法
有几个编译器工具链项目可以帮助开发者将任何语言的代码编译为 wasm。编译本地代码对网络有巨大的影响。这意味着大多数主要性能密集型代码现在都可以在网络上运行。例如,可以使用 emscripten LLVM 后端将 C++ 代码编译为 wasm。emscripten 项目接收由 C++ 编译器生成的 LLVM IR,并将其转换为 wasm 格式的 WebAssembly 模块。还有像 AssemblyScript 这样的项目,使用类似 emscripten 的工具 binaryen 将 TypeScript 代码转换为 WebAssembly。Rust 还默认支持通过 LLVM 的本地 WebAssembly 后端生成 WebAssembly 代码。使用 Rust 编译到 wasm 非常简单。首先,我们需要运行以下代码来添加 wasm:
rustup target add wasm32-unknown-unknown
完成这些后,我们可以通过运行以下代码将任何 Rust 程序编译为 wasm:
cargo build --target=wasm32-unknown-unknown
这是从 Rust crate 创建 wasm 文件所需的最基本内容,但从那里开始有很多手动操作。幸运的是,围绕 wasm 和 Rust 生态系统正在开发一些惊人的项目,允许进行更高级、更直观的 JavaScript 和 Rust 之间的交互,反之亦然。我们将探索这样一个项目,称为 wasm-bindgen,并很快构建一个真实世界的 Web 应用程序。
Rust 和 WebAssembly
Rust 和 WebAssembly 围绕的生态系统正在以相当快的速度发展,社区在就构建实用应用程序的工具集达成一致之前还需要一段时间。幸运的是,一些工具和库正在出现,为我们描绘了当使用 WebAssembly 在 Rust 中构建 Web 应用程序时,作为开发者我们可以期待什么。
在本节中,我们将探索一个来自社区的库,称为 wasm-bindgen. 这个库基本上是一个正在进行中的项目,因为 WebAssembly 规范本身也是一个正在进行中的项目,但尽管如此,它仍然功能丰富,可以探索可能实现的内容。
Wasm-bindgen
wasm-bindgen 是由 GitHub 上的 rust-wasm 团队开发的一个库。它允许 Rust 代码调用 JavaScript 代码,反之亦然。基于这个库,已经构建了其他高级库,如 web-sys 库和 js-sys 库。
JavaScript 本身是由 ECMA 标准定义的,但该标准并未指定其在网页上的工作方式。JavaScript 可以支持许多宿主环境,而网页恰好是其中之一。web-sys 库提供了对网页上所有 JavaScript API 的访问,即 DOM API,如 Window、Navigator、EventListener 等。js-sys 库提供了 ECMA 标准规范中指定的所有基本 JavaScript 对象,即函数、对象、数字等。
由于 WebAssembly 只支持数值类型,wasm-bindgen 库生成垫片,允许你在 JavaScript 中使用原生 Rust 类型。例如,Rust 中的结构体在 JavaScript 端表示为对象,而 Promise 对象在 Rust 端可以像 Future 一样访问。它通过在函数定义上使用 #[wasm-bindgen] 属性宏来实现所有这些。
为了探索 wasm-bindgen 以及它与 JavaScript 的交互方式,我们将构建一些实用的东西。我们将构建一个实时 Markdown 编辑器应用程序,允许你编写 Markdown 并查看渲染的 HTML 页面。不过,在我们开始之前,我们需要安装 wasm-bindgen-cli 工具,该工具将为我们生成垫片,使我们能够方便地使用库中暴露的 Rust 函数。我们可以通过运行以下命令来安装它:
cargo install wasm-bindgen-cli
接下来,让我们通过运行 cargo new livemd 并在 Cargo.toml 中包含以下内容来创建一个新的项目:
[package]
name = "livemd"
version = "0.1.0"
authors = ["Rahul Sharma <creativcoders@gmail.com>"]
edition = "2018"
[lib]
crate-type = ["cdylib"]
[dependencies]
wasm-bindgen = "0.2.29"
comrak = "0.4.0"
我们将我们的库命名为 livemd。我们的库是 cdylib 类型,并暴露了一个 C 接口,因为 WebAssembly 接受广泛可移植的动态 C 库接口,大多数语言都可以编译成这种接口。接下来,我们还将在我们目录的根目录下创建一个 run.sh 脚本,它将允许我们构建和运行我们的项目,并在我们更改任何代码时使用 cargo-watch 重新运行它。以下是 run.sh 文件的内容:
#!/bin/sh
set -ex
cargo build --target wasm32-unknown-unknown
wasm-bindgen target/wasm32-unknown-unknown/debug/livemd.wasm --out-dir app
cd app
yarn install
yarn run serve
接下来是 lib.rs 中 markdown 转换代码的实现,完整如下:
// livemd/src/lib.rs
use wasm_bindgen::prelude::*;
use comrak::{markdown_to_html, ComrakOptions};
#[wasm_bindgen]
pub fn parse(source: &str) -> String {
markdown_to_html(source, &ComrakOptions::default())
}
我们的 livemd 包公开一个名为 pars 的单个函数,它接受来自网页上(尚未创建)的 textarea 标签的 Markdown 文本,并通过调用 comrak 包中的 markdown_to_html 函数返回编译后的 HTML 字符串。如您所注意到的,parse 方法被注释为 #[wasm_bindgen] 属性。此宏生成所有类型的底层转换代码,并且是暴露此函数到 JavaScript 所必需的。使用此属性,我们不必关心我们的解析方法将接受什么类型的字符串。JavaScript 中的字符串与 Rust 中的字符串不同。#[wasm_bindgen] 属性处理这种差异以及将字符串从 JavaScript 端转换为低级细节,在我们接受它作为 &str 类型之前。在撰写本书时,有一些类型 wasm-bindgen 无法转换,例如带有生命周期注释的引用和类型定义。
我们接下来需要为这个包生成 wasm 文件。但在我们这样做之前,让我们设置我们的应用。在相同的目录下,我们将创建一个名为 app/ 的目录,并通过运行 yarn init 来初始化我们的项目:
yarn init 创建我们的 package.json 文件。除了常规字段外,我们还将指定 scripts 和 dev-dependencies:
{
"name": "livemd",
"version": "1.0.0",
"description": "A live markdown editor",
"main": "index.js",
"license": "MIT",
"scripts": {
"build": "webpack",
"serve": "webpack-dev-server"
},
"devDependencies": {
"html-webpack-plugin": "³.2.0",
"webpack": "⁴.28.3",
"webpack-cli": "³.2.0",
"webpack-dev-server": "³.1.0"
}
}
我们将使用 webpack 来启动我们的开发 web 服务器。Webpack 是一个模块打包器。模块打包器将多个 JavaScript 源文件打包成一个文件,可能还会对其进行压缩以便在网络上使用。为了配置 webpack 以便我们可以打包我们的 JavaScript 和 wasm 生成的代码,我们将在名为 webpack.config.js 的文件中创建一个 webpack 配置文件:
// livemd/app/webpack.config.js
const path = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin');
module.exports = {
entry: './index.js',
output: {
path: path.resolve(__dirname, 'dist'),
filename: 'index.js',
},
plugins: [
new HtmlWebpackPlugin({
template: "index.html"
})
],
mode: 'development'
};
接下来,在相同的 app/ 目录下,我们将创建三个文件:
index.html: 这包含应用的 UI:
<!--livemd/app/index.html-->
<!DOCTYPE html>
<html>
<head>
<title>Livemd: Realtime markdown editor</title>
<link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css" rel="stylesheet">
<link href="https://fonts.googleapis.com/css?family=Aleo" rel="stylesheet">
<link href="styles.css" rel="stylesheet">
</head>
<body class="container-fluid">
<section class="row">
<textarea class="col-md-6 container" id="editor">_Write your text here.._</textarea>
<div class="col-md-6 container" id="preview"></div>
</section>
<script src="img/index.js" async defer></script>
</body>
</html>
我们已声明一个具有 ID 为 editor 的 <textarea> HTML 元素。这将在左侧显示,并且是您可以在此处编写 Markdown 的地方。接下来,我们有一个具有 ID 为 preview 的 <div> 元素,它将显示实时渲染的 HTML 内容。
style.css: 为了使我们的应用看起来更美观,此文件为应用中的实时编辑器和预览面板提供基本的样式:
/* livemd/app/styles.css */
html, body, section, .container {
height: 100%;
}
#editor {
font-family: 'Aleo', serif;
font-size: 2rem;
color: white;
border: none;
overflow: auto;
outline: none;
resize: none;
-webkit-box-shadow: none;
-moz-box-shadow: none;
box-shadow: none;
box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, .6);
background-color: rgb(47,79,79);
}
#preview {
overflow: auto;
border: 5px;
border-left: 1px solid grey;
}
index.js: 此文件提供我们 UI 和livemd包之间的粘合代码:
// livemd/app/index.js
import('./livemd').then((livemd) => {
var editor = document.getElementById("editor");
var preview = document.getElementById("preview");
var markdownToHtml = function() {
var markdownText = editor.value;
html = livemd.parse(markdownText);
preview.innerHTML = html;
};
editor.addEventListener('input', markdownToHtml);
// Kick off parsing of initial text
markdownToHtml();
}).catch(console.error);
上述代码导入了 livemd 模块,该模块返回一个 Promise 实例。然后,我们通过调用 then 方法来链式调用由这个承诺产生的值,该方法接受一个匿名函数 (livemd) => {}。这个函数接收 wasm 模块(我们命名为 livemd)。在这个方法内部,我们通过 ID 获取 editor 和 preview HTML 元素。然后,我们创建一个名为 markdownToHtml 的函数,该函数从 editor 元素的 value 属性中获取文本并将其传递给 livemd wasm 模块的 parse 方法。这返回一个作为字符串的渲染 HTML 文本。然后,我们将 preview 元素的 innerHTML 属性设置为这个文本。接下来,为了提供用户在 editor 元素中任何文本更改的实时反馈,我们需要调用这个函数。我们可以使用 onInput 事件处理器来实现。我们对编辑器元素调用 addEventListener 方法,使用 "input" 事件,并将此函数作为处理器传递。最后,我们调用 markdownToHtml 来启动文本的解析和渲染。
就这样——我们已经创建了我们第一个使用 Rust 作为底层并运行 WebAssembly 的 Web 应用程序。
注意:这不是一个高效的实现,有很多改进可以做出。然而,由于我们在这里学习工具,为了演示目的,这是可以接受的。
现在,我们需要将我们的 crate 编译成 WebAssembly 代码,即一个 wasm 文件,并生成一个捆绑的 JavaScript 文件。我们已经设置了一个名为 run.sh 的脚本。以下是运行我们的 run.sh 脚本时的输出:
run.sh 脚本首先通过运行 cargo build --target wasm32-unknown-unknown 构建 livemd crate。然后,它调用 wasm-bindgen 工具,该工具优化我们的 wasm 文件并将其输出到 app/ 目录。接着,我们在应用目录中运行 yarn install,然后是 yarn run serve,这会使用 webpack-dev-server 插件启动我们的开发服务器。
如果你在运行 wasm-bindgen 命令行时遇到错误,尝试通过运行以下命令更新 livemd/Cargo.toml 中的 wasm-bindgen 依赖项:
cargo update -p wasm-bindgen
我们还需要安装 yarn 包管理器来在本地主机上托管网页。这可以通过运行以下命令来完成:
$ curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
$ echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
$ sudo apt-get update && sudo apt-get install yarn
从 webpack 的输出来看,我们的开发服务器正在 http://localhost:8080 运行。让我们转到我们的网页浏览器并访问这个地址。以下是我在浏览器中的输出:
如您所见,我们在左侧面板中有 markdown 格式的文本,并且它实时地渲染在右侧的 HTML 中。在底层,我们在这个页面的左侧键入的每一比特文本都被转换成了由我们创建的 livemd wasm 模块生成的 HTML 文本。
我们还可以将我们的livemd包发布为 npm 包。位于github.com/rustwasm/wasm-pack的 wasm-pack 项目提供了构建和分发用 Rust 编写并编译成 WebAssembly 的 npm 模块所需的所有编排。
其他 WebAssembly 项目
除了wasm-bindgen包及其相关项目外,Rust 社区中还有其他新兴的框架和项目值得探索。
Rust
Wasm-bindgen 并不是唯一旨在创建出色开发体验的项目。Rust 生态系统中的其他一些项目如下:
-
Stdweb:这个包旨在提供一个基于 Rust 的高层 API,用于通过 Web 访问 DOM API。
-
Yew:这是一个完整的前端 Web 应用程序构建框架,允许你使用 Rust 编写可以访问 Web API 并将它们编译成 wasm 以便在 Web 上运行的 Web 应用程序。它受到了 Elm 和 ReactJS 项目的启发。它还通过 Web Workers 封装了基于 actor 的消息传递并发。Yew 内部使用
stdweb包来访问 DOM API。 -
Nebutlet:这是一个可以执行 WebAssembly 程序而不需要任何系统调用接口的微内核,这在大多数操作系统实现中通常是标准做法。
-
Wasmi:这是一个用 Rust 实现的 wasm 虚拟机,但它与浏览器引擎中的 wasm 虚拟机无关。该项目由以太坊初创公司 Parity 发起,更适合在多个平台上运行 WebAssembly 应用程序。该项目托管在
github.com/paritytech/wasmi。
其他语言
其他语言也有针对 WebAssembly 的技术,例如以下内容:
-
Life:Life 是一个用 Golang 实现的 WebAssembly 虚拟机,用于安全地运行高性能、去中心化的应用程序。该项目位于
github.com/perlin-network/life。 -
AssemblyScript:这是一个 TypeScript 到 WebAssembly 的编译器。
-
Wagon:Wagon 是一个用 Golang 编写的 WebAssembly 解释器。
摘要
WebAssembly 将对 Web 开发者构建应用程序的方式产生巨大影响,使他们能够以最小的努力获得大量的性能提升。它将允许应用开发者多样化,从而使得他们能够用他们的本地语言编写 Web 应用程序,而无需担心学习其他框架。WebAssembly 不是用来取代 JavaScript 的,而是作为一个高性能语言,用于在 Web 上运行复杂的 Web 应用程序。WebAssembly 标准正在不断演变,并有许多令人兴奋的可能性。
在本章中,我们学习了 Rust 如何编译成 wasm 代码以及帮助在网络上部署 Rust 代码的可用工具。如果你想要了解更多关于 WebAssembly 的信息,请访问优秀的文档:developer.mozilla.org/en-US/docs/WebAssembly。
在下一章中,我们将学习一些关于 GUI 开发以及如何使用 Rust 构建桌面应用程序的内容。
第十六章:使用 Rust 构建桌面应用程序
如果你的软件只支持终端或基于命令行的界面,你的目标受众可能仅限于那些知道如何使用命令行的人。为你的软件提供一个图形用户界面(GUI)可以扩大你的目标受众,并为用户提供一个友好且直观的界面,使他们能够轻松地使用软件。对于构建 GUI,大多数语言都提供了框架,这些框架由几个原生库组成,可以访问平台的图形和 I/O 接口。这使得开发者可以轻松地为他们的应用程序构建 GUI,而无需担心底层细节。
有很多流行的 GUI 框架针对桌面平台,如 Qt、GTK+和 ImGUI,这些框架适用于主流语言。在撰写本书时,Rust 还没有成熟的 GUI 框架生态系统,但幸运的是,我们有方便的 FFI 机制,可以通过它利用 C/C++等语言提供的原生 GUI 框架。在本章中,我们将介绍这样一个 crate,它提供了对 GTK+框架的本地绑定,用于进行 GUI 开发,并构建我们自己的新闻阅读桌面应用程序。
在本章中,我们将涵盖以下主题:
-
GUI 开发简介
-
GTK+框架和
gtkcrate -
使用 Rust 构建黑客新闻桌面应用程序
-
其他新兴框架
GUI 开发简介
“在编程中,困难的部分不在于解决问题,而在于决定要解决什么问题。”
– 保罗·格雷厄姆
基于 GUI 的软件的出现始于 GUI 操作系统。第一个 GUI 操作系统是 1973 年开发的 Xerox Alto 计算机上的 Alto Executive。从那时起,许多操作系统效仿并附带了自己的基于 GUI 的界面。如今,最著名的基于 GUI 的操作系统是 macOS、Windows 以及基于 Linux 的发行版,如 Ubuntu 和 KDE。随着用户通过视觉点按界面与操作系统交互,对基于 GUI 的应用程序的需求增加,许多软件开始附带 GUI,为用户提供了一种与软件交互的视觉方式,类似于他们与操作系统交互的方式。但 GUI 开发的早期阶段有很多手动工作,由于硬件限制,不同的应用程序在其 GUI 中都有专门的实现和性能特征。最终,GUI 框架开始普及,这为开发者提供了一个共同的基线和从底层操作系统的所有底层细节中的抽象层,同时也实现了跨平台。
在我们构建应用程序之前,了解在将 GUI 或前端集成到应用程序中时遵循的一般设计指南对我们来说非常重要。我们将从 Linux 操作系统角度进行讨论,但其他平台上的理念也有相似之处。典型的 GUI 应用程序架构通常分为两个组件:前端和后端。前端是用户与之交互的 GUI 线程或主线程。它由包含在父容器窗口中的交互式视觉单元小部件组成。小部件的一个例子是点击执行任务的按钮,或者可以按顺序显示多个项目的列表视图。GUI 线程主要关注向用户展示视觉信息,并且负责传播用户与这些小部件交互时发生的任何事件。
后端是一个独立的线程,包含用于传播状态变化的事件处理程序或事件发射器,主要用于执行计算密集型任务。从 GUI 层处理输入通常被卸载到后台线程,因为如果在主线程上执行计算密集型任务会阻止用户与应用程序的前端交互,这不是一个好的用户体验。此外,为了维护性和关注点的分离,我们通常希望保持前端和后端分离。
在没有专用框架的情况下构建基于 GUI 的应用程序可能是一个非常繁琐的过程,因为没有它们,我们可能需要在应用程序代码中处理很多细节。GUI 框架为开发者抽象了所有这些细节,例如将小部件和窗口绘制到视频内存或 GPU 的帧缓冲区,从输入设备读取事件,重新绘制和刷新窗口等等。话虽如此,让我们看看这样一个框架,即 Gimp 工具包或 GTK+,它是一个构建可扩展 GUI 应用程序的非常成熟和跨平台的解决方案。
GTK+ 框架
GTK+(以下简称 gtk)是一个用 C 语言编写的跨平台 GUI 框架。由于其跨平台性,使用 gtk 开发的应用程序可以在所有主要平台上运行,例如 Windows、Linux 或 MacOS*.* gtk 项目最初是为了开发 Linux 的图像处理软件 GIMP 而创建的,后来被开源。gtk 也被许多其他软件项目使用,例如许多 Linux 发行版上的 Gnome 桌面环境,它使用 gtk 来构建其实用软件。在架构上,gtk 由几个库组成,这些库协同工作以处理渲染和促进用户与应用程序中的窗口和小部件交互所需的各种细节。以下是一些这些组件的例子:
-
GLib: 这是基本的核心库,提供了多种数据结构、用于可移植性的包装器以及运行时功能(如事件循环、线程支持、动态加载和对象系统)的接口。Glib 本身由组件组成,例如 GObject,它提供了一个对象模型,以及 GIO,它提供了对 I/O 的高级抽象**。
-
Pango: Pango 是一个提供文本渲染和国际化的库。
-
Cairo: 这是一个 2D 图形库,负责在屏幕上绘制事物,并试图在多个设备之间保持一致性,同时处理硬件加速等细节。
-
ATK: ATK 是一个辅助功能工具包库,负责为屏幕阅读器、放大镜和替代输入设备等输入设备提供辅助功能。
gtk 还有一个名为 Glade 的界面构建器,它可以生成用于快速应用程序开发的 gtk 源代码框架。
gtk 使用面向对象模型来表示小部件和窗口。它利用 GObject 库来提供这种抽象。要从 Rust 使用 gtk 框架,我们有 gtk-rs 项目,该项目包含许多遵循与 gtk 中存在的库相同命名约定的 crate,并为这些库提供原生 C 绑定。在 gtk-rs 项目包含的所有 crate 中,我们将使用 gtk crate 来构建我们的应用程序。
gtk 包提供了构建 GUI 的窗口和小部件系统,并试图模拟与原生 C 库相同的 API,尽管 Rust 没有面向对象的类型系统,因此存在一些差异。gtk 包中的小部件是智能指针类型。为了在使用 API 时提供灵活性,你可以拥有许多可变引用,类似于 Rust 中的内部可变性提供的引用。gtk 中的任何非平凡小部件都继承自某种基本小部件类型。Rust 通过 IsA<T> 特性支持小部件的继承。例如,gtk::Label 小部件有一个 impl 为 impl IsA<Widget> for Label。此外,gtk 中的大多数小部件都相互共享功能——gtk 包通过扩展特性(如 WidgetExt 特性)为所有小部件类型实现这一点。大多数小部件,如 gtk::Button 和 gtk::ScrollableWindow,都实现了 WidgetExt 特性。小部件还可以使用 Cast 特性将其向下转换为层次结构中的其他小部件。在简要介绍之后,让我们开始编写一个桌面应用程序。
使用 gtk-rs 构建 hacker news 应用程序
我们将使用 gtk crate 来构建一个简单的 hacker news 应用程序,该程序从 news.ycombinator.com/ 网站获取前 10 个热门故事。Hacker News 是一个专注于全球数字技术和科技新闻的网站。首先,我们为我们的应用程序创建了一个基本的线框模型:
在顶部,我们有应用标题栏,其中左侧有一个刷新按钮,可以按需更新我们的故事。故事是用户在 Hacker News 网站上发布的新闻条目。标题栏还包含居中的应用标题和右侧的常规窗口控制按钮。下面是我们的主要可滚动窗口,我们的故事将垂直渲染为故事小部件。故事小部件由两个小部件组成:一个用于显示故事的名称和分数的小部件,另一个用于渲染可以点击在用户默认浏览器中打开的故事链接。非常简单!
注意:由于我们使用的是绑定到原生 C 库的gtkcrate,我们需要安装 gtk 框架的开发 C 库。对于 Ubuntu 和 Debian 平台,我们可以通过运行以下命令来安装这些依赖项:
sudo apt-get install libgtk-3-dev
请参考 gtk-rs 文档页面gtk-rs.org/docs/requirements.html,以获取有关在其他平台上设置 gtk 的信息。
为了开始,我们将通过运行cargo new hews来创建一个新的 cargo 项目。我们创造性地将我们的应用命名为Hews,它是H(hacker 的首字母)和ews(news 的缩写)的组合。
以下是我们将在Cargo.toml文件中需要的依赖项:
# hews/Cargo.toml
[dependencies]
gtk = { version = "0.3.0", features = ["v3_18"] }
reqwest = "0.9.5"
serde_json = "1.0.33"
serde_derive = "1.0.82"
serde = "1.0.82"
在这里,我们使用了一堆 crate:
-
gtk:这是用于构建应用的 GUI。我们在这里使用的是 gtk 版本3.18的绑定。 -
reqwest:这是用于从黑客新闻 API 获取故事的。reqwest是hypercrate 的高级包装器。我们为了简单起见使用reqwest的同步 API。 -
serde_json:这是用于无缝地将从网络获取的 JSON 响应转换为强类型的Story结构体。 -
serde,serde_derive:这些提供了用于自动派生内置 Rust 类型序列化代码的特性和实现。通过使用serde_derive中的Serialize和Deserialize特性,我们可以将任何原生 Rust 类型序列化和反序列化到给定的格式。serde_json依赖于相同的功能将serde_json::Value类型转换为 Rust 类型。
要在我们的应用中显示新闻文章,我们将通过向官方黑客新闻 API 发起 HTTP 请求来获取它们,该 API 的文档位于github.com/HackerNews/API。我们将我们的应用分为两个模块。首先,我们有app模块,它包含所有与 UI 相关的功能,用于在屏幕上渲染应用和处理用户对 UI 状态的更新。其次,我们有hackernews模块,它提供从网络获取故事的 API。它在一个单独的线程中运行,这样在发生网络请求时不会阻塞 GUI 线程,因为这是一个阻塞的 I/O 操作。从黑客新闻 API 获取的故事是一个包含新闻标题和新闻链接的项目,以及其他属性,如故事的流行程度和评论列表。
为了使这个例子更简单、更容易理解,我们的应用程序没有适当的错误处理,并包含许多 unwrap() 调用,这在错误处理方面是一种不良做法。在您完成探索演示后,我们鼓励您在应用程序中集成更好的错误处理策略。话虽如此,让我们一步一步地通过代码。
首先,我们将查看我们的应用程序在 main.rs 中的入口点:
// hews/src/main.rs
mod app;
mod hackernews;
use app::App;
fn main() {
let (app, rx) = App::new();
app.launch(rx);
}
在我们的 main 函数中,我们调用 App::new(),它返回一个 App 实例,以及 rx,它是一个 mpsc::Receiver。为了使我们的 GUI 与网络请求解耦,所有状态更新在 hews 中都是通过通道异步处理的。App 实例内部调用 mpsc::channel(),返回 tx 和 rx。它将 tx 与其存储,并将其传递给网络线程,允许它通知 UI 任何新的故事。在 new 方法调用之后,我们在 app 上调用 launch,传入 rx,这在 GUI 线程中用于监听来自网络线程的事件。
接下来,让我们通过 app.rs 模块中的 app 模块来了解我们的应用程序,它处理将我们的应用程序渲染到屏幕上所需的大部分编排工作。
如果您想了解更多关于以下小部件的解释,请查找 gtk-rs 的优秀文档在 gtk-rs.org/docs/gtk/,您可以在那里搜索任何小部件并探索更多关于其属性的信息。
首先,我们有我们的 App 结构体,它是所有 GUI 事物的入口点:
// hews/src/app.rs
pub struct App {
window: Window,
header: Header,
stories: gtk::Box,
spinner: Spinner,
tx: Sender<Msg>,
}
这个结构体包含了一堆字段:
-
window: 这包含基本的gtk::Window小部件。每个 gtk 应用程序都以一个窗口开始,我们可以向其中添加子小部件以不同的布局来设计我们的 GUI。 -
header: 这是一个我们定义的结构体,它包装了一个gtk::HeaderBar小部件,该小部件充当我们应用程序窗口的标题栏。 -
stories: 这是一个存储我们的故事的垂直容器gtk::Box小部件。 -
spinner: 这是一个gtk::Spinner小部件,为加载故事提供视觉提示。 -
tx: 这是一个 mpscSender,用于从 GUI 发送事件到网络线程。消息的类型是Msg,它是一个枚举:
pub enum Msg {
NewStory(Story),
Loading,
Loaded,
Refresh,
}
当从 hackernews 模块调用 fetch_posts 方法时,我们的应用程序以初始状态 Loading 开始。我们稍后会看到这一点。NewStory 是在获取新故事时发生的状态。Loaded 是在所有故事都加载时发生的状态,当用户想要重新加载故事时,会发送 Refresh。
让我们继续到 App 结构体上的方法。这是我们的 new 方法:
impl App {
pub fn new() -> (App, Receiver<Msg>) {
if gtk::init().is_err() {
println!("Failed to init hews window");
process::exit(1);
}
new 方法首先使用 gtk::init() 启动 gtk 事件循环。如果失败,我们将退出,并在控制台打印一条消息:
let (tx, rx) = channel();
let window = gtk::Window::new(gtk::WindowType::Toplevel);
let sw = ScrolledWindow::new(None, None);
let stories = gtk::Box::new(gtk::Orientation::Vertical, 20);
let spinner = gtk::Spinner::new();
let header = Header::new(stories.clone(), tx.clone());
然后,我们为网络线程和 GUI 线程之间的通信创建 tx 和 rx 通道端点。接下来,我们创建我们的 window,它是一个 TopLevel 窗口。现在,如果窗口被调整大小,多个故事可能不会适合我们的应用程序窗口,因此我们需要一个可滚动的窗口。为此,我们将创建一个 ScrolledWindow 实例作为 sw。然而,gtk 的 ScrolledWindow 只接受其内部的单个子小部件,而我们需要存储多个故事,这是一个问题。幸运的是,我们可以使用 gtk::Box 类型,它是一个通用的容器小部件,用于布局和组织子小部件。在这里,我们创建一个具有 Orientation::Vertical 方向的 gtk::Box 实例作为 stories,这样我们的每个故事都会垂直堆叠渲染。我们还想在故事正在加载时在滚动小部件的顶部显示一个旋转器,因此我们将创建一个 gtk::Spinner 小部件并将其添加到 stories 中以在顶部渲染它。我们还将创建我们的 Header 栏,并将 stories 的引用以及 tx 传递给它。我们的标题栏包含刷新按钮,并有一个点击处理程序,该处理程序需要 stories 容器来清除其内部的项目,这样我们就可以加载新的故事:
stories.pack_start(&spinner, false, false, 2);
sw.add(&stories);
window.add(&sw);
window.set_default_size(600, 350);
window.set_titlebar(&header.header);
接下来,我们开始组合我们的小部件。首先,我们将 spinner 添加到 stories 中。然后,我们将 stories 容器小部件添加到我们的滚动小部件 sw 中,然后将其添加到我们的父 window 中。我们还使用 set_default_size 设置窗口大小。然后我们使用 set_titlebar 并传递我们的 header 来设置其标题栏。随后,我们向我们的窗口附加一个信号处理程序:
window.connect_delete_event(move |_, _| {
main_quit();
Inhibit(false)
});
如果我们调用 main_quit(),这将退出应用程序。Inhibit(false) 的返回类型不会阻止信号传播到 delete_event 的默认处理程序。所有小部件都有一个默认的信号处理程序。在 gtk crate 中的小部件上的信号处理程序遵循 connect_<event> 的命名约定,并接受一个闭包作为它们的第一个参数,该闭包以小部件作为其第一个参数和事件对象。
接下来,让我们看看 App 上的 launch 方法,它在 main.rs 中被调用:
pub fn launch(&self, rx: Receiver<Msg>) {
self.window.show_all();
let client = Arc::new(reqwest::Client::new());
self.fetch_posts(client.clone());
self.run_event_loop(rx, client);
}
首先,我们启用 window 小部件及其子小部件。我们通过调用 show_all 方法使它们可见,因为 gtk 中的小部件默认是不可见的。接下来,我们创建我们的 HTTP Client 并将其包装在 Arc 中,因为我们想与我们的网络线程共享它。然后我们调用 fetch_posts,传递我们的客户端。随后,我们通过调用 run_event_loop 并传递 rx 来运行我们的事件循环。fetch_posts 方法定义如下:
fn fetch_posts(&self, client: Arc<Client>) {
self.spinner.start();
self.tx.send(Msg::Loading).unwrap();
let tx_clone = self.tx.clone();
top_stories(client, 10, &tx_clone);
}
它通过调用其 start 方法启动旋转器动画,并发送 Loading 消息作为初始状态。然后它调用 hackernews 模块中的 top_stories 函数,传递 10 作为要获取的故事数量和一个 Sender 来通知 GUI 线程有新的故事。
在调用 fetch_posts 之后,我们在 App 上调用 run_event_loop 方法,该方法的定义如下:
fn run_event_loop(&self, rx: Receiver<Msg>, client: Arc<Client>) {
let container = self.stories.clone();
let spinner = self.spinner.clone();
let header = self.header.clone();
let tx_clone = self.tx.clone();
gtk::timeout_add(100, move || {
match rx.try_recv() {
Ok(Msg::NewStory(s)) => App::render_story(s, &container),
Ok(Msg::Loading) => header.disable_refresh(),
Ok(Msg::Loaded) => {
spinner.stop();
header.enable_refresh();
}
Ok(Msg::Refresh) => {
spinner.start();
spinner.show();
(&tx_clone).send(Msg::Loading).unwrap();
top_stories(client.clone(), 10, &tx_clone);
}
Err(_) => {}
}
gtk::Continue(true)
});
gtk::main();
}
首先,我们获取我们将要使用的一堆对象的引用。随后,我们调用 gtk::timeout_add,它每 100 毫秒运行一次给定的闭包。在闭包内部,我们以非阻塞方式对 rx 进行轮询,使用 try_recv() 获取来自网络或 GUI 线程的事件。当我们收到 NewStory 消息时,我们调用 render_story。当我们收到 Loading 消息时,我们禁用刷新按钮。在 Loaded 消息的情况下,我们停止我们的旋转器并启用刷新按钮,以便用户可以再次重新加载故事。最后,在收到 Refresh 消息的情况下,我们再次启动旋转器,并将 Loading 消息发送到 GUI 线程本身,随后调用 top_stories 方法。
我们的 render_story 方法定义如下:
fn render_story(s: Story, stories: >k::Box) {
let title_with_score = format!("{} ({})", s.title, s.score);
let label = gtk::Label::new(&*title_with_score);
let story_url = s.url.unwrap_or("N/A".to_string());
let link_label = gtk::Label::new(&*story_url);
let label_markup = format!("<a href=\"{}\">{}</a>", story_url, story_url);
link_label.set_markup(&label_markup);
stories.pack_start(&label, false, false, 2);
stories.pack_start(&link_label, false, false, 2);
stories.show_all();
}
render_story 方法在创建两个标签之前,将 Story 实例作为 s 和 stories 容器小部件作为参数获取:title_with_score,它包含故事标题及其评分,以及 link_label,它包含故事的链接。对于 link_label,我们将添加一个包含 <a> 标签的 URL 的自定义标记。最后,我们将这两个标签放入我们的 stories 容器中,并在最后调用 show_all 以使这些标签在屏幕上可见。
我们之前提到的 Header 结构体及其方法,是 App 结构体的一部分,具体如下:
// hews/src/app.rs
#[derive(Clone)]
pub struct Header {
pub header: HeaderBar,
pub refresh_btn: Button
}
impl Header {
pub fn new(story_container: gtk::Box, tx: Sender<Msg>) -> Header {
let header = HeaderBar::new();
let refresh_btn = gtk::Button::new_with_label("Refresh");
refresh_btn.set_sensitive(false);
header.pack_start(&refresh_btn);
header.set_title("Hews - popular stories from hacker news");
header.set_show_close_button(true);
refresh_btn.connect_clicked(move |_| {
for i in story_container.get_children().iter().skip(1) {
story_container.remove(i);
}
tx.send(Msg::Refresh).unwrap();
});
Header {
header,
refresh_btn
}
}
fn disable_refresh(&self) {
self.refresh_btn.set_label("Loading");
self.refresh_btn.set_sensitive(false);
}
fn enable_refresh(&self) {
self.refresh_btn.set_label("Refresh");
self.refresh_btn.set_sensitive(true);
}
}
这个结构体包含以下字段:
-
header: 一个 gtkHeaderBar,类似于一个适合窗口标题栏的水平 gtkBox -
refresh_btn: 一个用于按需重新加载故事的 gtkButton
Header 还有三个方法:
-
new: 这将创建一个新的Header实例。在new方法内部,我们创建一个新的 gtkHeaderBar,将其关闭按钮设置为显示,并添加一个标题。然后,我们创建一个刷新按钮,并使用connect_clicked方法将其附加到它上面,该方法接受一个闭包。在这个闭包内部,我们遍历滚动窗口容器的所有子项,这些子项作为story_container传递给此方法。然而,我们跳过了第一个,因为第一个小部件是一个Spinner,我们希望它在多次重新加载之间保持显示其进度。 -
disable_refresh: 这将禁用刷新按钮,将其灵敏度设置为false。 -
enable_refresh: 这将启用刷新按钮,将其灵敏度设置为true。
接下来,让我们看看我们的 hackernews 模块,它负责从 API 端点获取故事作为 json 并使用 serde_json 解析为 Story 实例的所有繁重工作。以下是 hackernews.rs 的第一部分内容:
// hews/src/hackernews.rs
use crate::app::Msg;
use serde_json::Value;
use std::sync::mpsc::Sender;
use std::thread;
use serde_derive::Deserialize;
const HN_BASE_URL: &str = "https://hacker-news.firebaseio.com/v0/";
#[derive(Deserialize, Debug)]
pub struct Story {
pub by: String,
pub id: u32,
pub score: u64,
pub time: u64,
pub title: String,
#[serde(rename = "type")]
pub _type: String,
pub url: Option<String>,
pub kids: Option<Value>,
pub descendents: Option<u64>,
}
首先,我们有一个为托管在 Firebase 上的 hackernews API 声明的基 URL 端点 HN_BASE_URL。Firebase 是来自 Google 的实时数据库。然后,我们有 Story 结构体的声明,并带有 Deserialize 和 Debug 特性的注解。Deserialize 特性来自 serde_derive 包,它提供了一个 derive 宏,可以将任何值转换为原生 Rust 类型。我们需要它,因为我们希望能够将来自网络的 json 响应解析为 Story 结构体。
Story 结构体包含与在 stories 端点返回的 json 响应中找到的相同字段。有关 json 结构的更多信息,请参阅 github.com/HackerNews/API#items。此外,在 Story 结构体的所有字段中,我们有一个名为 type 的字段。然而,type 也是 Rust 中用于声明类型别名的关键字,将 type 作为结构体的字段是不合法的,因此我们将它命名为 _type。但是,这不会解析为我们的 json 响应中的 type 字段。为了解决这种冲突,serde 为我们提供了一个字段级别的属性,允许我们在使用 #[serde(rename = "type")] 属性的字段上,即使在存在此类冲突的情况下也能解析值。rename 的值应与传入的 json 响应的字段名称中的值相匹配。接下来,让我们看看这个模块提供的方法集:
// hews/src/hackernews.rs
fn fetch_stories_parsed(client: &Client) -> Result<Value, reqwest::Error> {
let stories_url = format!("{}topstories.json", HN_BASE_URL);
let body = client.get(&stories_url).send()?.text()?;
let story_ids: Value = serde_json::from_str(&body).unwrap();
Ok(story_ids)
}
pub fn top_stories(client: Arc<Client>, count: usize, tx: &Sender<Msg>) {
let tx_clone = tx.clone();
thread::spawn(move || {
let story_ids = fetch_stories_parsed(&client).unwrap();
let filtered: Vec<&Value> = story_ids.as_array()
.unwrap()
.iter()
.take(count)
.collect();
let loaded = !filtered.is_empty();
for id in filtered {
let id = id.as_u64().unwrap();
let story_url = format!("{}item/{}.json", HN_BASE_URL, id);
let story = client.get(&story_url)
.send()
.unwrap()
.text()
.unwrap();
let story: Story = serde_json::from_str(&story).unwrap();
tx_clone.send(Msg::NewStory(story)).unwrap();
}
if loaded {
tx_clone.send(Msg::Loaded).unwrap();
}
});
}
这个模块公开的唯一函数是 top_stories。这个函数接受一个来自 reqwest 包的 Client 引用,然后是一个 count 参数,指定要检索的故事数量,以及一个 Sender 实例 tx,它可以发送类型为 Msg 的消息,Msg 是一个枚举。tx 用于将有关我们的网络请求状态的消息传达给 GUI 线程。最初,GUI 以 Msg::Loading 状态启动,这会禁用刷新按钮。
在这个函数中,我们首先克隆了我们的 tx 发送者,然后在一个线程中使用了这个 tx。我们创建一个线程是为了在网络请求进行时不会阻塞 UI 线程。在闭包中,我们调用 fetch_stories_parsed()。在这个方法中,我们首先使用 format! 宏将 /top_stories.json 端点与 HN_BASE_URL 连接起来。然后,我们向构建的端点发送请求以获取所有故事列表。我们调用 text() 方法将响应转换为 json 字符串。返回的 json 响应是一个包含故事 ID 的列表,每个 ID 都可以用来发起另一组请求,从而提供关于故事的详细信息,作为另一个 json 对象。然后我们使用 serde_json::from_str(&body) 解析这个响应。这给我们一个 Value 枚举值,它是一个解析后的 json 数组,包含故事 ID 列表。
因此,一旦我们将故事 ID 存储在story_ids中,我们就通过调用as_array()显式地将其转换为数组,然后对其iter()并调用take(count)来限制我们想要的条目数,最后调用collect(),这将返回一个Vec<Story>:
let story_ids = fetch_stories_parsed(&client).unwrap();
let filtered: Vec<&Value> = story_ids.as_array()
.unwrap()
.iter()
.take(count)
.collect();
接下来,我们检查过滤后的故事 ID 是否为空。如果是,我们将loaded变量设置为false:
let loaded = !filtered.is_empty();
loaded布尔值用于在加载我们的任何故事时向主 GUI 线程发送通知。接下来,如果filtered列表不为空,我们遍历我们的filtered故事并构建一个story_url:
for id in filtered {
let id = id.as_u64().unwrap();
let story_url = format!("{}item/{}.json", HN_BASE_URL, id);
let story = client.get(&story_url)
.send()
.unwrap()
.text()
.unwrap();
let story: Story = serde_json::from_str(&story).unwrap();
tx_clone.send(Msg::NewStory(story)).unwrap();
}
我们对每个构造的story_url从故事id发起 GET 请求,获取 JSON 响应,并使用serde_json::from_str函数将其解析为Story结构体。之后,我们通过tx_clone将包装在Msg::NewStory(story)中的故事发送到 GUI 线程。
发送所有故事后,我们向 GUI 线程发送一个Msg::Loaded消息,这启用了刷新按钮,以便用户可以再次重新加载故事。
好吧!是时候在我们的应用程序上阅读流行的新闻故事了。运行cargo run后,我们可以在窗口中看到我们的故事被拉取并渲染:
点击任何故事的链接时,它将在你的默认浏览器中打开。这就是全部。我们已经使用非常少的代码在 Rust 中制作了我们的 GUI 应用程序。现在,是时候探索和实验这个应用程序了。
练习
我们的应用程序运行得很好,但我们可以从很多方面来改进它。如果你有雄心壮志,可以查看以下挑战:
-
改进应用程序的错误处理,通过添加重试机制来处理网络缓慢的情况。
-
通过在标题栏上放置一个输入字段小部件来自定义要加载的故事数量,并将该数字解析并传递给网络线程。
-
为每个故事添加一个按钮来查看评论。当用户点击评论按钮时,应用程序应在右侧打开一个可滚动的窗口并逐个填充该故事的评论。
-
小部件可以使用 CSS 进行样式化。尝试使用
gtk::StyleProviderAPI 根据帖子的流行度给故事容器添加颜色。
其他新兴的 GUI 框架
正如我们已经看到的,gtk 包暴露的 API 在编写复杂的 GUI 时可能会有些不舒服。幸运的是,我们有一个名为 relm 的包装包。relm 包受到了 Elm 语言 Model-View-Update 架构的启发,它为构建反应式 GUI 提供了一种简单的方法。除了 relm 之外,Rust 社区还在开发许多其他独立的 GUI 工具包和包。其中之一是新的、有希望的 Azul,可以在 azul.rs/ 找到。它是一个支持异步 I/O 的功能 GUI 框架,还具备双向数据绑定等特性,允许你构建反应式小部件,并采用组合原则来构建小部件,而不是我们在构建 hews 时在 gtk 框架中探索的对象模型。作为渲染后端,Azul 使用了 Mozilla 的 Servo 中使用的性能优异的 Webrender 渲染引擎。
其他值得注意的提及包括来自 Piston 开发者组织在 github.com/PistonDevelopers/conrod 的 conrod,以及 github.com/Gekkio/imgui-rs 的 imgui-rs,这是一个为流行的即时模式 ImGUI 框架在 C++ 中的绑定库。
摘要
这是对使用 Rust 进行 GUI 开发的简要概述。本章让我们窥见了当前开发 GUI 应用程序的经验。在撰写本文时,这种体验并不算很好,但有一些新兴的框架,例如 Azul,旨在将这种体验提升到新的水平。
下一章将介绍如何使用调试器查找和修复程序中的错误。
第十七章:调试
本章将介绍调试 Rust 程序的各种方法。在二进制层面,Rust 程序与 C 程序非常相似。这意味着我们可以利用行业标准调试器(如 gdb 和 lldb)的强大遗产,这些调试器用于调试 C/C++程序,并使用相同的工具来调试 Rust 代码。在本章中,我们将交互式地通过一些基本的调试工作流程和 gdb 命令。我们还将介绍将 gdb 调试器与Visual Studio Code(vscode)编辑器集成,以及稍后简要概述另一个名为rr的调试器。
在本章中,我们将涵盖以下主题:
-
调试简介
-
GDB 基础和 Rust 程序的调试
-
GDB 与 Visual Studio Code 的集成
-
RR 调试器——快速概述
调试简介
“如果调试是去除 bug 的过程,那么编程就必须是放置 bug 的过程。” —— Edsger W. Dijkstra
这里是情况:你的程序不工作,你也不知道为什么。为了修复代码中这个神秘的问题,你已经添加了几个打印语句并启用了跟踪日志,但仍然没有成功。不用担心,你不是一个人!每个程序员都曾经遇到过这种情况,并且花费了无数小时寻找那个导致生产混乱的讨厌的 bug。
软件中的错误和偏差被称为 bug,移除它们的行为称为调试。调试是检查软件中故障原因和结果的一种受控和系统化的方法。对于任何希望深入了解其程序行为和运行方式的开发者来说,这是一项必备的技能。然而,没有合适的工具,调试通常不是一项容易的任务,开发者可能会失去对实际 bug 的追踪,甚至可能在错误的地方寻找 bug。我们用于识别软件中 bug 的方法可以极大地影响解决它们所需的时间,并继续在愉快的路径上前进。根据 bug 的复杂程度,调试通常采用以下一种方法:
-
打印行调试:在这种方法中,我们在代码中可能存在 bug 并可能修改应用程序状态的所需位置添加打印语句,并在程序运行时监控输出。这是简单、粗糙且通常有效的,但在某些情况下是不可能的。这项技术不需要额外的工具,每个人都知道如何做。实际上,这是大多数 bug 调试的起点。为了帮助打印行调试,Rust 提供了
Debug特质,我们之前已经多次使用过,以及dbg!、println!和eprintln!宏系列。 -
基于读取-评估-打印循环的调试:像 Python 这样的解释型语言通常自带自己的解释器。解释器为你提供了一个**读取-评估-打印循环(REPL)**界面,你可以将程序加载到交互会话中,并逐步检查变量的状态。这在调试中非常有用,特别是如果你已经正确地将代码模块化,使其可以作为函数独立调用。不幸的是,Rust 没有官方的 REPL,其整体设计也不支持 REPL。然而,miri 项目在这方面做了一些努力,该项目可以在
github.com/solson/miri找到。 -
调试器:采用这种方法,我们在生成的二进制程序中添加特殊的调试符号,并使用外部程序来监控其执行。这些外部程序被称为调试器,其中最流行的是 gdb 和 lldb。它们是调试中最强大和高效的方法,允许你在程序运行时检查大量关于程序细节的信息。调试器让你能够暂停正在运行的程序,并检查其在内存中的状态,以找出引入错误的特定代码行。
前两种方法相当明显,所以我们在这里不需要详细说明。这让我们只剩下了第三种方法:调试器。作为工具,调试器非常容易使用,但它们并不容易理解,并且通常在程序员职业生涯的早期并没有得到适当的介绍。在下一节中,我们将通过一步一步的过程来调试用 gdb 编写的 Rust 程序。但在那之前,让我们先了解一下调试器。
调试器概述
调试器是可以在程序运行时检查程序内部状态的程序,前提是程序已被编译,包括调试符号。它们依赖于进程内省系统调用,如 Linux 中的ptrace。它们允许你在程序运行时暂停程序的执行。为了实现这一点,它们提供了一个名为断点的功能。断点代表运行程序中的暂停点。可以在程序中的任何函数或代码行上设置断点。一旦调试器遇到断点,它就会暂停并等待用户输入进一步的指令。此时,程序没有运行,正处于执行过程中。在这里,你可以检查变量的状态、程序的活动堆栈帧以及其他如程序计数器和汇编指令等事物。调试器还提供了观察点,它们类似于断点,但作用于变量。当变量被读取或写入时,它们会触发并停止执行。
要在程序上使用调试器,我们需要一些先决条件。让我们接下来讨论它们。
调试前的准备工作
编译后的程序或对象文件是一系列零和一,没有从编译它的原始源代码映射。为了使程序能够被调试器检查,我们需要以某种方式将编译的二进制指令映射到源文件。这是通过在编译过程中注入额外的记账符号和仪器代码来完成的,调试器可以随后锁定这些符号。这些符号保存在一个符号表中,其中包含有关程序元素的信息,例如变量、函数和类型的名称。它们遵循一个称为 带有属性记录格式的调试(DWARF)的标准格式,大多数标准调试器都知道如何解析和理解。这些符号使开发者能够检查程序,例如将源代码与运行的二进制文件匹配,保持调用帧、寄存器值和程序内存映射等信息。
要调试我们的程序,我们需要以调试模式编译它。在调试模式下,编译的二进制文件将包含 DWARF 调试格式的调试符号。在这里,二进制文件的大小略有增加,运行速度也较慢,因为它需要在运行时更新调试符号表。当编译 C 程序时,您需要使用 -g 标志来告诉编译器包含调试符号进行编译。使用 Cargo 时,项目的调试构建默认在 target/debug/ 目录下编译,并包含调试符号。
注意:当使用除 Cargo 之外的其他包管理器时,也可以向 rustc 传递 -g 标志。
对发布构建运行调试器也是可能的,但可用的操作选择非常有限。如果您想在发布构建中启用 DWARF 调试符号,可以在 Cargo.toml 中通过修改 profile.release 部分,如下所示:
[profile.release]
debug = true
话虽如此,让我们深入探讨如何设置 gdb。
设置 gdb
要开始使用 gdb,我们首先需要安装它。通常,Linux 系统上默认安装了它,但如果未安装,请参考互联网上的指南来设置您的机器。在 Ubuntu 上,只需运行一个安装命令,例如 apt-get install gdb。在这里,我们将使用 7.11.1 版本的 gdb 进行演示。
虽然 gdb 对 Rust 程序有惊人的支持,但它并没有正确处理一些 Rust 特有的问题,例如获取更整洁的输出。Rust 工具链 rustup 还为 gdb 和 lldb 调试器安装了包装器,分别是 rust-gdb 和 rust-lldb。这样做是为了解决处理 Rust 代码的一些限制,例如为混淆类型获取更整洁的输出以及一些用户定义类型的格式化打印。让我们来探索如何使用 gdb 调试 Rust 程序。
一个示例程序 - buggie
我们需要一个程序来调试以体验 gdb。让我们通过运行cargo new buggie来创建一个新的项目。我们的程序将有一个单独的函数fibonacci,它接受一个usize类型的n位置,并给出第n个斐波那契数。这个函数假设斐波那契数的初始值是0和1。以下代码是整个程序的代码:
1 // buggie/src/main.rs
2
3 use std::env;
4
5 pub fn fibonacci(n: u32) -> u32 {
6 let mut a = 0;
7 let mut b = 1;
8 let mut c = 0;
9 for _ in 2..n {
10 let c = a + b;
11 a = b;
12 b = c;
13 }
14 c
15 }
16
17 fn main() {
18 let arg = env::args().skip(1).next().unwrap();
19 let pos = str::parse::<u32>(&arg).unwrap();
20 let nth_fib = fibonacci(pos);
21 println!("Fibonacci number at {} is {}", pos, nth_fib);
22 }
让我们试运行这个程序:
我们用4作为参数运行了程序,但我们看到输出是0,而应该是3。这里有一个错误。虽然我们可以使用println!或dbg!宏轻松解决这个问题,但这次我们将使用 gdb。
在我们运行 gdb 之前,我们需要规划我们的调试会话。这包括决定在程序中查看哪些部分以及要查找什么。作为一个起点,我们将检查main函数的内容,然后进入fibonacci函数。我们将设置两个断点,一个在main中,另一个在fibonacci内部。
gdb 基础知识
我们将再次运行我们的程序,这次使用 gdb 通过rust-gdb包装器运行rust-gdb --args target/debug/buggie 4。--args标志用于将参数传递给程序。这里我们传递了数字4。以下是 gdb 的输出:
在加载我们的程序后,gdb 将我们带到(gdb)提示符。在这个时候,程序还没有运行——它只是被加载了。让我们快速查看 gdb 功能的范围。尝试使用help命令(显示命令的高级部分)和help all命令(显示所有可用命令的帮助信息):
好吧,所以看起来 gdb 可以做很多事情:这里有32页的命令。接下来,让我们在 gdb 提示符上调用run来运行程序并查看结果:
这就是我们的程序在 gdb 上下文中的运行方式。正如你所见,中间部分,我们得到了第四个斐波那契数的相同错误输出0。我们现在将调试这个问题。通过按Ctrl + L来清除屏幕。我们也可以通过调用q来退出 gdb,然后通过运行rust-gdb --args target/debug/buggie 4来重新开始。
在我们的调试会话的起点,为了查看我们是否向斐波那契函数传递了正确的数字,我们将在main的开始处添加一个断点,即我们程序中的第18行。为了在该行添加断点,我们将运行以下代码:
(gdb) break 18
这给我们以下输出:
Breakpoint 1 at 0x9147: file src/main.rs, line 18.
现在 gdb 已经在我们请求的同一行设置了断点,即18。让我们通过调用run来运行我们的程序:
(gdb) run
这给我们以下输出:
(gdb) run
Starting program: /home/creativcoder/buggie/target/debug/buggie 4
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
Breakpoint 1, buggie::main::h8018d7420dbab31b () at src/main.rs:18
18 let arg = env::args().skip(1).next().unwrap();
(gdb)
现在我们的程序在断点处暂停,等待其下一条指令。
你会看到 Rust 的符号前面带有它们的模块名,后面跟着一些随机 ID,例如,buggie::main::h8018d7420dbab31。现在,为了查看我们在程序中的位置,我们可以运行list命令来查看源代码,或者我们可以通过运行以下代码来使用更直观的 TUI 模式:
(gdb) tui enable
这将打开 gdb,并有一些不错的反馈,同时我们的命令提示符仍然在底部:
如你所见,TUI 指示我们在第 18 行有一个断点,符号为B+>。我们可以通过 TUI 面板中的代码列表来滚动查看我们的整个源代码。
注意:如果 TUI 屏幕渲染不正确,你可以输入refresh并重新绘制面板和代码列表。
现在,我们将逐行通过我们的程序。为此,我们有两个可用的命令:next和step。第一个是逐行运行程序,而step允许你跳入函数并逐行执行其中的指令。我们想使用next,这将带我们到下一行 19,而不是进入 Rust 标准库 API 调用的细节。运行以下代码:
(gdb) next
在达到斐波那契函数之前,我们还需要做两次这样的操作。我们可以通过在键盘上按Enter键来运行最后一个命令。在这种情况下,按Enter键两次将运行下一行代码。现在,我们就在斐波那契调用的前面:
在我们进入斐波那契函数之前,让我们检查pos变量,确保它不是一些垃圾或0。我们可以使用print命令来做这件事:
(gdb) print pos
$1 = 4
(gdb)
好的,我们的pos是正确的。现在,我们处于第 20 行,正好在我们调用fibonacci之前。现在,使用step命令进入fibonacci函数:
(gdb) step
我们现在在第 6 行:
接下来,让我们逐行执行代码。当我们正在斐波那契函数中逐行执行代码时,我们可以使用info locals和info args命令来检查变量:
(gdb) info locals
iter = Range<u32> = {start = 3, end = 4}
c = 0
b = 1
a = 1
(gdb) info args
n = 4
(gdb)
前面的输出显示了第三次迭代的iter变量。下一行显示了函数中使用的所有其他变量。我们可以看到,在每次迭代中,c变量都被重新赋值为0。这是因为我们有let c = a + b;,它遮蔽了在循环外部声明的c变量。Rust 允许你使用相同的名称重新声明一个变量。我们在这里找到了我们的错误。
我们将通过删除c的重新声明来移除我们的错误。斐波那契函数变为以下形式:
pub fn fibonacci(n: u32) -> u32 {
let mut a = 0;
let mut b = 1;
let mut c = 0;
for _ in 2..n {
c = a + b;
a = b;
b = c;
}
c
}
因此,让我们再次运行这个程序。这次,我们将不带 gdb 调试器运行它:
现在我们得到了正确的输出,即第四个斐波那契数的2。这些都是使用 gdb 调试 Rust 代码的基本知识。
与 gdb 类似,lldb 是另一个与 Rust 兼容的调试器。
接下来,让我们看看如何将 gdb 与代码编辑器集成。
Visual Studio Code 的调试器集成
使用命令行中的调试器是调试程序的一种常见方式。这也是一项重要的技能,因为您可能会遇到更高级的编码平台不可用的情况。例如,您可能需要调试一个已经在生产中运行的程序。使用 gdb 和 lldb 都可以附加到正在运行的进程,但您可能无法从您的编辑器中附加到正在运行的程序。
然而,在典型的开发环境设置中,您会使用代码编辑器或 IDE,如果您可以直接从编辑器调试程序而不离开编辑器,这将非常方便。这样,您将获得一个与调试器正确集成的编辑器提供的更流畅的调试体验和更快的反馈循环。在本节中,我们将探讨如何将 gdb 集成到 vscode 中。
要在 vscode 中设置 gdb,我们需要安装 Native Debug 扩展。在打开我们的 vscode 编辑器后,我们将按 Ctrl + Shift + P 并输入 install extension。或者,您可以选择左下角的扩展图标,如图所示,并输入 native debug。通过这样做,我们将获得 Native Debug 扩展的页面:
我们将点击安装并等待安装完成。一旦扩展被安装,我们将点击重新加载以重新启动 Visual Studio Code。这将启用任何新安装的扩展。接下来,我们将在 vscode 中打开我们的 buggie 目录,点击顶部的 调试 菜单,并选择 开始调试,如图所示:
从这里开始,我们将被要求选择一个环境,如下所示:
NativeDebug 扩展支持 gdb 和 lldb。我们将从这个菜单中选择 gdb。这将打开一个新的 launch.json 配置文件,用于配置本项目的调试会话。它位于同一项目根目录下的 .vscode/ 目录中。如果它没有打开,我们可以手动创建一个包含 launch.json 的 .vscode/ 目录。我们将用以下配置填充这个 launch.json:
// buggie/.vscode/launch.json
{
"version": "0.2.0",
"configurations": [
{
"name": "Buggie demo",
"type": "gdb",
"request": "launch",
"target": "target/debug/buggie",
"cwd": "${workspaceRoot}",
"arguments": "4",
"gdbpath": "rust-gdb",
"printCalls": true
}
]
}
launch.json 文件为 gdb 和 vscode 设置了重要的详细信息,例如要调用的目标和使用参数。在其他大多数情况下,其他字段将自动为您填充。我们项目的特定配置如下:
-
我们给我们的配置添加了一个名称,即
"Buggie demo"。 -
我们添加了一个指向
rust-gdb的gdbpath变量。这将通过rust-gdb包装器启动gdb,该包装器知道如何在 Rust 中格式化打印复杂的数据类型。 -
我们将
target字段指向我们的调试二进制文件,即target/debug/buggie。
我们将保存此文件。接下来,让我们在编辑器中为我们的程序添加一个断点。我们可以通过在 vscode 中的文本区域左侧单击来实现,如下面的截图所示:
在前面的截图中,如果您将鼠标悬停在左侧,您将看到一个淡红色的标记出现。我们可以点击此标记的左侧来设置断点,然后它将显示为红色的小点。一旦我们完成设置,我们将按 F5 键在 vscode 中启动 gdb。一旦 gdb 运行并遇到我们的断点,我们的代码编辑器将看起来像这样:
在顶部中心,我们可以看到常用的控件,例如单步执行、进入或暂停/停止代码中的调试。在左侧面板中,我们可以获取有关当前堆栈帧中变量的信息。在左下角,我们有关于我们的调用堆栈的信息。在左侧中间,我们可以监视任何变量。在上面的代码中,我添加了对我们的 c 变量的监视。
程序现在暂停在第 9 行。我们还可以将鼠标悬停在代码中的变量上以查看它们的值,如下面的截图所示:
这非常有帮助。这些都是使用 vscode 与 gdb 配合使用的基础知识。接下来,让我们简要概述另一个在调试多线程代码时非常有用的调试器:RR 调试器。
RR 调试器 – 快速概述
除了 gdb 和 lldb,rr 是另一个在调试多线程代码时非常有用的强大调试器,由于它的非确定性,调试起来比较困难。通常,在调试多线程代码时,某个代码段会触发一个错误,但在程序后续执行中无法重现。
由于多线程代码引起的错误也被称为海森堡错误。
RR 调试器可以为非确定性的多线程代码执行可重现的调试会话。它是通过记录调试会话来实现的,您可以回放并逐步跟踪以缩小问题范围。它是通过首先将程序的跟踪保存到磁盘上,并包含所有重现程序执行所需的信息来做到这一点的。
RR 的一个限制是,目前它只支持 Linux 和 Intel CPU。要在 Ubuntu 16.04 上设置 RR 调试器,我们将从 github.com/mozilla/rr/releases 拉取最新的 .deb 软件包。在撰写本文时,rr 版本为 5.2.0。下载完 deb 软件包后,我们可以通过运行以下代码来安装 rr:
sudo dpkg -i https://github.com/mozilla/rr/releases/download/5.2.0/rr-5.2.0-Linux-x86_64.deb
注意:安装 perf 工具是先决条件。你可以按照以下步骤安装它们:
sudo apt-get install linux-tools-4.15.0-43-generic
根据您的内核版本,将linux-tools-(version)替换为适用版本。您可以在 Linux 上使用uname -a命令获取内核版本。另一个先决条件是将sysctl标志在perf_event_paranoid中从3更改为-1。建议您通过运行以下代码临时设置此标志:
sudo sysctl -w kernel.perf_event_paranoid=-1
完成这些后,让我们快速通过运行cargo new rr_demo来创建一个新的项目,并使用 rr 进行调试会话。我们将探索如何使用 rr 调试器对示例程序进行调试,该程序演示了非确定性。我们将依赖rand包,我们可以通过运行cargo add rand将其添加到Cargo.toml文件中。在我们的main.rs文件中有以下代码:
// rr_demo/src/main.rs
use rand::prelude::*;
use std::thread;
use std::time::Duration;
fn main() {
for i in 0..10 {
thread::spawn(move || {
let mut rng = rand::thread_rng();
let y: f64 = rng.gen();
let a: u64 = rand::thread_rng().gen_range(0, 100);
thread::sleep(Duration::from_millis(a));
print!("{} ", i);
});
}
thread::sleep(Duration::from_millis(1000));
println!("Hello, world!");
}
这是一个最小化、非确定性的程序,它启动10个线程并将它们打印到标准输出。为了突出 rr 的可重复性方面,我们将启动线程并随机休眠。
首先,我们需要使用 rr 记录程序的执行。这是通过运行以下代码完成的:
rr record target/debug/rr_demo
这给我们以下输出:
在我的机器上,程序执行跟踪被记录并存储在以下位置:
rr: Saving execution to trace directory `/home/creativcoder/.local/share/rr/rr_demo-15'
记录的文件,rr_demo-15,在您的机器上可能被命名为不同的名称。现在我们可以通过运行以下代码来重新播放记录的程序:
rr replay -d rust-gdb /home/creativcoder/.local/share/rr/rr_demo-15
以下是在 rr 下运行 gdb 的会话:
如您所见,每次运行程序时都会打印出相同的数字序列,因为程序是从上一次运行中记录的会话中运行的。这有助于调试多线程程序,其中线程运行顺序混乱,并且您下次运行程序时可能无法重现错误。
摘要
在本章中,我们通过使用 GNU 的gdb和现有的调试器来手动调试 Rust 代码。我们还配置了 gdb 与 vscode,为我们提供了一个方便的基于点击的 UI 来调试我们的代码。最后,我们了解到了 rr 调试器如何使多线程代码的调试变得确定性。
通过这种方式,我们结束了使用 Rust 的编程之旅。
3688



被折叠的 条评论
为什么被折叠?



