/ /

Transacciones

Overview

En esta guía, puedes aprender cómo usar el driver Java Reactive Streams para realizar transacciones. Las transacciones te permiten ejecutar una serie de operaciones que no se aplican hasta que se completen correctamente todos los cambios de datos. Si alguna operación en la transacción falla, el driver cancela la transacción y descarta todos los cambios en los datos antes de que sean visibles.

En MongoDB, las transacciones se ejecutan dentro de sesiones lógicas. Una sesión es una agrupación de operaciones de lectura o escritura relacionadas que se prevé ejecutar de forma secuencial. Con las sesiones, puedes habilitar la consistencia causal para un grupo de operaciones y ejecutar transacciones ACID. MongoDB garantiza que los datos involucrados en tus operaciones de transacción se mantengan coherentes, incluso si las operaciones encuentran errores inesperados.

Cuando se utiliza el controlador Java Reactive Streams, es posible crear una nueva sesión desde una instancia MongoClient como un tipo ClientSession. Recomendamos reutilizar su cliente para múltiples sesiones y transacciones en lugar de crear una nueva instancia de cliente cada vez.

Advertencia

Utiliza un ClientSession solo con el MongoClient (o el MongoDatabase o MongoCollection asociados) que lo creaste. El uso de un ClientSession con un MongoClient diferente resulta en errores de operación.

Datos de muestra

Los ejemplos en esta guía utilizan las colecciones sample_restaurants.restaurants y sample_mflix.movies de los conjuntos de datos de muestra de Atlas. Para aprender cómo crear un clúster MongoDB Atlas gratuito y cargar los conjuntos de datos de muestra, consulta Comenzar.

Importante

Proyecto Reactor librería

Esta guía usa la librería Proyecto Reactor para consumir instancias Publisher devueltas por los métodos del driver Reactive Streams de Java. Para obtener más información sobre la biblioteca Project Reactor y cómo utilizarla, consulta Primeros pasos en la documentación de Reactor. Para obtener más información sobre cómo utilizamos los métodos de la librería Project Reactor en esta guía, consulta la guía Guardar datos en MongoDB.

Coherencia causal

MongoDB habilita la coherencia causal en ciertas sesiones de clientes. El modelo de coherencia causal garantiza que en un sistema distribuido, las operaciones dentro de una sesión se ejecuten en un orden causal. Los clientes observan resultados que son coherentes con las relaciones causales, o las dependencias entre las operaciones. Por ejemplo, si realizas una serie de operaciones donde una depende lógicamente del resultado de otra, las lecturas subsecuentes reflejarán esa relación de dependencia.

Para garantizar la coherencia causal, las sesiones de los clientes deben cumplir los siguientes requisitos:

Al iniciar una sesión, el driver debe habilitar la opción de coherencia causal. Esta opción está habilitada por defecto.
Las operaciones deben ejecutarse en una sola sesión en un solo hilo. De lo contrario, las sesiones o hilos deben comunicarse entre sí los valores de operation time y tiempo de clúster. Para ver un ejemplo de dos sesiones que comunican estos valores, consulte los Ejemplos de coherencia causal en el manual del servidor de MongoDB.
Debes usar un MAJORITY nivel de consistencia de lectura.
Debe usar un MAJORITY nivel de confirmación de escritura (write concern). Este es el valor predeterminado de nivel de confirmación de escritura (write concern).

La siguiente tabla describe las garantías que ofrecen las sesiones coherentes causales:

garantías	Descripción
Leer las escrituras	Las operaciones de lectura reflejan los resultados de las operaciones de escritura anteriores.
Lecturas monotónicas	Las operaciones de lectura no devuelven resultados que reflejen un estado de datos anterior al de una operación de lectura previa.
Escrituras monotónicas	Si una operación de escritura debe preceder a otras operaciones de escritura, el servidor ejecutará primero esta operación de escritura. Por ejemplo, si llamas a `insertOne()` para insertar un documento y luego llamas a `updateOne()` para modificar el documento insertado, el servidor ejecutará primero la operación de inserción.
Las escrituras siguen a las lecturas	Si una operación de escritura debe seguir a otras operaciones de lectura, el servidor primero ejecuta las operaciones de lectura. Por ejemplo, si llamas a `find()` para recuperar un documento y luego llamas a `deleteOne()` para borrar el documento recuperado, el servidor ejecutará primero la operación find.

