Polyglot persistence for Java developers - moving out of the relational comfort zone

Polyglot persistence for Java
developers - moving out of the
relational comfort zone

Chris Richardson

Author of POJOs in Action
Founder of CloudFoundry.com
Chris.Richardson@SpringSource.Com
@crichardson

Overall presentation goal

The joy and pain of
building Java
applications that
use NoSQL

5/3/11 Copyright (c) 2011 Chris Richardson. All rights reserved.
Slide 2

About Chris
•  Grew up in England and live in Oakland, CA
•  Over 25+ years of software development
experience including 14 years of Java
•  Speaker at JavaOne, SpringOne, NFJS,
JavaPolis, Spring Experience, etc.
•  Organize the Oakland JUG and the Groovy
Grails meetup

http://www.theregister.co.uk/2009/08/19/springsource_cloud_foundry/

Slide 3

Agenda
o  The trouble with relational
databases
o  Overview of NoSQL databases
o  Introduction to Spring Data
o  NoSQL case study: POJOs in Action

Slide 4

Relational databases are great
o  SQL = Rich, declarative query language
o  Database enforces referential integrity
o  ACID semantics
o  Well understood by developers
o  Well supported by frameworks and tools, e.g. Spring
JDBC, Hibernate, JPA
o  Well understood by operations
n  Configuration
n  Care and feeding
n  Backups
n  Tuning
n  Failure and recovery
n  Performance characteristics
o  But….

Slide 5

The trouble with relational databases
o  Object/relational impedance mismatch
n  Complicated to map rich domain model to
relational schema
o  Relational schema is rigid
n  Difficult to handle semi-structured data, e.g.
varying attributes
n  Schema changes = downtime or $$
o  Extremely difficult/impossible to scale writes:
n  Vertical scaling is limited/requires $$
n  Horizontal scaling is limited or requires $$
o  Performance can be suboptimal for some use
cases

Slide 6

NoSQL databases have emerged…
Each one offers some
combination of:
o  High performance
o  High scalability
o  Rich data-model
o  Schema less
In return for:
o  Limited transactions
o  Relaxed consistency
o  …

Slide 7

… but there are few commonalities
o  Everyone and their dog has written one
o  Different data models
n  Key-value
n  Column
n  Document
n  Graph
o  Different APIs – No JDBC, Hibernate,
JPA (generally)
o  “Same sorry state as the database
market in the 1970s before SQL was
invented” http://queue.acm.org/detail.cfm?id=1961297

Slide 8

How to I access my data?

Slide 9

Reality Check - Relational DBs are not going away

§  NoSQL
usage small
by
comparison
…
§  But
growing…

Slide 10

Future = multi-paradigm data storage
for enterprise applications

IEEE Software Sept/October 2010 - Debasish Ghosh / Twitter @debasishg

Slide 11

Agenda
o  The trouble with relational databases

Slide 12

Redis
o  Advanced key-value store
n  Think memcached on steroids (the good kind)
K1 V1
n  Values can be binary strings, Lists, Sets, Ordered
Sets, Hash maps, .. K2 V2
n  Operations for each data type, e.g. appending
to a list, adding to a set, retrieving a slice of a K3 V2
list, …
o  Very fast:
n  In-memory operations
n  ~100K operations/second on entry-level hardware
o  Persistent
n  Periodic snapshots of memory OR append
commands to log file
n  Limits are size of keys retained in memory.
o  Has transactions
n  Commands can be batched and executed
atomically

Slide 13

Redis CLI
redis> sadd myset a
(integer) 1
redis> sadd myset b
(integer) 1
redis> smembers myset
1. "a"
2. "b"
redis> srem myset a
(integer) 1
redis> smembers myset
1. "b"

Slide 14

