APIs assíncronas e síncronas

Visão geral

Neste guia, você aprenderá sobre as APIsassíncronas e síncronas do driver Rust. Este guia explica como habilitar as APIs disponíveis e estruturar seu código para usar cada uma.

O driver Rust oferece suporte a tokio e async-std, duas caixas de tempo de execução assíncronas populares. Por padrão, o driver usa o tempo de execução assíncrono tokio , mas você pode selecionar um tempo de execução específico adicionando sinalizadores de recursos à dependência mongodb em seu arquivo Cargo.toml .

O driver também inclui uma API síncrona para casos de uso que exigem bloqueio ou quando o paralelismo não é necessário. Você pode selecionar a API síncrona adicionando sinalizadores de feição à dependência do mongodb no seu arquivo Cargo.toml .

Configurar o tempo de execução assíncrono

O driver usa o tempo de execução tokio por padrão. Você pode escolher explicitamente um tempo de execução adicionando os sinalizadores de feição "tokio-runtime" ou "async-std-runtime" à dependência mongodb .

Selecione nas abas a seguir para ver como adicionar sinalizadores de feições para cada caixa correspondente:

[dependencies.mongodb]
version = "2.8.2"
features = ["tokio-runtime"]

[dependencies.mongodb]
version = "2.8.2"
default-features = false
features = ["async-std"]

Para obter mais informações sobre como instalar o driver e adicionar sinalizadores de recurso, consulte a etapa Download e instalação do Início rápido.

Exemplo de tempo de execução do Tokio

O código a seguir usa o módulo task da caixa tokio para criar tarefas simultâneas separadas para várias operações de dados:

let client = Client::with_uri_str("<connection string>").await?;
let some_data = doc! { "title": "1984", "author": "George Orwell" };
for i in 0..5 {
    let client_ref = client.clone();
    let somedata_ref = some_data.clone();
    task::spawn(async move {
        let collection = client_ref
            .database("items")
            .collection::<Document>(&format!("coll{}", i));
        collection.insert_one(somedata_ref, None).await
    });
}

Configurar a API síncrona

O driver também fornece uma API síncrona de bloqueio. Para usar a API síncrona, adicione o sinalizador de feição "sync" ou "tokio-sync" à dependência mongodb .

Selecione nas abas a seguir para ver como adicionar sinalizadores de feições para cada caixa correspondente:

[dependencies.mongodb]
version = "2.8.2"
default-features = false
features = ["sync"]

[dependencies.mongodb]
version = "2.8.2"
default-features = false
features = ["tokio-sync"]

Exemplo de código síncrono

Ao usar a API síncrona, use tipos do módulo mongodb::sync para executar operações. O código abaixo usa o módulo sync para inserir dados em uma collection usando a API síncrona. Quando o método insert_one é executado dentro do loop for , o driver aguarda que cada solicitação seja concluída antes de continuar.

use mongodb::sync::Client;
fn main() {
    let client = Client::with_uri_str("<connection string>")?;
    let some_data = doc! { "title": "1984", "author": "George Orwell" };
    for i in 0..5 {
        let client_ref = client.clone();
        let somedata_ref = some_data.clone();
        let collection = client_ref
            .database("items")
            .collection::<Document>(&format!("coll{}", i));
        collection.insert_one(somedata_ref, None);
    }
}

Usar APIs assíncronas e síncronas

Você pode usar API assíncronas e síncronas na mesma aplicação. Por exemplo, para habilitar ambos os tokio tempos de execução do , você pode adicionar a tokio dependência do à sua lista de dependências e adicionar o "tokio-sync" sinalizador à mongodb dependência do :

[dependencies]
futures = "0.3.28"
tokio = {version = "1.32.0", features = ["full"]}
[dependencies.mongodb]
version = "2.8.2"
features = ["tokio-sync"]

Informações adicionais

Para obter mais informações sobre os conceitos deste guia, consulte as seguintes páginas:

Documentação da API

Para saber mais sobre os métodos e tipos mencionados neste guia, consulte a documentação da API abaixo:

Voltar

Considerações de desempenho

Monitoramento de clusters