Menu Docs
Página inicial do Docs
/
MongoDB Atlas
/
Atlas Device SDKs
/
SDK para Java

API assíncrona - SDK Java

Nesta página

  • Chamadas assíncronas
  • Realm.Callback
  • App.Callback
  • RealmAsyncTask
  • RealmResults
  • RealmResultTask
  • Coroutines

O SDK Java permite acessar os recursos de rede e disco de duas maneiras: síncrona e assíncrona. Enquanto as solicitações síncronas, ou "sync", bloqueiam a execução até que a solicitação retorne sucesso ou falha, as solicitações assíncronas, ou "async", atribuem uma chamada de resposta e prosseguem com a execução para a próxima linha de código. Quando o pedido é devolvido, a chamada de resposta é executada para processar os resultados. Na chamada de resposta, você pode verificar se a solicitação foi executada com êxito e acessar os resultados retornados ou o erro retornado.

Chamadas assíncronas

As solicitações de API assíncronas no SDK terminam com o sufixo "Async". Há várias maneiras diferentes de uma solicitação assíncrona se comportar, dependendo de qual parte do SDK você está usando.

Realm.Callback

As chamadas assíncronas para abrir um Realm, com e sem sincronização, use um parâmetro final do tipo Realm.Callback. Para recuperar valores retornados após a conclusão da solicitação, implemente o método onSuccess() no objeto de chamada de resposta de resposta passado como o parâmetro final para esses métodos assíncronos. Você também deve implementar o método onError() para lidar com falhas de solicitação, mas ele não é necessário.

Realm.getInstanceAsync(config, new Realm.Callback() {
    @Override
    public void onSuccess(@NotNull Realm realm) {
        Log.v("EXAMPLE", "Successfully fetched realm instance.");
    }
    public void onError(Exception e) {
        Log.e("EXAMPLE", "Failed to get realm instance: " + e);
    }
});
Realm.getInstanceAsync(config, object : Realm.Callback() {
    override fun onSuccess(realm: Realm) {
        Log.v("EXAMPLE", "Successfully fetched realm instance.")
    }
    fun onError(e: java.lang.Exception) {
        Log.e("EXAMPLE", "Failed to get realm instance: $e")
    }
})

App.Callback

Quando você executa queries do Atlas App Services como Roles e autenticação de usuário, chamadas assíncronas aceitam um parâmetro final do tipo Chamada de resposta . Você pode lidar com esse retorno de chamada com uma função Lambda que aceita um único parâmetro do tipo App.Result. Para recuperar valores retornados de App.Callback solicitações:

  1. Use o método isSuccess() do App.Result passado para a função da chamada de resposta para determinar se a query foi concluída com sucesso.

  2. Se a consulta for bem-sucedida, use o método get() para recuperar o resultado da consulta. Se a consulta falhou, use getError() para recuperar a exceção que causou a falha na consulta.

String appID = YOUR_APP_ID; // replace this with your App ID
App app = new App(new AppConfiguration.Builder(appID)
        .build());
Credentials anonymousCredentials = Credentials.anonymous();
AtomicReference<User> user = new AtomicReference<User>();
app.loginAsync(anonymousCredentials, it -> {
    if (it.isSuccess()) {
        Log.v("AUTH", "Successfully authenticated anonymously.");
        user.set(app.currentUser());
    } else {
        Log.e("AUTH", it.getError().toString());
    }
});
val appID = YOUR_APP_ID // replace this with your App ID
val app: App = App(
    AppConfiguration.Builder(appID)
        .build()
)
val anonymousCredentials: Credentials = Credentials.anonymous()
var user: User?
app.loginAsync(anonymousCredentials) {
    if (it.isSuccess) {
        Log.v("AUTH", "Successfully authenticated anonymously.")
        user = app.currentUser()
    } else {
        Log.e("AUTH", it.error.toString())
    }
}

RealmAsyncTask

Chamadas assíncronas para executar transações em um domínio retornam uma instância do RealmAsyncTask. Opcionalmente, você pode especificar um manipulador de erro ou uma notificação de sucesso para RealmAsyncTask passando parâmetros adicionais para a chamada assíncrona. Além disso, você usa o método cancel() para interromper a conclusão de uma transação. A função Lambda passada para um RealmAsyncTask contém as operações de gravação a incluir na transação.

