Next-Generation Spring Data and MongoDB

Unless otherwise indicated, these slides are © 2013-2018 Pivotal Software, Inc. and licensed under a
Creative Commons Attribution-NonCommercial license: http://creativecommons.org/licenses/by-nc/3.0/
Next Generation
Spring Data and MongoDB
Mat Keep | Christoph Strobl

Mat Keep
Senior Director, Product Team
Christoph Strobl
Software Engineer, Spring Data
MongoDB 4.0
Multi Document Transactions
1
Spring Data - Lovelace
Sessions & Transactions
2
Alyson Crabal
Product Manager, Server
Jeff Yemin
Lead Engineer, Drivers

3
MongoDB 4.0:
Multi-Document ACID Transactions

4
Safe Harbor Statement
This presentation contains “forward-looking statements” within the meaning of Section 27A of the
Securities Act of 1933, as amended, and Section 21E of the Securities Exchange Act of 1934, as
amended. Such forward-looking statements are subject to a number of risks, uncertainties, assumptions
and other factors that could cause actual results and the timing of certain events to differ materially from
future results expressed or implied by the forward-looking statements. Factors that could cause or
contribute to such differences include, but are not limited to, those identified our filings with the Securities
and Exchange Commission. You should not rely upon forward-looking statements as predictions of future
events. Furthermore, such forward-looking statements speak only as of the date of this presentation.
In particular, the development, release, and timing of any features or functionality described for MongoDB
products remains at MongoDB’s sole discretion. This information is merely intended to outline our general
product direction and it should not be relied on in making a purchasing decision nor is this a commitment,
promise or legal obligation to deliver any material, code, or functionality. Except as required by law, we
undertake no obligation to update any forward-looking statements to reflect events or circumstances after
the date of such statements.

5
Intelligent Operational Data Platform
Best way to work
with data
Intelligently put data
where you want it
Freedom to run
anywhere

6
Data Models and Transactions
Tabular (Relational) Database
Related data split across multiple records and tables.
Multi-record transactions essential
Different databases take different approaches
Document Database
Related data contained in a single, rich document.
Transaction scoped to the document

7
Relational data model
Updating a contact’s details after they change
jobs means modifying multiple tables

8
Document
Database
Atomic single document operations
Updating a contact’s details after they change jobs means
atomically modifying multiple fields in a single document

9
Document
Database
For many apps, single
document transactions
meet data integrity
needs

10
MongoDB Multi-Document Transactions
Just like relational transactions
•  Multi-statement, familiar relational syntax
•  Easy to add to any application
•  Multiple documents in 1 or many collections
ACID guarantees
•  Snapshot isolation, all or nothing execution
•  No performance impact for single document operations
Schedule
•  MongoDB 4.0: Replica Set (Summer 2018)
•  MongoDB 4.2: extended to sharded clusters

11
Natural for developers
●  Idiomatic to the programming
language
●  Familiar to relational
developers
●  Simple
MongoDB Transactions Syntax
try (ClientSession clientSession =client.startSession())
{
clientSession.startTransaction();
try {
collection.insertOne(clientSession, docOne);
collection.insertOne(clientSession, docTwo);
clientSession.commitTransaction();
} catch (Exception e) {
clientSession.abortTransaction();
}
}

12
Natural for developers
●  Idiomatic to the programming
language
●  Familiar to relational
developers
●  Simple
with client.start_session() as s:
s.start_transaction()
try:
collection.insert_one(doc1, session=s)
collection.insert_one(doc2, session=s)
s.commit_transaction()
except Exception:
s.abort_transaction()
MongoDB Transactions Syntax

13
s.start_transaction()
orders.insert_one(order, session=s)
stock.update_one(item, stockUpdate, session=s)
s.commit_transaction()
db.start_transaction()
cursor.execute(orderInsert, orderData)
cursor.execute(stockUpdate, stockData)
db.commit()
*
Comparing Syntax with Tabular Databases

14
Best Practices
•  Existing single document atomicity guarantees
will meet 80%+ of your needs!
•  Transactions automatically abort after 60
seconds – TUNABLE
•  No more than 1,000 documents modified in a
single transaction
•  Add application logic that catches and retries
transactions aborted due to temporary
exceptions (aborted transactions are fully rolled
back by the database)

15
Our Journey to ACID Transactions
Major engineering investment over 3+ years touching every part of
the server and drivers
•  Storage layer
•  Replication consensus protocol
•  Sharding architecture
•  Consistency and durability guarantees
•  Global logical clock
•  Cluster metadata management
•  Exposed to drivers through API enhancements

