/ /

Java SDK

Docs Home

MongoDB Atlas

SDK de Dispositivo Atlas

Java SDK

Docs Home

MongoDB Atlas

SDK de Dispositivo Atlas

Java SDK

API asincrónica - SDK de Java

Los SDK de dispositivos Atlas están obsoletos. Consulte deprecation page for details.

The Java SDK lets you access network and disk resources in two ways: synchronously and asynchronously. While synchronous, or "sync", requests block execution until the request returns success or failure, asynchronous, or "async", requests assign a callback and proceed execution to the next line of code. When the request returns, the callback runs to process results. In the callback, you can check if the request executed successfully and either access the returned results or the returned error.

Asynchronous Calls

Asynchronous API requests in the SDK end with the suffix "Async". There are several different ways an asynchronous request can behave, depending on which part of the SDK you're using.

Realm.Callback

Las llamadas asincrónicas para abrir un reino, tanto con como sin sincronización, utilizan un parámetro final de tipo Realm.Callback. Para recuperar los valores devueltos después de que se complete la solicitud, implemente el onSuccess() Método en el objeto de devolución de llamada que se pasa como parámetro final a estos métodos asincrónicos. También debería implementar el método onError() para gestionar los fallos de solicitud, aunque no es obligatorio.

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

Cuando consultas a Atlas App Services como Funciones y autenticación de usuarios, las llamadas asíncronas aceptan un parámetro final de tipo aplicación.Callback. Se puede gestionar esta función de retorno con una función lambda que acepta un único parámetro de tipo aplicación.Result. Para recuperar valores devueltos de las solicitudes App.Callback:

Utilice el método isSuccess() del App.Result pasado a la función de devolución de llamada para determinar si la consulta se completó correctamente.
Si la query fue exitosa, use el método get() para recuperar el resultado de la query. Si falló la query, use getError() para recuperar la excepción que causó el fallo de la query.

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

Las llamadas asíncronas para ejecutar transacciones en un dominio devuelven una instancia de RealmAsyncTask. Opcionalmente, puede especificar un controlador de errores o una notificación de éxito para RealmAsyncTask pasando parámetros adicionales a la llamada asíncrona. Además, puede usar el método cancel() para detener la finalización de una transacción. La función lambda pasada a RealmAsyncTask contiene las operaciones de escritura que se incluirán en la transacción.

// 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

Las lecturas asincrónicas desde un dominio que usan findAllAsync() devuelven inmediatamente una instancia de RealmResults vacía. El SDK ejecuta la consulta en un subproceso en segundo plano y rellena la RealmResults instancia con los resultados al completarse la consulta. Puede registrar un receptor con addChangeListener() para recibir una notificación al completarse la consulta.

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

Las queries asíncronas a Atlas devuelven una instancia de RealmResultTask. Puedes cancelar instancias RealmResultTask de la misma manera que RealmAsyncTask. Para acceder a los valores devueltos por tu query, puedes utilizar:

get() para bloquear hasta que la operación se complete
getAsync() para manejar el resultado a través de una instancia de 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}")
        }
    }

corrutina

El SDK proporciona un conjunto de extensiones de Kotlin para realizar solicitudes asincrónicas mediante corrutinas y flujos en lugar de devoluciones dellamada. Puede usar estas extensiones para ejecutar transacciones, detectar cambios, leer y escribir.

// 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")
    }
})

Tip

Kotlin Flows utilizan objetos Frozen en varios hilos

The toFlow() extension method passes frozen Realm objects to safely communicate between threads.

Tip

The SDK also includes Kotlin extensions that make specifying type parameters for Realm reads and writes easier.

Volver

Adapters

Atlas App Services