Scaling Redis
o  Master/slave replication
n  Tree of Redis servers
n  Non-persistent master can replicate to a persistent slave
n  Use slaves for read-only queries
o  Sharding
n  Client-side only – consistent hashing based on key
n  Server-side sharding – coming one day
o  Run multiple servers per physical host
n  Server is single threaded => Leverage multiple CPUs
n  32 bit more efficient than 64 bit
o  Optional "virtual memory"
n  Ideally data should fit in RAM
n  Values (not keys) written to disc

Slide 15

Redis use cases
o  Use in conjunction with another database as the
SOR
o  Drop-in replacement for Memcached
n  Session state
n  Cache of data retrieved from SOR
n  Denormalized datastore for high-performance queries
o  Hit counts using INCR command
o  Randomly selecting an item – SRANDMEMBER
o  Queuing – Lists with LPOP, RPUSH, ….
o  High score tables – Sorted sets

o  Notable users: github, guardian.co.uk, ….

Slide 16

Cassandra
o  An Apache open-source project originally
developed by Facebook for inbox search
o  Extremely scalable
o  Fast writes = append to a log
o  Data is replicated and sharded
o  Rack and datacenter aware
o  Column-oriented database
n  The data model will hurt your brain
n  4 or 5-dimensional hash map

Slide 17

Cassandra data model
My Column family (within a key space)
Keys Columns

a colA: value1 colB: value2 colC: value3

b colA: value colD: value colE: value

o  4-D map: keySpace x key x columnFamily x
column è value
o  Column names are dynamic; can contain
data
o  Arbitrary number of columns
o  One CF row = one DDD aggregate
Slide 18

Cassandra data model – insert/update
Keys Columns

a colA: value1 colB: value2 colC: value3

b colA: value colD: value colE: value Transaction =
updates to a
row within a
ColumnFamily

Insert(key=a, columName=colZ, value=foo)
Keys Columns

a colA: value1 colB: value2 colC: value3 colZ: foo

b colA: value colD: value colE: value

Slide 19

Cassandra query example – slice
Key Columns
s
colA: colB: colC: colZ:
a
value1 value2 value3 foo

colA: colD: colE:
b
value value value

slice(key=a, startColumn=colA, endColumnName=colC)

Key Columns You can also do a
s
rangeSlice which
colA: colB:
a
value1 value2 returns a range of keys
– less efficient

Slide 20

Super Column Families – one more
dimension
Keys Super columns

ScA ScB
a
colA: value1 colB: value2 colC: value3

b
colA: value colD: value colE: value

Insert(key=a, superColumn=scB, columName=colZ, value=foo)

keySpace x key x columnFamily x superColumn x column -> value
Keys Super columns

ScA ScB
a
colA: value1 colB: value2 colC:colZ: foo
value3

b

Slide 21

Getting data with super slice

Keys Super columns

ScA ScB
a
colA: value1 colB: value2 colC: value3

b

slice(key=a, startColumn=scB, endColumnName=scC)

keySpace x key x columnFamily x Super column x column -> value

Keys Super columns

ScB
a
colC: value3

Slide 22