16
What’s Done, What’s Left

17
Systems of Engagement
Web, mobile, IoT, social apps, content, personalization, single view,
mainframe offload
Systems
of Insight
Operational intelligence, data science,
data lake
Systems of Record
Back office LoB legacy modernization: billing, payment and order
processing, supply chain
MongoDB:
Easier to Address Complete Range of Use Cases

18
Learn More
Transactions Page
●  Documentation
●  Chalk and talks
Download the Release
Candidate

19
Spring
Transactions
MongoDBData

20
The Lovelace Release

21
The Lovelace Release
Client SessionsValidator TransactionsChange Streams

22
The Lovelace Release - Validator

23
The Lovelace Release - JSON Schema

24

25

26

27
The Lovelace Release - Change Streams

28
The Lovelace Release - Client Sessions

29
@EnableTransactionManagement
TransactionTemplate
@Transactional
PlatformTransactionManager

30
TransactionTemplate
@Transactional
PlatformTransactionManager
Flux
.flatMap(…
.then(…
.onError(…

31
@Configuration
@EnableMongoRepositories
public class MongoConfiguration extends AbstractMongoConfiguration {
@Bean
public MongoClient mongoClient() {
return new MongoClient(
}
@Override
protected String getDatabaseName() {
return "...
}
}
Full Control

32
@Configuration
@Bean
return new MongoClient(
}
@Override
return "...
}
}
Full Control
new MongoClientURI("…?replicaSet=rs0")); !

33
@Service
public class PrettySimpleService {
final MongoOperations ops;
final MongoClient client;
public void insertDocuments() {
ops.insert(documentOne);
ops.insert(documentTwo);
}
}
Full Control

34
@Service
ops.withSession(session).insert(documentOne);
ops.withSession(session).insert(documentTwo);
}
}
Full Control
ClientSession session = client.startSession();
session.startTransaction();

35
Full Control
session.commitTransaction();
try {
session.abortTransaction();
}
session.close();
@Service
}
}

36
Full Control
try {
}
ops.withSession(()-> session)
.execute(action -> {
action.insert(documentOne);
action.insert(documentTwo);
return "OK";
});
session.close();
@Service
}
}

37
@Service
try {
}
session.close();
}
}
1
{ insert: "collection-1",
ordered: true,
$db: "db",
$clusterTime: { ... },
lsid: { id: { $binary: { base64 : "I3M7Nj...", ...
txnNumber: 1,
startTransaction: true,
documents: [ { ... } ] }
1
Full Control

38
@Service
try {
}
session.close();
}
}
1
2
ordered: true,
$db: "db",
txnNumber: 1,
documents: [ { ... } ] }
1
ordered: true,
$db: "db",
txnNumber: 1,
documents: [ { ... } ] }
2
Full Control

39
@Service
try {
}
session.close();
}
}
1
2
3
ordered: true,
$db: "db",
txnNumber: 1,
documents: [ { ... } ] }
1
ordered: true,
$db: "db",
txnNumber: 1,
documents: [ { ... } ] }
2
{ commitTransaction: 1,
$db: "admin",
txnNumber: 1 }
3
Full Control

40
Full Control
@Service
try {
}
session.close();
}
}
return "OK";
});

41
Full Control
@Service
try {
}
session.close();
}
}
action.getCollection("collection-1").insertOne(session, …
return "OK";
});
!

42
Collection / Meta Operations
@Configuration
@Bean
return new MongoClient(new MongoClientURI("…?replicaSet=rs0"));
}
@Override
return "...
}
}
Collection / Meta operations don’t
work inside a transaction.
Create required structures upfront to
avoid frustration.
!
@EventListener
public void onApplicationEvent(ContextRefreshedEvent event) {
event.getApplicationContext().getBean(MongoOperations.class)
.createCollection(...)
} Use WriteConcern.MAJORITY to
avoid headaches.

43
The thing with Count
return action.count(query(where("value").is("txn")), "collection-1");
});

44
}); { count: "collection-1",
ordered: true,
$db: "db",
lsid: { id: { $binary: { base64 : "I3M7Nj...", ... } } },
txnNumber: 1,
query: { "value" : "txn" } }
Command failed with error 50851 (Location50851):
Cannot run 'count' in a multi-document transaction.

