会议和交易

从版本 3.6 开始，MongoDB 支持会话的概念。 使用会话可以启用 MongoDB 的因果一致性模型，该模型保证按照尊重其因果关系的顺序运行操作。 这些实例分为 instances 和 instances。 在本节中，当我们谈到会话时，我们指的是 。ServerSessionClientSessionClientSessionspring-doc.cn

客户端会话中的操作不会与会话外的操作隔离。

Both 和 都提供了用于将 a 绑定到操作的网关方法。 并使用实现 MongoDB 的集合和数据库接口的会话代理对象，因此您无需在每次调用时添加会话。 这意味着 的潜在调用将委托给 。MongoOperationsReactiveMongoOperationsClientSessionMongoCollectionMongoDatabaseMongoCollection#find()MongoCollection#find(ClientSession)spring-doc.cn

返回本机 MongoDB Java Driver 网关对象（例如 ）等方法，这些对象本身为 . 这些方法不是 session 代理的。 在直接与 交互时，您应该提供 where needed，而不是通过 上的回调之一。(Reactive)MongoOperations#getCollectionMongoCollectionClientSessionClientSessionMongoCollectionMongoDatabase#executeMongoOperations

ClientSession 支持

以下示例显示了会话的使用情况：spring-doc.cn

ClientSessionOptions sessionOptions = ClientSessionOptions.builder()
    .causallyConsistent(true)
    .build();

ClientSession session = client.startSession(sessionOptions); (1)

template.withSession(() -> session)
    .execute(action -> {

        Query query = query(where("name").is("Durzo Blint"));
        Person durzo = action.findOne(query, Person.class);  (2)

        Person azoth = new Person("Kylar Stern");
        azoth.setMaster(durzo);

        action.insert(azoth);                                (3)

        return azoth;
    });

session.close()                                              (4)
1 从服务器获取新会话。
2 像以前一样使用方法。 它会自动应用。MongoOperationClientSession
3 确保关闭 .ClientSession
4 关闭会话。
在处理实例时，尤其是延迟加载的实例，在所有数据加载之前不要关闭 是很重要的。 否则，延迟获取将失败。DBRefClientSession 
ClientSessionOptions sessionOptions = ClientSessionOptions.builder()
.causallyConsistent(true)
.build();

Publisher<ClientSession> session = client.startSession(sessionOptions); (1)

template.withSession(session)
.execute(action -> {

        Query query = query(where("name").is("Durzo Blint"));
        return action.findOne(query, Person.class)
            .flatMap(durzo -> {

                Person azoth = new Person("Kylar Stern");
                azoth.setMaster(durzo);

                return action.insert(azoth);                            (2)
            });
    }, ClientSession::close)                                            (3)
    .subscribe();                                                       (4)
1 获取 for new session retrieval.Publisher
2 像以前一样使用方法。 这是自动获取和应用的。ReactiveMongoOperationClientSession
3 确保关闭 .ClientSession
4 在您订阅之前，什么都不会发生。 有关详细信息，请参阅 Project Reactor Reference Guide。

通过使用提供实际会话的 ，您可以将会话获取推迟到实际订阅的时间点。 尽管如此，您仍需要在完成后关闭会话，以免过时的会话污染服务器。 当您不再需要会话时，请使用 hook on 进行调用。 如果您希望对会话本身进行更多控制，可以通过驱动程序获取 并通过 .PublisherdoFinallyexecuteClientSession#close()ClientSessionSupplierspring-doc.cn

的反应性使用仅限于 Template API 的使用。 目前没有与反应式存储库的会话集成。ClientSession

MongoDB 事务

从版本 4 开始，MongoDB 支持 Transactions。 事务构建在 Sessions 之上，因此需要一个活动的 .ClientSessionspring-doc.cn

除非您在应用程序上下文中指定 a，否则事务支持将被 DISABLED。 您可以使用 参与正在进行的非原生 MongoDB 事务。MongoTransactionManagersetSessionSynchronization(ALWAYS)

要获得对事务的完全编程控制，您可能需要对 使用会话回调。MongoOperationsspring-doc.cn

以下示例显示了编程事务控制：spring-doc.cn

程序化交易
ClientSession session = client.startSession(options);                   (1)

