Какой веб-фреймворк Rust лучше всего изучить, прежде чем приступать к разработке API и веб-приложений в 2023 году? Здесь мы рассмотрим некоторые из наиболее популярных фреймворков, которые используются в настоящее время или выглядят многообещающе.

Web Framework (WF) или Web Application Framework (WAF) — это программная платформа, предназначенная для поддержки разработки веб-приложений, включая веб-сервисы, веб-ресурсы, микросервисы и веб-API. Веб-фреймворки предоставляют стандартный способ создания и развертывания веб-приложений в Интернете. Веб-фреймворки предназначены для автоматизации накладных расходов, связанных с обычными действиями, выполняемыми при веб-разработке.

Например, многие веб-фреймворки предоставляют библиотеки для доступа к базам данных, структуры шаблонов (HTML, JSON и т. д.) и управления сеансами, а также часто способствуют повторному использованию кода. Хотя они обычно предназначены для разработки динамических веб-сайтов, их также можно использовать для статических веб-сайтов.

Rust — это язык программирования, предлагающий огромный потенциал для веб-разработки. Он быстрый, безопасный и предлагает множество функций, идеально подходящих для создания веб-приложений. Вот некоторые из лучших фреймворков и их особенности, которые следует учитывать при их разработке.

Hyper

Hyper все еще находится в разработке и, скорее всего, выйдет в стабильную версию в 2023 году. Но Hyper выглядит многообещающей средой, которую стоит изучить в 2023 году, прежде чем принять решение о создании веб-приложения на Rust.

Hyper планирует выпустить стабильную версию 1.0 к концу января 2023 года. Если вы хотите узнать больше о переходе на стабильную версию 1.0, следуйте здесь.

Hyper — это быстрая реализация HTTP, написанная на Rust. Гипер можно использовать как:

• Клиент, используемый для связи с веб-службой.
• Сервер, используемый для создания этих веб-сервисов.
• Чрезвычайно высокая скорость отклика
• Имеет высокий уровень параллелизма и неблокирующие сокеты.
• поддерживать HTTP/1 и HTTP/2。

use std::{convert::Infallible, net::SocketAddr, error::Error};
use http_body_util::Full;
use hyper::{Request, Response, body::Bytes, service::service_fn};
use hyper::server::conn::http1;
use tokio::net::TcpListener;

async fn hello(
    _: Request<hyper::body::Incoming>,
) -> Result<Response<Full<Bytes>>, Infallible> {
    Ok(Response::new(Full::new(Bytes::from("Hello World!"))))
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));

    let listener = TcpListener::bind(addr).await?;

    loop {
        let (stream, _) = listener.accept().await?;

        tokio::task::spawn(async move {
            if let Err(err) = http1::Builder::new()
                .serve_connection(stream, service_fn(hello))
                .await
            {
                println!("Error serving connection: {:?}", err);
            }
        });
    }
}

Любой разработчик, использующий платформу Rust API, должен знать Hyper. Он имеет множество функций и прост в использовании. Документация также первоклассная и является отличным учебным ресурсом для новых разработчиков.

Actix-web

Actix Web — это мощный, практичный и невероятно быстрый веб-фреймворк на Rust. Actix Web основан на модели Rust Actor. Это высокопроизводительный веб-фреймворк, написанный на Rust, с мощным набором функций для создания веб-приложений. Actix Web является типобезопасным, многофункциональным, масштабируемым и чрезвычайно быстрым.

сеть его деятельности

• поддержка мультиплекса
• Пешеходный переход ввода/вывода
• сетевая розетка
• Промежуточное программное обеспечение

Ниже приводится письменный ответ Hello World Метод веб-страницы:

use actix_web::{get, web, App, HttpRequest, HttpServer, Responder};

#[get("/")]
async fn index(\_req: HttpRequest) -> impl Responder {
"Hello from the index page."
}

async fn hello(path: web::Path<String>) -> impl Responder {
format!("Hello World {}!", &path)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
App::new()
.service(index)
.route("/{name}", web::get().to(hello))
})
.bind(("127.0.0.1", 8080))?
.run()
.await
}

бегать cargo run Вы можете запустить сервер и просмотреть эффект в браузере.

Rocket

Rocket — это веб-фреймворк для Rust, который делает написание веб-приложений очень простым и быстрым, не жертвуя при этом гибкостью и безопасностью типов. Он не требует использования котлов и легко расширяется.

Rocket Философия да позволяет запускать и разрабатывать с минимальной настройкой. это связано с Rust Экосистема тесно интегрирована, и интегрировать существующие библиотеки и инструменты очень легко.

Ниже приведен пример страницы, развернутой по URL-адресу, которая принимает полезную нагрузку JSON и сохраняет ее в базе данных.

Вот пример реализации веб-страницы: PUT /:id