45
}); { count: "collection-1",
ordered: true,
$db: "db",
txnNumber: 1,
query: { "value" : "txn" } }
Command failed with error 50851 (Location50851):
Cannot run 'count' in a multi-document transaction.
{ aggregate: "collection-1",
ordered: true,
$db: "db",
txnNumber: 1,
pipeline: [ { $match : { "value" : "txn" } },
{ $group : { "_id" : null, count : { $sum : 1} } } ] }

46
AggregationResults<Document> result = action.aggregate(
newAggregation(match(where("value").is("txn")),
count().as("count")),
"collection-1", Document.class);
return result.iterator().next().getLong("count");
});
ordered: true,
$db: "db",
txnNumber: 1,

47
return action.execute("collection-1", collection ->
collection.countDocuments(session, Filters.eq("value", "txn")));
}); 
});
ordered: true,
$db: "db",
txnNumber: 1,

ordered: true,
$db: "db",
txnNumber: 1,
48
});
RC1

49
@Configuration
@Bean
}
@Override
return "...
}
}
Declarative

50
@Configuration
@Bean
}
@Override
return "...
}
}
@Bean
PlatformTransactionManager transactionManager(MongoDbFactory dbFactory) {
return new MongoTransactionManager(dbFactory);
}
Declarative
!

51
@Service
}
}
try {
}
session.close();
Declarative

52
@Service
}
}
@Transactional
ops.insert(documentOne);
ops.insert(documentTwo);
Declarative

53
@Service
final MongoDbFactory dbFactory;
final MongoTemplate template;
MongoTransactionManager txMgr = new MongoTransactionManager(dbFactory);
TransactionStatus status = txMgr.getTransaction(…
TransactionTemplate txTemplate = new TransactionTemplate(txMgr);
txTemplate.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status)
template.insert(documentOne);
template.insert(documentTwo);
}
});
txMgr.commit(status);
Transaction Template

54
Also works with
JTA, JPA, …
non native MongoDB transactions like
@Bean
public MongoOperations mongoTemplate(MongoDbFactory dbFactory) {
MongoTemplate template = new MongoTemplate(dbFactory);
template.setSessionSynchronization(SessionSynchronization.ALWAYS);
return template;
}
!

55
Reactive
Transactions
MongoDBFlux

56
@Service
public class SimpleReactiveService {
public Mono insertDocuments() {
MongoCollection collection = client.getDatabase(...
return Mono.from(client.startSession()).flatMap(session -> {
return …
});
}
Flux TX

57
@Service
return Mono.from(collection.insertOne(session, documentOne))
});
}
Flux TX

58
@Service
.then(Mono.from(collection.insertOne(session, documentTwo)))
});
}
Flux TX

59
@Service
.onErrorResume(e -> Mono.from(session.abortTransaction())
});
}
Flux TX

60
@Service
.then(Mono.error(e)))
});
}
Flux TX

61
@Service
.flatMap(val -> Mono.from(session.commitTransaction())
.then(Mono.empty()))
});
}
Flux TX

62
@Service
.doFinally(signal -> session.close());
});
}
Flux TX

63
@Service
.doFinally(signal -> session.close());
});
}
Flux TX
1
2
3
ordered: true,
$db: "db",
txnNumber: 1,
documents: [ { ... } ] }
1
ordered: true,
$db: "db",
lsid: { id: { $binary: { base64 : "I3M7
txnNumber: 1,
documents: [ { ... } ] }
2
{ commitTransaction: 1,
$db: "admin",
txnNumber: 1 }
3

64
@Service
final ReactiveMongoOperations ops;
return ops.inTransaction()
.execute(
action -> action.insert(documentOne)
.then(action.insert(documentTwo))
.then(Mono.empty());
}
}
Flux TX

@Service
final ReactiveMongoOperations ops;
return ops.inTransaction()
.execute(
action -> action.insert(documentOne)
.then(action.insert(documentTwo))
.then(Mono.empty());
}
}
65
Context
ReactiveMongoContext.getSession()
reactor.util.context.
Context

66
https://github.com/spring-projects/
spring-data-examples/tree/master/
mongodb/transactions

67
Reactive
in theFlux?
Yes!
Si!
Oui!
Evet!
да!
ya!
Ναί!
Ja!
@Transactional
public Mono insertDocuments()
@Deprecated
public ReactiveSessionScoped inTransaction()

Next-Generation Spring Data and MongoDB

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Next-Generation Spring Data and MongoDB

Similar to Next-Generation Spring Data and MongoDB (20)

More from VMware Tanzu

More from VMware Tanzu (20)

Recently uploaded

Recently uploaded (20)

Next-Generation Spring Data and MongoDB