Cassandra CLI
$ bin/cassandra-cli -h localhost
Connected to: "Test Cluster" on localhost/9160
Welcome to cassandra CLI.
[default@unknown] use Keyspace1;
Authenticated to keyspace: Keyspace1
[default@Keyspace1] list restaurantDetails;
Using default limit of 100
-------------------
RowKey: 1
=> (super_column=attributes,
(column=json, value={"id":
1,"name":"Ajanta","menuItems"....

[default@Keyspace1] get restaurantDetails['1']['attributes’];
=> (column=json, value={"id":1,"name":"Ajanta","menuItems"....

Slide 23

Scaling Cassandra
• Client connects to any node
• Dynamically add/remove nodes
Keys = [D, A]
Node 1 • Reads/Writes specify how many nodes
• Configurable # of replicas
Token = A •  adjacent nodes
•  rack and data center aware
Replicates to
Replicates to

Node 4 Node 2
Keys = [A, B]
Token = D Token = B

Replicates to
Keys = [C, D] Replicates to

Node 3
Token = C
Keys = [B, C]

Slide 24

Cassandra use cases
o  Use cases
•  Big data
•  Persistent cache
•  (Write intensive) Logging

o  Who is using it
n  Digg, Facebook, Twitter, Reddit, Rackspace
n  Cloudkick, Cisco, SimpleGeo, Ooyala, OpenX
n  The largest production cluster has over 100
TB of data in over 150 machines. –
Casssandra web site
Slide 25

MongoDB
o  Document-oriented database
n  JSON-style documents: Lists, Maps, primitives
n  Documents organized into collections (~table)
o  Full or partial document updates
n  Transactional update in place on one document
n  Atomic Modifiers
o  Rich query language for dynamic queries
o  Index support – secondary and compound
o  GridFS for efficiently storing large files
o  Map/Reduce

Slide 26

Data Model = Binary JSON documents
{
"name" : "Ajanta",
"type" : "Indian",
"serviceArea" : [
"94619",

],
"94618" One document
"openingHours" : [
{
=
"dayOfWeek" : Monday,
"open" : 1730,
one DDD aggregate
"close" : 2130
}
],
"_id" : ObjectId("4bddc2f49d1505567c6220a0")
}

o  Sequence of bytes on disk = fast I/O
n  No joins/seeks
n  In-place updates when possible => no index updates
o  Transaction = update of single document

Slide 27

MongoDB CLI
$ bin/mongo
> use mydb
> r1 = {name: 'Ajanta'}
{name: 'Ajanta'}
> r2 = {name: 'Montclair Egg Shop'}
{name: 'Montclair Egg Shop'}
> db.restaurants.save(r1)
> r1
{ _id: ObjectId("98…"), name: "Ajanta"}
> db.restaurants.save(r2)
> r2
{ _id: ObjectId("66…"), name: "Montclair Egg Shop"}
> db.restaurants.find({name: /^A/})
{ _id: ObjectId("98…"), name: "Ajanta"}
> db.restaurants.update({name: "Ajanta"},
{name: "Ajanta Restaurant"})

Slide 28

MongoDB query by example
o  Find a restaurant that serves the 94619 zip
code and is open at 6pm on a Monday
{
serviceArea:"94619",
openingHours: {
$elemMatch : {
"dayOfWeek" : "Monday",
"open": {$lte: 1800},
"close": {$gte: 1800}
}
}
}
DBCursor cursor = collection.find(qbeObject);
while (cursor.hasNext()) {
DBObject o = cursor.next();
…
}

Slide 29

Scaling MongoDB
Shard 1 Shard 2
Mongod Mongod
(replica) (replica)

Mongod Mongod
(master) Mongod (master) Mongod
(replica) (replica)

Config
Server

mongod
A shard consists of a
mongos replica set =
generalization of
master slave
mongod

mongod Collections spread
over multiple
client shards

Slide 30

MongoDB use cases
o  Use cases
n  Real-time analytics
n  Content management systems
n  Single document partial update
n  Caching
n  High volume writes
o  Who is using it?
n  Shutterfly, Foursquare
n  Bit.ly Intuit
n  SourceForge, NY Times
n  GILT Groupe, Evite,
n  SugarCRM

Slide 31

Other NoSQL databases
o  SimpleDB – “key-value”
o  Neo4J – graph database
o  CouchDB – document-oriented
o  Membase – key-value
o  Riak – key-value + links
o  Hbase – column-oriented
o  …
http://nosql-database.org/ has a list of 122 NoSQL databases

Slide 32

Agenda

Slide 33

NoSQL Java APIs

Database Libraries
Redis Jedis, JRedis, JDBC-Redis, RJC

Cassandra Raw Thrift if you are a masochist
Hector, …

MongoDB MongoDB provides a Java driver

Slide 34

Spring Data Project Goals
o  Bring classic Spring value propositions
to a wide range of NoSQL databases:
n  Productivity
n  Programming model consistency: E.g.
<NoSQL>Template classes
n  “Portability”
o  Many entry points to use
n  Auto-generated repository implementations
n  Opinionated APIs (Think JdbcTemplate)
n  Object Mapping (Java and GORM)
n  Cross Store Persistence Programming model
n  Productivity support in Roo and Grails
Slide 35

Spring Data sub-projects
§ Commons: Polyglot persistence
§ Key-Value: Redis, Riak
§ Document: MongoDB, CouchDB
§ Graph: Neo4j
§ GORM for NoSQL
§ Various milestone releases
§ Key Value 1.0.0.M3 (Apr 6, 2011)
§ Document 1.0.0.M2 (April 9, 2011)
§ Graph - Neo4j Support 1.0.0 (April 19, 2011)
§ … http://www.springsource.org/spring-data

Slide 36

MongoTemplate
Simplifies data MongoTemplate POJO ó DBObject
access databaseName mapping
Translates userId
Password
exceptions
defaultCollectionName

writeConcern
writeResultChecking
<<interface>>
save() MongoConvertor
insert() write(Object, DBObject)
remove() read(Class, DBObject)
updateFirst()
findOne()
find()
…
SimpleMongo
uses Converter
Mongo
MongoMapping
(Java Driver class)
Converter

Slide 37

Richer mapping Annotations define mapping:
@Document, @Id, @Indexed,
@PersistanceConstructor,
@Document @CompoundIndex, @DBRef,
public class Person { @GeoSpatialIndexed, @Value

Map fields instead of properties
@Id è no getters or setters required
private ObjectId id;
private String firstname; Non-default constructor

@Indexed Index generation
private String lastname;

@PersistenceConstructor
public Person(String firstname, String lastname) {
this.firstname = firstname;
this.lastname = lastname;
}

….
}
Slide 38

Generic Mongo Repositories
interface PersonRepository extends MongoRepository<Person, ObjectId> {
List<Person> findByLastname(String lastName);
}

<bean>
<mongo:repositories
base-package="net.chrisrichardson.mongodb.example.mongorepository"
mongo-template-ref="mongoTemplate" />
</beans>

Person p = new Person("John", "Doe");
personRepository.save(p);

Person p2 = personRepository.findOne(p.getId());

List<Person> johnDoes = personRepository.findByLastname("Doe");
assertEquals(1, johnDoes.size());

Slide 39

Support for the QueryDSL project
Generated from Type-safe
domain model class composable queries

QPerson person = QPerson.person;

Predicate predicate =
person.homeAddress.street1.eq("1 High Street")
.and(person.firstname.eq("John"))

List<Person> people = personRepository.findAll(predicate);

assertEquals(1, people.size());
assertPersonEquals(p, people.get(0));

Slide 40

Cross-store/polyglot persistence
Person person = new Person(…);
@Entity
public class Person { entityManager.persist(person);
// In Database
@Id private Long id; Person p2 = entityManager.find(…)
private String firstname;
private String lastname;

// In MongoDB
@RelatedDocument private Address address;

{ "_id" : ObjectId(”….."),
"_entity_id" : NumberLong(1),
"_entity_class" : "net.. Person",
"_entity_field_name" : "address",
"zip" : "94611", "street1" : "1 High Street", …}

Slide 41

Agenda
o  NoSQL case study: POJOs in
Action

Slide 42

Food to Go
o  Customer enters delivery address and delivery
time
o  System displays available restaurants
n  = restaurants that serve the zip code of the delivery
address AND are open at the delivery time
class Restaurant { class TimeRange {
long id; long id;
String name; int dayOfWeek;
Set<String> serviceArea; int openingTime;
Set<TimeRange> openingHours;
int closingTime;
List<MenuItem> menuItems;
}
}

class MenuItem {
String name;
double price;
}

Slide 43

Database schema
ID Name … RESTAURANT
table
1 Ajanta
2 Montclair Eggshop

Restaurant_id zipcode RESTAURANT_ZIPCODE
table
1 94707
1 94619
2 94611
2 94619 RESTAURANT_TIME_RANGE
table
Restaurant_id dayOfWeek openTime closeTime
1 Monday 1130 1430
1 Monday 1730 2130
2 Tuesday 1130 …

Slide 44

SQL for finding available
restaurants
select r.* Straightforward
from restaurant r three-way join
inner join restaurant_time_range tr
on r.id =tr.restaurant_id
inner join restaurant_zipcode sa
on r.id = sa.restaurant_id
where “94619’ = sa.zip_code
and tr.day_of_week=“monday”
and tr.openingtime <= 1930
and 1930 <=tr.closingtime

Slide 45

Redis - Persisting restaurants is
“easy”
rest:1:details [ name: “Ajanta”, … ]

rest:1:serviceArea [ “94619”, “94611”, …]

rest:1:openingHours [10, 11]

timerange:10 [“dayOfWeek”: “Monday”, ..]

timerange:11 [“dayOfWeek”: “Tuesday”, ..]

OR

rest:1 [ name: “Ajanta”,
“serviceArea:0” : “94611”, “serviceArea:1” : “94619”,
“menuItem:0:name”, “Chicken Vindaloo”,
…]

OR

rest:1 { .. A BIG STRING/BYTE ARRAY, E.G. JSON }

Slide 46

BUT…
o  … we can only retrieve them via
primary key
è Queries instead of data model
drives NoSQL database design
è We need to implement indexes
o  But how can a key-value store
support a query that has

?
n  A 3-way join
n  Multiple =
n  > and <

Slide 47

Denormalization eliminates joins
Restaurant_id Day_of_week Open_time Close_time Zip_code

1 Monday 1130 1430 94707
1 Monday 1130 1430 94619
1 Monday 1730 2130 94707
1 Monday 1730 2130 94619
2 Monday 0700 1430 94619
…

One simple query
SELECT restaurant_id, open_time No joins
FROM time_range_zip_code Two = and one <
WHERE day_of_week = ‘Monday’
AND zip_code = 94619
AND 1815 < close_time
AND open_time < 1815
Application filters out opening
times after delivery time

Slide 48

Eliminate multiple =’s with
concatenation
SELECT restaurant_id, open_time
FROM time_range_zip_code
WHERE day_of_week = ‘Monday’
AND zip_code = 94619
AND 1815 < close_time

94619:Monday ….

GET 94619:Monday

Slide 49

Sorted sets support range queries
Key Sorted Set [ Entry:Score, …]

closingTimes:94707:Monday [1130_1:1430, 1730_1:2130]

closingTimes:94619:Monday [0700_2:1430, 1130_1:1430, 1730_2:2130]

ZRANGEBYSCORE
closingTimes:94619:Monday Member: OpeningTime_RestaurantId
Score: ClosingTime
1815 2359
->
{1730_1:2130}

1730 is before 1815 => Ajanta is open

Slide 50

Querying my data

What did you
just tell me
to do!?

Slide 51

RedisTemplate-based code
@Repository
public class AvailableRestaurantRepositoryRedisImpl implements AvailableRestaurantRepository {

@Autowired private final StringRedisTemplate redisTemplate;

private BoundZSetOperations<String, String> closingTimes(int dayOfWeek, String zipCode) {
return redisTemplate.boundZSetOps(AvailableRestaurantKeys.closingTimesKey(dayOfWeek, zipCode));
}

public List<AvailableRestaurant> findAvailableRestaurants(Address deliveryAddress, Date deliveryTime) {
String zipCode = deliveryAddress.getZip();
int timeOfDay = timeOfDay(deliveryTime);
int dayOfWeek = dayOfWeek(deliveryTime);

Set<String> closingTrs = closingTimes(dayOfWeek, zipCode).rangeByScore(timeOfDay, 2359);
Set<String> restaurantIds = new HashSet<String>();
String paddedTimeOfDay = FormattingUtil.format4(timeOfDay);
for (String trId : closingTrs) {
if (trId.substring(0, 4).compareTo(paddedTimeOfDay) <= 0)
restaurantIds.add(StringUtils.substringAfterLast(trId, "_"));
}

Collection<String> jsonForRestaurants = redisTemplate.opsForValue().multiGet(
AvailableRestaurantKeys.timeRangeRestaurantInfoKeys(restaurantIds ));
List<AvailableRestaurant> restaurants = new ArrayList<AvailableRestaurant>();
for (String json : jsonForRestaurants) {
restaurants.add(AvailableRestaurant.fromJson(json));
}
return restaurants;
}

Slide 52

Redis – Spring configuration
@Configuration
public class RedisConfiguration extends AbstractDatabaseConfig {

@Bean
public RedisConnectionFactory jedisConnectionFactory() {
JedisConnectionFactory factory = new JedisConnectionFactory();
factory.setHostName(databaseHostName);
factory.setPort(6379);
factory.setUsePool(true);
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxActive(1000);
factory.setPoolConfig(poolConfig);
return factory;
}

@Bean
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(factory);
return template;
}
}

Slide 53

Deleting/Updating a restaurant
o  Need to delete members of the sorted
sets
o  But we can’t “find by a foreign key”
o  To delete a restaurant:
n  GET JSON details of Restaurant (incl.
openingHours + serviceArea)
n  Re-compute sorted set keys and
members and delete them
n  Delete the JSON

Slide 54

Cassandra: Easy to store
restaurants
Column Family: RestaurantDetails
Keys Columns

1 name: Ajanta type: Indian …

name: Montclair
2 type: Breakfast …
Egg Shop

OR
Column Family: RestaurantDetails
Keys Columns

1 details: { JSON DOCUMENT }

2 details: { JSON DOCUMENT }

Slide 55

But we can’t query this
o  Similar challenges to using Redis
o  No joins è denormalize
o  Can use composite/concatenated
keys
n  Prefix - equality match
n  Suffix - can be range scan
o  Some limited querying options
n  Row key – exact or range
n  Column name – exact or range

Slide 56

Cassandra: Find restaurants that close
after the delivery time and then filter
Keys Super Columns

1430 1430 2130

94619:Mon
1130_1: JSON FOR 1730_1: JSON FOR
0700_2: JSON FOR EGG
AJANTA AJANTA

SuperSlice
key= 94619:Mon
SliceStart = 1815
SliceEnd = 2359

Keys Super Columns

2130

94619:Mon
1730_1: JSON FOR
AJANTA

18:15 is after 17:30 => {Ajanta}

Slide 57

Cassandra/Hector code
import me.prettyprint.hector.api.Cluster;

public class CassandraHelper {
@Autowired private final Cluster cluster;

public <T> List<T> getSuperSlice(String keyspace, String columnFamily,
String key, String sliceStart, String sliceEnd,
SuperSliceResultMapper<T> resultMapper) {

SuperSliceQuery<String, String, String, String> q =
HFactory.createSuperSliceQuery(HFactory.createKeyspace(keyspace, cluster),
StringSerializer.get(), StringSerializer.get(), StringSerializer.get(), StringSerializer.get());
q.setColumnFamily(columnFamily);
q.setKey(key);
q.setRange(sliceStart, sliceEnd, false, 10000);

QueryResult<SuperSlice<String, String, String>> qr = q.execute();

SuperColumnRowProcessor<T> rowProcessor = new SuperColumnRowProcessor<T>(resultMapper);

for (HSuperColumn<String, String, String> superColumn : qr.get().getSuperColumns()) {
List<HColumn<String, String>> columns = superColumn.getColumns();
rowProcessor.processRow(key, superColumn.getName(), columns);
}
return rowProcessor.getResult();
}
}

Slide 58

MongoDB = easy to store
{
"_id": "1234"
"name": "Ajanta",
"serviceArea": ["94619", "99999"],
"openingHours": [
{
"dayOfWeek": 1,
"open": 1130,
"close": 1430
},
{
"dayOfWeek": 2,
"open": 1130,
"close": 1430
},
…
]
}
Slide 59

MongoDB = easy to query
{
"serviceArea": "94619",
"openingHours": {
"$elemMatch": {
"open": { "$lte": 1815},
"dayOfWeek": 4,
"close": { $gte": 1815}
}
}
db.availableRestaurants.ensureIndex({serviceArea: 1})
Slide 60

MongoTemplate-based code
@Repository
public class AvailableRestaurantRepositoryMongoDbImpl
implements AvailableRestaurantRepository {

@Autowired private final MongoTemplate mongoTemplate;

@Autowired @Override
public List<AvailableRestaurant> findAvailableRestaurants(Address deliveryAddress,
Date deliveryTime) {
int timeOfDay = DateTimeUtil.timeOfDay(deliveryTime);
int dayOfWeek = DateTimeUtil.dayOfWeek(deliveryTime);

Query query = new Query(where("serviceArea").is(deliveryAddress.getZip())
.and("openingHours”).elemMatch(where("dayOfWeek").is(dayOfWeek)
.and("openingTime").lte(timeOfDay)
.and("closingTime").gte(timeOfDay)));

return mongoTemplate.find(AVAILABLE_RESTAURANTS_COLLECTION, query,
AvailableRestaurant.class);
}

mongoTemplate.ensureIndex(“availableRestaurants”,
new Index().on("serviceArea", Order.ASCENDING));
Slide 61

MongoDB – Spring Configuration
@Configuration
public class MongoConfig extends AbstractDatabaseConfig {
private @Value("#{mongoDbProperties.databaseName}")
String mongoDbDatabase;

public @Bean MongoFactoryBean mongo() {
MongoFactoryBean factory = new MongoFactoryBean();
factory.setHost(databaseHostName);
MongoOptions options = new MongoOptions();
options.connectionsPerHost = 500;
factory.setMongoOptions(options);
return factory;
}

public @Bean
MongoTemplate mongoTemplate(Mongo mongo) throws Exception {
MongoTemplate mongoTemplate = new MongoTemplate(mongo, mongoDbDatabase);
mongoTemplate.setWriteConcern(WriteConcern.SAFE);
mongoTemplate.setWriteResultChecking(WriteResultChecking.EXCEPTION);
return mongoTemplate;
}
}

Slide 62

Is NoSQL webscale?
Benchmarking is still work in
progress but so far
http://www.youtube.com/watch?
v=b2F-DItXtZs

Redis Mongo Cassandra
Insert for PK Awesome Awesome Fast*
Find by PK Awesome Awesome Fast
Insert for find available Fast Awesome Ok*
Find available Awesome Ok Ok
restaurants

* Cassandra can be clustered for improved write performance

In other words: it depends
Slide 63

Summary
o  Relational databases are great but
n  Object/relational impedance mismatch
n  Relational schema is rigid
n  Extremely difficult/impossible to scale writes
n  Performance can be suboptimal
o  Each NoSQL databases can solve some
combination of those problems BUT
n  Limited transactions
n  Query-driven, denormalized database design
n  …
è
o  Carefully pick the NoSQL DB for your application
o  Consider a polyglot persistence architecture

Slide 64

Thank you!

My contact info

chris.richardson@springsource.com

@crichardson

Slide 65

Polyglot persistence for Java developers - moving out of the relational comfort zone

More Related Content

What's hot (20)

Similar to Polyglot persistence for Java developers - moving out of the relational comfort zone (20)

More from Chris Richardson (20)

Recently uploaded (20)

Polyglot persistence for Java developers - moving out of the relational comfort zone