李成笔记网

专注域名、站长SEO知识分享与实战技巧

2024年12月12日

构建一个rust生产应用读书笔记四(实战4)

上一节我们已经将数据的基本配置完成，这一节我们继续完成邮件订阅功能的开发，这两天按照书中的代码编写终于调试成功了，把这其中遇到的问题总结记录下来

版本问题

在调试的过程中遇到了各种各样的版本问题，目前这个版本依赖可以编译通过，如果在学习过程中也遇到syn，macors等版本问题，可以参考如下版本

Cargo.toml

[package]
name = "zero2prod"
version = "0.1.0"
edition = "2021"

[lib]
path = "src/lib.rs"

[[bin]]
path = "src/main.rs"
name = "zero2prod"

[dependencies]
actix-web = "4"
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
serde = "1.0.115"
config = { version = "0.14", default-features = false, features = ["yaml"] }
sqlx = { version = "0.8", default-features = false, features = [
  "runtime-tokio-rustls",
  "macros",
  "postgres",
  "uuid",
  "chrono",
  "migrate",
] }
uuid = { version = "1", features = ["v4"] }
chrono = { version = "0.4.22", default-features = false, features = ["clock"] }

[dev-dependencies]
reqwest = { version = "0.12", features = ["json"] }

# On MacOS, `brew install michaeleisel/zld/zld`
# [target.x86_64-apple-darwin]
# rustflags = ["-C", "link-arg=-fuse-ld=/usr/local/bin/zld"]
# [target.aarch64-apple-darwin]
# rustflags = ["-C", "link-arg=-fuse-ld=/usr/local/bin/zld"]

有时候还会遇到编译问题，我通常执行cargo clean, cargo update来解决。

有时候，更新到最新版本的 Cargo 和 Rust 工具链也可以解决构建问题

执行

rustup update

使用配置文件yaml

在实际的项目中，将数据库的配置文件，服务器的ip端口统一在配置文件里面管理，方便应用部署的时候根据实际的情况调整

// ! configuration.yaml
application_port: 8000
database:
  host: '127.0.0.1'
  port: 5432
  username: 'postgres'
  password: 'postgres'
  database_name: 'newsletter'

配置文件读取

//! src/configuration
#[derive(serde::Deserialize)]
pub struct Settings {
    pub database: DatabaseSettings,
    pub application_port: u16,
}

#[derive(serde::Deserialize, Clone)]
pub struct DatabaseSettings {
    pub username: String,
    pub password: String,
    pub port: u16,
    pub host: String,
    pub database_name: String,
}

pub fn get_configuration() -> Result<Settings, config::ConfigError> {
    let settings = config::Config::builder()
        .add_source(config::File::new(
            "configuration.yaml",
            config::FileFormat::Yaml,
        ))
        .build()?;
    settings.try_deserialize::<Settings>()
}

impl DatabaseSettings {
    pub fn connection_string(&self) -> String {
        format!(
            "postgres://{}:{}@{}:{}/{}",
            self.username, self.password, self.host, self.port, self.database_name
        )
    }
}

函数说明

get_configuration 函数用于从 configuration.yaml 文件中读取配置，并将其解析为 Settings 结构体。

  • 使用 config::Config::builder() 创建一个配置构建器。
  • 使用 add_source 方法添加一个配置源，这里指定了配置文件的路径和格式（YAML）。
  • 调用 build 方法构建配置对象，因依赖库版本升级后原文提供的方法已过时，和这里不一样但实现功能一样。
  • 使用 try_deserialize 方法将配置对象反序列化为 Settings 结构体。
  • 如果任何步骤失败，函数将返回一个 Result 类型的 Err 变体，其中包含 config::ConfigError。

注意的是：struct都要记得加上序列化attribute

lib.rs

在 lib.rs 文件中声明模块是常见的方式, 这些模块通常是项目中不同功能的逻辑划分,根据当前应用分成3个模块

pub mod configuration;
pub mod routes;
pub mod startup;

routes

根据之前的代码，我们把代码重构,将health_check() 挪到health_check.rs中

//! src/routes/health_check.rs
use actix_web::HttpResponse;

pub async fn health_check() -> HttpResponse {
    HttpResponse::Ok().finish()
}

routes 模块化

//! src/routes/mod.rs
mod health_check;
mod subscriptions;

pub use health_check::*;
pub use subscriptions::*;

重构subscriptions.rs，把订购的用户信息存入到数据库中

use core::result::Result::{Err, Ok};

use actix_web::{web, HttpResponse};
use chrono::Utc;
use sqlx::PgPool;
use uuid::Uuid;