template.withSession(session)
    .execute(action -> {

        session.startTransaction();                                     (2)

        try {

            Step step = // ...;
            action.insert(step);

            process(step);

            action.update(Step.class).apply(Update.set("state", // ...

            session.commitTransaction();                                (3)

        } catch (RuntimeException e) {
            session.abortTransaction();                                 (4)
        }
    }, ClientSession::close)                                            (5)
1 获取新的 .ClientSession
2 启动事务。
3 如果一切按预期进行，请提交更改。
4 有些东西坏了，所以回滚所有内容。
5 完成后不要忘记关闭会话。

前面的示例允许您在回调中使用会话范围的实例时完全控制事务行为，以确保将会话传递给每个服务器调用。 为了避免这种方法带来的一些开销，您可以使用 a 来消除手动事务流的一些噪音。MongoOperationsTransactionTemplatespring-doc.cn

Mono<DeleteResult> result = Mono
    .from(client.startSession())                                                             (1)

    .flatMap(session -> {
        session.startTransaction();                                                          (2)

        return Mono.from(collection.deleteMany(session, ...))                                (3)

            .onErrorResume(e -> Mono.from(session.abortTransaction()).then(Mono.error(e)))   (4)

            .flatMap(val -> Mono.from(session.commitTransaction()).then(Mono.just(val)))     (5)

            .doFinally(signal -> session.close());                                           (6)
      });
1 首先，我们显然需要启动会话。
2 一旦我们手头有钱，就开始交易。ClientSession
3 通过传递 to 操作来在事务中操作。ClientSession
4 如果操作异常完成，我们需要停止事务并保留错误。
5 或者当然，如果成功，请提交更改。 仍然保留操作结果。
6 最后，我们需要确保关闭会话。

上述操作的罪魁祸首是保持主流，而不是通过 or 发布的交易结果，这导致了相当复杂的设置。DeleteResultcommitTransaction()abortTransaction()spring-doc.cn

除非您在应用程序上下文中指定 a，否则事务支持将被 DISABLED。 您可以使用 参与正在进行的非原生 MongoDB 事务。ReactiveMongoTransactionManagersetSessionSynchronization(ALWAYS)

使用 TransactionTemplate / TransactionalOperator 的事务

Spring Data MongoDB 事务同时支持 和 。TransactionTemplateTransactionalOperatorspring-doc.cn

交易TransactionTemplate / TransactionalOperator
template.setSessionSynchronization(ALWAYS);                                     (1)

// ...

TransactionTemplate txTemplate = new TransactionTemplate(anyTxManager);         (2)

txTemplate.execute(new TransactionCallbackWithoutResult() {

    @Override
    protected void doInTransactionWithoutResult(TransactionStatus status) {     (3)

        Step step = // ...;
        template.insert(step);

        process(step);

        template.update(Step.class).apply(Update.set("state", // ...
    }
});
1 在 Template API 配置期间启用事务同步。
2 使用提供的 .TransactionTemplatePlatformTransactionManager
3 在回调中，和 transaction 已注册。ClientSession
在运行时更改 的状态（您可能认为在前面清单的第 1 项中是可能的）可能会导致线程和可见性问题。MongoTemplate 
template.setSessionSynchronization(ALWAYS);                                          (1)

// ...

TransactionalOperator rxtx = TransactionalOperator.create(anyTxManager,
                                   new DefaultTransactionDefinition());              (2)


Step step = // ...;
template.insert(step);

Mono<Void> process(step)
    .then(template.update(Step.class).apply(Update.set("state", …))
    .as(rxtx::transactional)                                                         (3)
    .then();
1 为 Transactional participation 启用事务同步。
2 使用提供的 .TransactionalOperatorReactiveTransactionManager
3 TransactionalOperator.transactional(…)为所有上游操作提供事务管理。

使用MongoTransactionManager和ReactiveMongoTransactionManager进行交易

MongoTransactionManager / ReactiveMongoTransactionManager是众所周知的 Spring 事务支持的网关。 它允许应用程序使用 Spring 的 managed transaction 功能。 the 将 a 绑定到线程，而 则使用 the for this。 检测会话并相应地对与事务关联的这些资源进行操作。 还可以参与其他正在进行的交易。 以下示例显示如何使用 ：MongoTransactionManagerClientSessionReactiveMongoTransactionManagerReactorContextMongoTemplateMongoTemplateMongoTransactionManagerspring-doc.cn

交易MongoTransactionManager / ReactiveMongoTransactionManager
@Configuration
static class Config extends AbstractMongoClientConfiguration {

    @Bean
    MongoTransactionManager transactionManager(MongoDatabaseFactory dbFactory) {  (1)
        return new MongoTransactionManager(dbFactory);
    }

    // ...
}

@Component
public class StateService {

    @Transactional
    void someBusinessFunction(Step step) {                                        (2)

        template.insert(step);

        process(step);

        template.update(Step.class).apply(Update.set("state", // ...
    };
});
1 在应用程序上下文中注册。MongoTransactionManager
2 将方法标记为事务性方法。
@Transactional(readOnly = true)建议同时启动一个事务，将 添加到 传出请求.MongoTransactionManagerClientSession 
@Configuration
public class Config extends AbstractReactiveMongoConfiguration {

    @Bean
    ReactiveMongoTransactionManager transactionManager(ReactiveMongoDatabaseFactory factory) {  (1)
        return new ReactiveMongoTransactionManager(factory);
    }

    // ...
}

@Service
public class StateService {

    @Transactional
    Mono<UpdateResult> someBusinessFunction(Step step) {                                  (2)

        return template.insert(step)
            .then(process(step))
            .then(template.update(Step.class).apply(Update.set("state", …));
    };
});
1 在应用程序上下文中注册。ReactiveMongoTransactionManager
2 将方法标记为事务性方法。
@Transactional(readOnly = true)建议同时启动一个事务，将 添加到 传出请求.ReactiveMongoTransactionManagerClientSession

控制特定于 MongoDB 的事务选项

事务性服务方法可以要求特定的事务选项来运行事务。 Spring Data MongoDB 的事务管理器支持评估事务标签，例如 .@Transactional(label = { "mongo:readConcern=available" })spring-doc.cn

默认情况下，使用前缀的标签命名空间由默认配置的 （） 进行评估。 事务标签由 和 提供，并可供编程事务控制使用。 由于它们的声明性质，提供了一个很好的起点，也可以用作文档。mongo:MongoTransactionOptionsResolverTransactionAttributeTransactionTemplateTransactionalOperator@Transactional(label = …)spring-doc.cn

目前支持以下选项：spring-doc.cn

最大提交时间

控制 commitTransaction 操作在服务器上的最大执行时间。 该值的格式与 ISO-8601 持续时间格式对应，用于 。Duration.parse(…)spring-doc.cn

用法：mongo:maxCommitTime=PT1Sspring-doc.cn

阅读关注

设置事务的读取关注点。spring-doc.cn

用法：mongo:readConcern=LOCAL|MAJORITY|LINEARIZABLE|SNAPSHOT|AVAILABLEspring-doc.cn

读取首选项

设置事务的读取首选项。spring-doc.cn

用法：mongo:readPreference=PRIMARY|SECONDARY|SECONDARY_PREFERRED|PRIMARY_PREFERRED|NEARESTspring-doc.cn

写入关注

设置事务的写关注点。spring-doc.cn

用法：mongo:writeConcern=ACKNOWLEDGED|W1|W2|W3|UNACKNOWLEDGED|JOURNALED|MAJORITYspring-doc.cn

加入外部事务的嵌套事务不会影响初始事务选项，因为事务已启动。 仅当启动新事务时，才会应用事务选项。

事务中的特殊行为

在事务内部，MongoDB 服务器的行为略有不同。spring-doc.cn

连接设置spring-doc.cn

MongoDB 驱动程序提供了一个专用的副本集名称配置选项，用于将驱动程序引入自动检测模式。 此选项有助于在事务期间识别主副本集节点和命令路由。spring-doc.cn

确保添加到 MongoDB URI。 有关更多详细信息，请参阅连接字符串选项。replicaSet

集合操作spring-doc.cn

MongoDB 不支持在事务中执行集合操作，例如创建集合。 这也会影响首次使用时发生的动态集合创建。 因此，请确保所有必需的结构都已到位。spring-doc.cn

暂时性错误spring-doc.cn

MongoDB 可以为事务操作期间引发的错误添加特殊标签。 这些可能表示暂时性故障，仅重试操作即可消失。 我们强烈推荐 Spring Retry 来实现这些目的。 不过，可以覆盖以实现 MongoDB 参考手册中所述的重试提交操作行为。MongoTransactionManager#doCommit(MongoTransactionObject)spring-doc.cn

计数spring-doc.cn

MongoDB 根据可能无法反映事务中实际情况的集合统计信息进行操作。 在多文档事务中发出命令时，服务器会响应错误 50851。 检测到活动事务后，所有公开的方法都会使用 and 运算符转换并委托给聚合框架，同时保留设置，例如 .countcountMongoTemplatecount()$match$countQuerycollationspring-doc.cn

在 aggregation count 帮助程序中使用 geo 命令时，限制适用。 以下运算符不能使用，必须替换为其他运算符：spring-doc.cn

使用 和 的查询必须重写为相应的 . 这同样适用于必须更改为 的存储库查询方法中的 query 关键字。 另请参阅 MongoDB JIRA 票证 DRIVERS-518 以进一步参考。Criteria.near(…)Criteria.nearSphere(…)Criteria.within(…)Criteria.withinSphere(…)nearwithinspring-doc.cn

以下代码段显示了 session-bound 闭包内的用法：countspring-doc.cn

session.startTransaction();

template.withSession(session)
    .execute(action -> {
        action.count(query(where("state").is("active")), Step.class)
        ...

上面的代码段在以下命令中具体化：spring-doc.cn

db.collection.aggregate(
   [
      { $match: { state: "active" } },
      { $count: "totalEntityCount" }
   ]
)

而不是：spring-doc.cn

db.collection.find( { state: "active" } ).count()