/ /

SDK de Java

Docs Home

MongoDB Atlas

SDK de dispositivos Atlas

SDK de Java

Docs Home

MongoDB Atlas

SDK de dispositivos Atlas

SDK de Java

API asincrónica - SDK de Java

Los SDK de dispositivos Atlas están obsoletos. Consulte Página de desuso para más detalles.

El SDK de Java permite acceder a los recursos de red y disco de dos maneras: sincrónica y asincrónica. Mientras que las solicitudes sincrónicas (o "sync") bloquean la ejecución hasta que la solicitud devuelve un resultado correcto o incorrecto, las asincrónicas (o "async") asignan una devolución de llamada y pasan a la siguiente línea de código. Cuando la solicitud retorna, la devolución de llamada se ejecuta para procesar los resultados. En la devolución de llamada, se puede comprobar si la solicitud se ejecutó correctamente y acceder a los resultados devueltos o al error devuelto.

Llamadas asincrónicas

Las solicitudes de API asíncronas en el SDK terminan con el sufijo "Async". Existen diferentes maneras en que una solicitud asíncrona puede comportarse, dependiendo de la parte del SDK que se utilice.

Reino.Devolución de llamada

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

Devolución de llamada de la aplicación

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 consulta se realizó correctamente, utilice el método get() para recuperar el resultado. Si falló, utilice getError() para recuperar la excepción que provocó el error.

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())
    }
}

Tarea asincrónica de reino

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

Resultados del reino

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

Tarea de resultados del reino

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 se complete la operación
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}")
        }
    }

Corrutinas

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

El toFlow() método de extensión pasa objetos Realm congelados para comunicarse de forma segura entre subprocesos.

Tip

El SDK también incluye extensiones Kotlin que facilitan la especificación de parámetros de tipo para lecturas y escrituras de Realm.

Volver

Adaptadores

Servicios de aplicaciones Atlas