#[derive(serde::Deserialize)]
pub struct FormData {
    email: String,
    name: String,
}

pub async fn subscribe(form: web::Form<FormData>, pool: web::Data<PgPool>) -> HttpResponse {
    match sqlx::query!(
        r#"insert into subscriptions (id,email,name,subscribed_at) values($1,$2,$3,$4)"#,
        Uuid::new_v4(),
        form.email,
        form.name,
        Utc::now()
    )
    .execute(pool.as_ref())
    .await
    {
        Ok(_) => HttpResponse::Ok().finish(),
        Err(e) => {
            print!("Failed to execute query:{}", e);
            HttpResponse::InternalServerError().finish()
        }
    }
}

代码说明

  • subscribe 函数是一个异步处理函数，用于处理用户订阅请求。
  • form: web::Form<FormData>: 接收一个 web::Form<FormData> 类型的参数，类似于DTO对象，表示从 HTTP 请求中解析出来的表单数据。
  • pool: web::Data<PgPool>: 接收一个 web::Data<PgPool> 类型的参数，表示数据库连接池。
  • sqlx::query! 宏用于构建 SQL 查询，并绑定参数。该方法是一种预处理sql的方式。
  • Uuid::new_v4(): 生成一个唯一的 UUID 作为订阅 ID。
  • Utc::now(): 获取当前的 UTC 时间，用于记录订阅时间。
  • execute(pool.as_ref()): 执行 SQL 查询，并传递数据库连接池的引用，传递引用可以避免不必要的克隆操作，提高性能。PgPool 本身是一个较重的对象，包含了许多内部状态和资源管理逻辑。如果每次调用 execute 都克隆一次 PgPool，不仅会增加内存开销，还可能导致性能下降。而且你可以在不改变所有权的情况下使用资源。
  • match 表达式用于处理查询结果：
  • 如果查询成功（Ok），返回 HttpResponse::Ok().finish()，表示请求处理成功。
  • 如果查询失败（Err），打印错误信息并返回 HttpResponse::InternalServerError().finish()，表示服务器内部错误。

主函数

//! main.rs
use sqlx::postgres::PgPool;
use std::net::TcpListener;
use zero2prod::configuration::get_configuration;
use zero2prod::startup::run;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let configuration = get_configuration().expect("Failed to read configuration.");
    let connection_pool = PgPool::connect(&configuration.database.connection_string())
        .await
        .expect("Failed to connect to Postgres.");

    let address = format!("127.0.0.1:{}", configuration.application_port);
    let listener = TcpListener::bind(address)?;
    run(listener, connection_pool)?.await?;
    Ok(())
}


startup里面监听和路由注册

use crate::routes::{ health_check, subscribe };
use actix_web::dev::Server;
use actix_web::web::Data;
use actix_web::{ web, App, HttpServer };
use sqlx::PgPool;
use std::net::TcpListener;

pub fn run(listener: TcpListener, db_pool: PgPool) -> Result<Server, std::io::Error> {
    let db_pool = Data::new(db_pool);
    let server = HttpServer::new(move || {
        App::new()
            .route("/health_check", web::get().to(health_check))
            .route("/subscriptions", web::post().to(subscribe))
            .app_data(db_pool.clone())
    })
        .listen(listener)?
        .run();
    Ok(server)
}

函数说明

  • run 函数是一个启动 HTTP 服务器的函数，它接受一个 TcpListener 和一个 PgPool 作为参数。
  • let db_pool = Data::new(db_pool);: 将 PgPool 包装成 Data 类型，以便在应用中共享。
  • HttpServer::new(move || { ... }): 创建一个新的 HttpServer 实例，并传入一个闭包来配置应用。前面的文章提到过，闭包暂时可以理解为java中的lambda表达式
  • move || { ... }: 使用 move 关键字将闭包内的变量捕获到闭包中，确保闭包拥有这些变量的所有权。
  • App::new(): 创建一个新的 App 实例。
  • .route("/health_check", web::get().to(health_check)): 配置一个 GET 路由 /health_check，并将其映射到 health_check 处理函数。
  • .route("/subscriptions", web::post().to(subscribe)): 配置一个 POST 路由 /subscriptions，并将其映射到 subscribe 处理函数。
  • .app_data(db_pool.clone()): 将 db_pool 作为应用数据注册到 App 中，使其在处理函数中可用。

代码改进

以上代码在测试的过程中可以做如下的改进，后面会继续优化

  1. 日志记录：添加日志记录，以便在启动和运行时记录重要信息。
  2. 错误处理：使用更详细的错误处理和日志记录，以便更好地调试和监控。
  3. 配置文件：确保配置文件路径和格式正确，避免因配置文件问题导致启动失败。