// transaction logic, success notification, error handler all via lambdas
realm.executeTransactionAsync(transactionRealm -> {
    Item item = transactionRealm.createObject(Item.class);
}, () -> {
    Log.v("EXAMPLE", "Successfully completed the transaction");
}, error -> {
    Log.e("EXAMPLE", "Failed the transaction: " + error);
});
// using class instances for transaction, success, error
realm.executeTransactionAsync(new Realm.Transaction() {
    @Override
    public void execute(Realm transactionRealm) {
        Item item = transactionRealm.createObject(Item.class);
    }
}, new Realm.Transaction.OnSuccess() {
    @Override
    public void onSuccess() {
        Log.v("EXAMPLE", "Successfully completed the transaction");
    }
}, new Realm.Transaction.OnError() {
    @Override
    public void onError(Throwable error) {
        Log.e("EXAMPLE", "Failed the transaction: " + error);
    }
});
// using class instances for transaction, success, error
realm.executeTransactionAsync(Realm.Transaction { transactionRealm ->
        val item: Item = transactionRealm.createObject<Item>()
}, Realm.Transaction.OnSuccess {
        Log.v("EXAMPLE", "Successfully completed the transaction")
}, Realm.Transaction.OnError { error ->
        Log.e("EXAMPLE", "Failed the transaction: $error")
})
// transaction logic, success notification, error handler all via lambdas
realm.executeTransactionAsync(
    { transactionRealm ->
        val item = transactionRealm.createObject<Item>()
    },
    { Log.v("EXAMPLE", "Successfully completed the transaction") },
    { error ->
        Log.e("EXAMPLE", "Failed the transaction: $error")
    })

RealmResults

Leituras assíncronas de um realm usando findAllAsync() retornam imediatamente uma instância RealmResults vazia. O SDK executa a query em uma thread de background e preenche a instância RealmResults com os resultados quando a query é concluída. Você pode registrar um ouvinte com addChangeListener() para receber uma notificação quando a query for concluída.

RealmResults<Item> items = realm.where(Item.class).findAllAsync();
// length of items is zero when initially returned
items.addChangeListener(new RealmChangeListener<RealmResults<Item>>() {
    @Override
    public void onChange(RealmResults<Item> items) {
        Log.v("EXAMPLE", "Completed the query.");
        // items results now contains all matched objects (more than zero)
    }
});
val items = realm.where<Item>().findAllAsync()
// length of items is zero when initially returned
items.addChangeListener(RealmChangeListener {
    Log.v("EXAMPLE", "Completed the query.")
    // items results now contains all matched objects (more than zero)
})

RealmResultTask

As queries do Atlas assíncronas retornam uma instância do RealmResultTask. Você pode cancelar instâncias RealmResultTask como RealmAsyncTask. Para acessar os valores retornados por sua query, você pode usar:

  • get() para bloquear até que a operação seja concluída

  • getAsync() para lidar com o resultado por meio de uma instância do App.Callback

Document queryFilter  = new Document("type", "perennial");
mongoCollection.findOne(queryFilter).getAsync(task -> {
    if (task.isSuccess()) {
        Plant result = task.get();
        Log.v("EXAMPLE", "successfully found a document: " + result);
    } else {
        Log.e("EXAMPLE", "failed to find document with: ", task.getError());
    }
});
val queryFilter = Document("type", "perennial")
mongoCollection.findOne(queryFilter)
    .getAsync { task ->
        if (task.isSuccess) {
            val result = task.get()
            Log.v("EXAMPLE", "successfully found a document: $result")
        } else {
            Log.e("EXAMPLE", "failed to find document with: ${task.error}")
        }
    }

Coroutines

O SDK fornece um conjunto de extensões Kotlin para solicitar de forma assíncrona usando coroutines e flows em vez de chamadas de resposta. Você pode usar essas extensões para executar transações, assistir a alterações, ler e escrever.

// open a realm asynchronously
Realm.getInstanceAsync(config, object : Realm.Callback() {
    override fun onSuccess(realm: Realm) {
        Log.v("EXAMPLE", "Successfully fetched realm instance")
        CoroutineScope(Dispatchers.Main).launch {
            // asynchronous transaction
            realm.executeTransactionAwait(Dispatchers.IO) { transactionRealm: Realm ->
                if (isActive) {
                    val item = transactionRealm.createObject<Item>()
                }
            }
        }
        // asynchronous query
        val items: Flow<RealmResults<Item>> = realm.where<Item>().findAllAsync().toFlow()
    }
    fun onError(e: Exception) {
        Log.e("EXAMPLE", "Failed to get realm instance: $e")
    }
})

Dica

Os fluxos Kotlin usam objetos congelados em vários threads

O método de extensão toFlow() transmite objetos de Realm congelados para comunicação segura entre threads.

Dica

Veja também:

O SDK também inclui extensões do Kotlin que facilitam a especificação de parâmetros de tipo para leituras e gravações do Realm.

Voltar

Adaptadores

Próximo

Serviços Atlas App