/ /

Transações

Visão geral

Neste guia, você pode aprender como usar o driver Java Reactive Streams para executar transações. As transações permitem que você execute uma série de operações que não se aplicam até que todas as alterações de dados sejam bem-sucedidas. Se qualquer operação da transação falhar, o driver cancelará a transação e descartará todas as alterações de dados sem nunca se tornar visível.

No MongoDB, as transações são executadas dentro de sessões lógicas . Uma sessão é um agrupamento de operações de leitura ou escrita relacionadas que você pretende executar sequencialmente. Com sessões, você pode habilitar a consistência causal para um grupo de operações e executar transações ACID. O MongoDB garante que os dados envolvidos em suas operações de transação permaneçam consistentes, mesmo que as operações encontrem erros inesperados.

Ao usar o driver Java Reactive Streams, você pode criar uma nova sessão a partir de uma instância MongoClient como tipo ClientSession . Recomendamos que você reutilize seu cliente para várias sessões e transações, em vez de fazer a instância de um novo cliente a cada vez.

Aviso

Utilize uma ClientSession apenas com o MongoClient (ou MongoDatabase ou MongoCollection associada) que a criou. Utilizar uma ClientSession com um MongoClient diferente resulta em erros de operação.

Dados de amostra

Os exemplos neste guia usam as collections sample_restaurants.restaurants e sample_mflix.movies dos conjuntos de dados de amostra do Atlas. Para aprender como criar um agrupamento de MongoDB Atlas gratuito e carregar os conjuntos de dados de amostra, consulte a Introdução.

Importante

Biblioteca do Reator do Projeto

Este guia usa a biblioteca Project Reactor para consumir instâncias do Publisher retornadas pelos métodos de driver Java Reactive Streams. Para saber mais sobre a biblioteca do Projeto Reactor e como usá-la, consulte Introdução na documentação do Reactor. Para saber mais sobre como usamos os métodos da biblioteca do Project Reactor neste guia, consulte o guia Gravar dados no MongoDB.

Consistência causal

O MongoDB permite consistência causal em determinadas sessões de cliente. O modelo de consistência causal garante que, em um sistema distribuído, as operações dentro de uma sessão sejam executadas em uma ordem causal. Os clientes observam resultados consistentes com as relações causais ou as dependências entre as operações. Por exemplo, se você executar uma série de operações em que uma operação depende logicamente do resultado de outra, todas as leituras subsequentes refletirão o relacionamento de dependência .

Para garantir a consistência causal, as sessões de cliente devem atender aos seguintes requisitos:

Ao iniciar uma sessão, o driver deve habilitar a opção de consistência causal. Esta opção está habilitada por padrão.
As operações devem ser executadas em uma única sessão em um único thread. Caso contrário, as sessões ou threads devem comunicar os valores de optime e tempo de cluster uns aos outros. Para exibir um exemplo de duas sessões que comunicam esses valores, consulte os exemplos de Consistência causal no manual do MongoDB Server.
Você deve usar uma preocupação de leitura MAJORITY .
Você deve usar uma preocupação de gravação MAJORITY . Este é o valor padrão de preocupação de gravação .

A tabela a seguir descreve as garantias que as sessões causalmente consistentes oferecem:

Garantia	Descrição
Ler suas gravações	As operações de leitura refletem os resultados das operações de gravação anteriores.
Leituras monotônicas	As operações de leitura não retornam resultados que reflitam um estado de dados anterior a uma operação de leitura anterior.
Escritas monotônicas	Se uma operação de gravação precisar preceder outras operações de gravação, o servidor executará essa operação de gravação primeiro. Por exemplo, se você chamar `insertOne()` para inserir um documento e, em seguida, chamar `updateOne()` para modificar o documento inserido, o servidor executará a operação de inserção primeiro.
Escritas que seguem as leituras	Se uma operação de gravação precisar seguir outras operações de leitura, o servidor executará primeiro as operações de leitura. Por exemplo, se você chamar `find()` para recuperar um documento e, em seguida, chamar `deleteOne()` para excluir o documento recuperado, o servidor executará primeiro a operação de localização.

Dica

Para saber mais sobre os conceitos mencionados nesta seção, consulte as seguintes entradas de manual do MongoDB Server :

Métodos de transação

Crie um ClientSession utilizando o método startSession() na sua instância do MongoClient . Você pode então modificar o estado da sessão usando os métodos fornecidos por ClientSession. A tabela a seguir detalha os métodos que você pode usar para gerenciar sua transação:

Método	Descrição
`startTransaction()`	Inicia uma nova transação, configurada com as opções fornecidas, nesta sessão. Lança uma exceção se já houver uma transação em andamento para a sessão. Para saber mais sobre esse método, consulte a página startTransaction() no manual do MongoDB Server .
`abortTransaction()`	Termina a transação ativa para esta sessão. Lança uma exceção se não houver nenhuma transação ativa para a sessão ou se a transação já estiver confirmada ou encerrada. Para saber mais sobre esse método, consulte a página abortTransaction() no manual do MongoDB Server .
`commitTransaction()`	Confirma a transação ativa para esta sessão. Lança uma exceção se não houver nenhuma transação ativa para a sessão ou se a transação tiver sido encerrada. Para saber mais sobre esse método, consulte a página commitTransaction() no manual do MongoDB Server .

Dica

Tempo limite da transação

Você pode definir um limite de tempo para que as operações sejam concluídas em suas transações. Para saber mais, consulte a seção Transações do guia Limitar o tempo de execução do servidor.

Exemplo de transação

O exemplo a seguir demonstra como criar uma sessão, criar uma transação e inserir documentos em várias coleções em uma transação. O código executa as seguintes etapas:

Cria uma sessão a partir do cliente utilizando o método startSession()
Inicia uma transação usando o método startTransaction()
Insere documentos nas collections restaurants e movies
Confirma a transação usando o 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)
        );

Observação

Operações paralelas não suportadas

O driver Reactive Streams do Java não suporta a execução de operações paralelas em uma única transação.

Se você estiver usando o MongoDB Server v8.0 ou posterior, poderá executar operações de gravação em vários namespaces em uma única transação usando operações de gravação em massa. Para saber mais, consulte a seção Gravação em massa do cliente do guia Operações de gravação em massa.

Informações adicionais

Para saber mais sobre os conceitos mencionados neste guia, consulte as seguintes páginas no manual do servidor:

Documentação da API

Para saber mais sobre qualquer um dos tipos ou métodos discutidos neste guia, consulte a seguinte documentação da API:

Voltar

Operações de gravação em massa

Agrupamentos