测试结果

运行cargo run

在api调试工具中添加email和name参数

添加图片注释，不超过 140 字（可选）

查看数据库结果

添加图片注释，不超过 140 字（可选）

单元测试代码

use sqlx::{Connection, Executor, PgConnection, PgPool};
use std::net::TcpListener;
use uuid::Uuid;
use zero2prod::configuration::{get_configuration, DatabaseSettings};
use zero2prod::startup::run;

pub struct TestApp {
    pub address: String,
    pub db_pool: PgPool,
}

async fn spawn_app() -> TestApp {
    let listener = TcpListener::bind("127.0.0.1:0").expect("Failed to bind random port");
    // We retrieve the port assigned to us by the OS
    let port = listener.local_addr().unwrap().port();
    let address = format!("http://127.0.0.1:{}", port);

    let mut configuration = get_configuration().expect("Failed to read configuration.");
    configuration.database.database_name = Uuid::new_v4().to_string();
    let connection_pool = configure_database(&configuration.database).await;

    let server = run(listener, connection_pool.clone()).expect("Failed to bind address");
    let _ = tokio::spawn(server);
    TestApp {
        address,
        db_pool: connection_pool,
    }
}

pub async fn configure_database(config: &DatabaseSettings) -> PgPool {
    // Create database
    let maintenance_settings = DatabaseSettings {
        database_name: "postgres".to_string(),
        username: "postgres".to_string(),
        password: "password".to_string(),
        ..config.clone()
    };

    let mut connection = PgConnection::connect(&maintenance_settings.connection_string())
        .await
        .expect("Failed to connect to Postgres");
    connection
        .execute(format!(r#"CREATE DATABASE "{}";"#, config.database_name).as_str())
        .await
        .expect("Failed to create database.");

    // Migrate database
    let connection_pool = PgPool::connect(&config.connection_string())
        .await
        .expect("Failed to connect to Postgres.");
    sqlx::migrate!("./migrations")
        .run(&connection_pool)
        .await
        .expect("Failed to migrate the database");
    connection_pool
}

#[tokio::test]
async fn health_check_works() {
    // Arrange
    let app = spawn_app().await;
    let client = reqwest::Client::new();

    // Act
    let response = client
        // Use the returned application address
        .get(&format!("{}/health_check", &app.address))
        .send()
        .await
        .expect("Failed to execute request.");

    // Assert
    assert!(response.status().is_success());
    assert_eq!(Some(0), response.content_length());
}

#[tokio::test]
async fn subscribe_returns_a_200_for_valid_form_data() {
    // Arrange
    let app = spawn_app().await;
    let client = reqwest::Client::new();
    let body = "name=le%20guin&email=ursula_le_guin%40gmail.com";

    // Act
    let response = client
        .post(&format!("{}/subscriptions", &app.address))
        .header("Content-Type", "application/x-www-form-urlencoded")
        .body(body)
        .send()
        .await
        .expect("Failed to execute request.");

    // Assert
    assert_eq!(200, response.status().as_u16());

    let saved = sqlx::query!("SELECT email, name FROM subscriptions",)
        .fetch_one(&app.db_pool)
        .await
        .expect("Failed to fetch saved subscription.");

    assert_eq!(saved.email, "ursula_le_guin@gmail.com");
    assert_eq!(saved.name, "le guin");
}

#[tokio::test]
async fn subscribe_returns_a_400_when_data_is_missing() {
    // Arrange
    let app = spawn_app().await;
    let client = reqwest::Client::new();
    let test_cases = vec![
        ("name=le%20guin", "missing the email"),
        ("email=ursula_le_guin%40gmail.com", "missing the name"),
        ("", "missing both name and email"),
    ];

    for (invalid_body, error_message) in test_cases {
        // Act
        let response = client
            .post(&format!("{}/subscriptions", &app.address))
            .header("Content-Type", "application/x-www-form-urlencoded")
            .body(invalid_body)
            .send()
            .await
            .expect("Failed to execute request.");

        // Assert
        assert_eq!(
            400,
            response.status().as_u16(),
            // Additional customised error message on test failure
            "The API did not fail with 400 Bad Request when the payload was {}.",
            error_message
        );
    }
}


总结

总体来说，rust 是非常不错的一门编程语言，但是门槛稍微有点高，通过实战吸取经验确实是一种非常不错的方法，欢迎大家评论区评论

标签：net::err_connection_refused翻译 

作者:lichen , 分类:站长日记 , 浏览:29 , 评论:0

发表评论:

控制面板
您好，欢迎到访网站！
  查看权限
网站分类
最新留言