Tip

Para aprender más sobre los conceptos mencionados en esta sección, consulta las siguientes entradas del manual del servidor MongoDB:

Métodos de transacciones

Crea un(a) ClientSession utilizando el método startSession() en tu instancia de MongoClient. Luego, puedes modificar el estado de la sesión utilizando los métodos proporcionados por el ClientSession. La siguiente tabla detalla los métodos que puedes usar para gestionar tu transacción:

Método	Descripción
`startTransaction()`	Inicia una nueva transacción, configurada con las opciones dadas, en esta sesión. Lanza una excepción si ya hay una transacción en curso para la sesión. Para obtener más información sobre este método, consulta la página startTransaction() en el manual del MongoDB Server.
`abortTransaction()`	Finaliza la transacción activa para esta sesión. Lanza una excepción si no hay una transacción activa para la sesión o si la transacción ya se ha confirmado o finalizado. Para obtener más información sobre este método, consulta la página abortTransaction() en el manual del Servidor de MongoDB.
`commitTransaction()`	Comete la transacción activa para esta sesión. Lanza una excepción si no existe ninguna transacción activa para la sesión o si la transacción ha finalizado. Para obtener más información sobre este método, consulte la página commitTransaction() en el manual del MongoDB Server.

Tip

Tiempo de espera de la transacción

Puedes establecer un límite en la cantidad de tiempo que las operaciones pueden tardar en completarse en tus transacciones. Para obtener más información, consulta la sección Transacciones de la guía "Limitar el tiempo de ejecución del servidor".

Ejemplo de transacción

El siguiente ejemplo demuestra cómo crear una sesión, realizar una transacción e insertar documentos en varias colecciones en una sola transacción. El código ejecuta los siguientes pasos:

Crea una sesión desde el cliente usando el método startSession()
Inicia una transacción utilizando el método startTransaction()
Inserta documentos en las colecciones restaurants y movies
Confirma la transacción utilizando el método commitTransaction()

MongoClient mongoClient = MongoClients.create(settings);
MongoDatabase restaurantsDatabase = mongoClient.getDatabase("sample_restaurants");
MongoCollection<Document> restaurants = restaurantsDatabase.getCollection("restaurants");
MongoDatabase moviesDatabase = mongoClient.getDatabase("sample_mflix");
MongoCollection<Document> movies = moviesDatabase.getCollection("movies");
Mono.from(mongoClient.startSession())
        .flatMap(session -> {
            // Begins the transaction
            session.startTransaction();
            // Inserts documents in the given order
            return Mono.from(restaurants.insertOne(session, new Document("name", "Reactive Streams Pizza").append("cuisine", "Pizza")))
                    .then(Mono.from(movies.insertOne(session, new Document("title", "Java: Into the Streams").append("type", "Movie"))))
                    // Commits the transaction
                    .flatMap(result -> Mono.from(session.commitTransaction())
                            .thenReturn(result))
                    .onErrorResume(error -> Mono.from(session.abortTransaction()).then(Mono.error(error)))
                    .doFinally(signalType -> session.close());
        })
        // Closes the client after the transaction completes
        .doFinally(signalType -> mongoClient.close())
        // Prints the results of the transaction
        .subscribe(
                result -> System.out.println("Transaction succeeded"),
                error -> System.err.println("Transaction failed: " + error)
        );

Nota

Operaciones paralelas no admitidas

El driver de Java Reactive Streams no admite la ejecución de operaciones en paralelo dentro de una sola transacción.

Si estás utilizando MongoDB Server v8.0 o posterior, puedes realizar operaciones de escritura en múltiples espacios de nombres dentro de una sola transacción utilizando operaciones de escritura en bloque. Para obtener más información, consulta la sección Cliente Bulk Guardar de la guía Bulk Guardar Operaciones.

Información Adicional

Para **aprender** más sobre los conceptos mencionados en esta **guía**, consulta las siguientes páginas en el manual del **servidor**:

Documentación de la API

Para aprender más sobre cualquiera de los tipos o métodos discutidos en esta guía, consulta la siguiente documentación de la API:

Volver

Operaciones de escritura masiva

intercalación