#[derive(Serialize, Deserialize)]
struct Message<'r> {
   contents: &'r str,
}

#[put("/<id>", data = "<msg>")]
fn update(db: &Db, id: Id, msg: Json<Message<'_>>) -> Value {
    if db.contains_key(&id) {
        db.insert(id, msg.contents);
        json!({ "status": "ok" })
    } else {
        json!({ "status": "error" })
    }
}

Rocket поддерживает шаблоны, имеет специальные руководства и поддерживает асинхронные потоки «из коробки».

Tide

Tide — это минимальный и функциональный фреймворк веб-приложений, построенный на Rust. Tide создан для быстрой веб-разработки. Tide поставляется с мощным набором встроенных функций, которые упрощают создание асинхронных веб-приложений и API. Tide основан на веб-фреймворке Rust Actix.

Tide имеет богатый функционал Web рамка. Прилив Активно развивается,и имеет обширные ресурсы сообщества,Позволяет быстро начать и проектировать

Платформа Tide имеет следующие функции, помогающие быстро создавать приложения.

• асинхронный/ждатьподдерживать
• тип безопасной маршрутизации
• Запросить охрану
• шаблонподдерживать
• Управление сеансами
• сетевая розеткаподдерживать
• Давайте рассмотрим пример реализации конечной точки с помощью команды HTTP POST.

use tide::Request;
use tide::prelude::*;

#[derive(Debug, Deserialize)]
struct Animal {
    name: String,
    legs: u16,
}

#[async_std::main]
async fn main() -> tide::Result<()> {
    let mut app = tide::new();
    app.at("/orders/shoes").post(order_shoes);
    app.listen("127.0.0.1:8080").await?;
    Ok(())
}

async fn order_shoes(mut req: Request<()>) -> tide::Result {
    let Animal { name, legs } = req.body_json().await?;
    Ok(format!("Hello, {}! I've put in an order for {} shoes", name, legs).into())
}

Теперь вы можете использовать curl доступ имеет api /orders/shoes

curl localhost:8080/orders/shoes -d '{ "name": "Pankaj", "legs": 9 }'

Это ответит на ожидаемое сообщение Hello, Pankaj! I've put in an order for 9 shoes

Warp

Warp — это суперпростая компонуемая среда веб-сервера, созданная на основе Rust для обеспечения скорости. Основным строительным блоком Warp является фильтр, который можно комбинировать и составлять для выражения разнообразных требований к запросам.

Благодаря своей системе фильтрации, Warp предлагает готовые функциональные возможности:

• Маршрутизация путей и извлечение параметров
• Требования к заголовку и извлечение
• Десериализация строки запроса
• JSON и тело формы
• данные многочастной формы
• Статические файлы и каталоги
• сетевая розетка
• Доступ к журналу
• Gzip、Deflate и Brotli сжатие
• События, отправленные сервером (SSE)

Поскольку он строит Hyper и Tokio - асинхронный Rust-проект, вы автоматически получаете:

• HTTP/1 и HTTP/2 поддерживать
• асинхронная функция
• Одна из самых быстрых реализаций HTTP
• Проверено и правильно

Вот использование Warp простоты Hello, world Пример:

//main.rs
use warp::Filter;
#[tokio::main]
async fn main() {
    // GET /hello/warp => 200 OK with body "Hello, warp!"
    let hello = warp::path!("hello" / String)
        .map(|name| format!("Hello, {}!", name));

    warp::serve(hello)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

Axum

Axum Web Цель рамы существует эффективно, быстро и легко. Аксум вдохновленный Erlang язык программирования, который обеспечивает разработчикам эффективный параллелизм и идеально подходит для разработки в реальном времени. Web Приложения, микросервисы и системы с низкой задержкой. Аксум индивидуальный акцент на эргономике и модульности Web Каркас приложения.

Для использования Axum вам нужна версия Rust v1.6 или выше.

Особенности Аксума включают в себя:

• Используйте API без макросов для маршрутизации запросов к обработчикам.
• Используйте экстракторы для декларативного анализа запросов.
• Простая и предсказуемая модель обработки ошибок.
• Генерируйте ответы с минимальным шаблоном.
• В полной мере используйте промежуточное программное обеспечение и сервисы Tower-http.
• поддерживать WebSocket и Другие соглашения
• Пешеходный переход ввода/вывода

use actix_web::{web, App, Responder};

fn index() -> impl Responder {

    "Hello, world!"

}

fn main() {

    App::new().route("/", web::get().to(index)).run();

}

Перечисленные выше фреймворки являются всего лишь 2023 Некоторые примечательные события года rust Web Каркас Все они имеют разные дизайнерские возможности. Вы пытаетесь протестировать их и использовать в соответствии с вашими требованиями. .