salvo
v0.74.3
Inglês 简体中文 繁體中文
O Salvo é uma estrutura de back -end de ferrugem extremamente simples e poderosa. Somente o conhecimento básico de ferrugem é necessário para desenvolver serviços de back -end.
Você pode visualizar amostras aqui ou visualizar o site oficial.
São necessárias apenas algumas linhas de código para implementar um servidor que suporta o ACME para obter automaticamente os certificados e suporta protocolos HTTP1, HTTP2 e HTTP3.
use salvo :: prelude :: * ;
# [ handler ]
async fn hello ( res : & mut Response ) {
res . render ( Text :: Plain ( "Hello World" ) ) ;
}
# [ tokio :: main ]
async fn main ( ) {
let mut router = Router :: new ( ) . get ( hello ) ;
let listener = TcpListener :: new ( "0.0.0.0:443" )
. acme ( )
. add_domain ( "test.salvo.rs" ) // Replace this domain name with your own.
. http01_challenge ( & mut router ) . quinn ( "0.0.0.0:443" ) ;
let acceptor = listener . join ( TcpListener :: new ( "0.0.0.0:80" ) ) . bind ( ) . await ;
Server :: new ( acceptor ) . serve ( router ) . await ;
}Não há diferença entre um manipulador e um middleware, um middleware é apenas um manipulador. Você pode escrever middleware sem conhecer conceitos como tipos associados e tipos genéricos. Se você pode escrever uma função, pode escrever middleware !!!
use salvo :: http :: header :: { self , HeaderValue } ;
use salvo :: prelude :: * ;
# [ handler ]
async fn add_header ( res : & mut Response ) {
res . headers_mut ( )
. insert ( header :: SERVER , HeaderValue :: from_static ( "Salvo" ) ) ;
}Em seguida, adicione -o ao roteador:
Router :: new ( ) . hoop ( add_header ) . get ( hello ) Este é um middleware muito simples, adiciona um Header à Response , visualize o código -fonte completo.
Normalmente, escrevemos roteamento assim:
Router :: with_path ( "articles" ) . get ( list_articles ) . post ( create_article ) ;
Router :: with_path ( "articles/<id>" )
. get ( show_article )
. patch ( edit_article )
. delete ( delete_article ) ;Freqüentemente, algo como visualizar artigos e listas de artigos não requer login de usuário, mas criando, editando, excluindo artigos etc. exigem permissões de autenticação de login de usuário. O sistema de roteamento semelhante a uma árvore em Salvo pode atender a essa demanda. Podemos escrever roteadores sem login de usuário juntos:
Router :: with_path ( "articles" )
. get ( list_articles )
. push ( Router :: with_path ( "<id>" ) . get ( show_article ) ) ;Em seguida, escreva os roteadores que exigem que o usuário faça login juntos e use o middleware correspondente para verificar se o usuário está conectado:
Router :: with_path ( "articles" )
. hoop ( auth_check )
. push ( Router :: with_path ( "<id>" ) . patch ( edit_article ) . delete ( delete_article ) ) ; Embora essas duas rotas tenham o mesmo path("articles") , elas ainda podem ser adicionadas à mesma rota pai ao mesmo tempo, então a rota final se parece com a seguinte:
Router :: new ( )
. push (
Router :: with_path ( "articles" )
. get ( list_articles )
. push ( Router :: with_path ( "<id>" ) . get ( show_article ) ) ,
)
. push (
Router :: with_path ( "articles" )
. hoop ( auth_check )
. push ( Router :: with_path ( "<id>" ) . patch ( edit_article ) . delete ( delete_article ) ) ,
) ; <id> corresponde a um fragmento no caminho, em circunstâncias normais, o id do artigo é apenas um número, que podemos usar expressões regulares para restringir as regras de correspondência de id , r"<id:/d+/>" .
Você também pode usar <**> , <*+> ou <*?> Para corresponder a todos os fragmentos de caminho restantes. Para tornar o código mais legível, você também pode adicionar o nome apropriado para tornar a semântica do caminho mais clara, por exemplo: <**file_path> .
Algumas expressões regulares para os caminhos correspondentes precisam ser usados com frequência e podem ser registrados com antecedência, como Guid:
PathFilter :: register_wisp_regex (
"guid" ,
Regex :: new ( "[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}" ) . unwrap ( ) ,
) ;Isso o torna mais conciso quando a correspondência de caminhos é necessária:
Router :: with_path ( "<id:guid>" ) . get ( index )Veja o código -fonte completo
Podemos obter o arquivo assíncrono pelo file de função na Request :
# [ handler ]
async fn upload ( req : & mut Request , res : & mut Response ) {
let file = req . file ( "file" ) . await ;
if let Some ( file ) = file {
let dest = format ! ( "temp/{}" , file . name ( ) . unwrap_or_else ( || "file" . into ( ) ) ) ;
if let Err ( e ) = tokio :: fs :: copy ( & file . path , Path :: new ( & dest ) ) . await {
res . status_code ( StatusCode :: INTERNAL_SERVER_ERROR ) ;
} else {
res . render ( "Ok" ) ;
}
} else {
res . status_code ( StatusCode :: BAD_REQUEST ) ;
}
}Você pode facilmente obter dados de várias fontes de dados diferentes e montá -los no tipo que deseja. Você pode definir um tipo personalizado primeiro, por exemplo:
# [ derive ( Serialize , Deserialize , Extractible , Debug ) ]
/// Get the data field value from the body by default.
# [ salvo ( extract ( default_source ( from = "body" ) ) ) ]
struct GoodMan < ' a > {
/// The id number is obtained from the request path parameter, and the data is automatically parsed as i64 type.
# [ salvo ( extract ( source ( from = "param" ) ) ) ]
id : i64 ,
/// Reference types can be used to avoid memory copying.
username : & ' a str ,
first_name : String ,
last_name : String ,
} Então, no Handler você pode obter dados como este:
# [ handler ]
async fn edit ( req : & mut Request ) {
let good_man : GoodMan < ' _ > = req . extract ( ) . await . unwrap ( ) ;
}Você pode até passar o tipo diretamente para a função como um parâmetro, assim:
# [ handler ]
async fn edit < ' a > ( good_man : GoodMan < ' a > ) {
res . render ( Json ( good_man ) ) ;
}Veja o código -fonte completo
O suporte perfeito para o OpenAPI pode ser alcançado sem fazer alterações significativas no projeto.
# [ derive ( Serialize , Deserialize , ToSchema , Debug ) ]
struct MyObject < T : ToSchema + std :: fmt :: Debug > {
value : T ,
}
# [ endpoint ]
async fn use_string ( body : JsonBody < MyObject < String > > ) -> String {
format ! ( "{:?}" , body )
}
# [ endpoint ]
async fn use_i32 ( body : JsonBody < MyObject < i32 > > ) -> String {
format ! ( "{:?}" , body )
}
# [ endpoint ]
async fn use_u64 ( body : JsonBody < MyObject < u64 > > ) -> String {
format ! ( "{:?}" , body )
}
# [ tokio :: main ]
async fn main ( ) {
tracing_subscriber :: fmt ( ) . init ( ) ;
let router = Router :: new ( )
. push ( Router :: with_path ( "i32" ) . post ( use_i32 ) )
. push ( Router :: with_path ( "u64" ) . post ( use_u64 ) )
. push ( Router :: with_path ( "string" ) . post ( use_string ) ) ;
let doc = OpenApi :: new ( "test api" , "0.0.1" ) . merge_router ( & router ) ;
let router = router
. push ( doc . into_router ( "/api-doc/openapi.json" ) )
. push ( SwaggerUi :: new ( "/api-doc/openapi.json" ) . into_router ( "swagger-ui" ) ) ;
let acceptor = TcpListener :: new ( "127.0.0.1:5800" ) . bind ( ) . await ;
Server :: new ( acceptor ) . serve ( router ) . await ;
}O SALVO CLI é uma ferramenta de linha de comando que simplifica a criação de novos projetos de Salvo, suporte a modelos de APIs da Web, sites, bancos de dados (incluindo SQLite, PostgreSQL e MySQL via SQLX, Seaorm, Diesel, RBATIS) e Middleware básico. Você pode usar o salvo-cli para criar um novo projeto Salvo:
cargo install salvo-clisalvo new project_nameVocê pode encontrar mais exemplos na pasta Exemplos. Você pode executar esses exemplos com o seguinte comando:
cd examples
cargo run --bin example-basic-auth Você pode usar qualquer exemplo de nome que deseja executar em vez de basic-auth aqui.
O resultado dos testes de referência pode ser encontrado a partir daqui:
https://web-frameworks-benchmark.netlify.app/result?l=rust
https://www.techempower.com/benchmarks/#section=data-r22
Salvo é um projeto de código aberto. Se você quiser apoiar a Salvo, pode me comprar um café aqui .
Salvo está licenciado em qualquer um dos
Licença Apache, versão 2.0, (licença-apache ou http://www.apache.org/license/license-2.0).
MIT License (licença-mit ou http://opensource.org/license/mit).
