Enterprise applications are complex making it difficult to fit everything in one model. NoSQL is taking a leading role in the next generation database technologies and polyglot persistence a good option to leverage the strength of multiple data stores. This talk will introduce the Spring Data project, an umbrella project that provides a familiar and consistent Spring-based programming model for a wide range of data access technologies such as Redis, MongoDB, HBase, Neo4j...while retaining store-specific features and capabilities.

1. Taming NoSQL with Spring
Sergi Almar
@sergialmar

2. About Sergi Almar
‣CTO @ PayTouch
‣VMWare / SpringSource Certified
Instructor
‣javaHispano JUG core member
‣Spring I/O organizer (hope to see you next
year in Spain)

3. Database evolution
1990$
RDBS$

4. Database evolution
1990$ 2000#
RDBS#
RDBS$
OLAP#/#
BI#

5. Database evolution
1990$ 2000# 2010$
RDBS$
RDBS#
NoSQL$
RDBS$
OLAP$/$BI$
OLAP#/#
BI# Hadoop$

6. Increasing Cost & Complexity

7. CAP Theorem

8. CAP Theorem
Hypertable HBase BigTable MongoDB
RDBMS
Redis Memcache Couchbase Terrastore
Dynamo Voldemort Cassandra
Riak SimpleDB CouchDB

9. CAP Theorem
Dynamo Voldemort Cassandra
RDBMS
Riak SimpleDB CouchDB
Which one should I choose?
Hypertable HBase BigTable MongoDB
Redis Memcache Couchbase Terrastore

10. NoSQL Categories
Key-Value Column Document Graph

11. Welcome to Polyglot persistence

12. Key-Value Stores

13. Key-value stores
‣Based on Amazon’s Dynamo paper
‣Data stored as key / value pairs
‣Hard to query
‣Mostly in memory
K1 V1
K2 V2
K3 V2

14. ‣Redis is an advanced key-value store
‣Similar to Memcached but the dataset is not
volatile.
‣Data types: string, lists, sets, hashes, sorted
sets
‣Data expiration
‣Master-slave replication
‣Has “transactions” (batch operations)
‣Libraries - Many languages (Java: Jedis,
JRedis...)

15. Redis Quick Demo

16. Column stores

17. Column stores
Based on Bigtable paper
Data model: big table with column
families

18. Document store

19. Table / Documents
{ title: "Taming NoSQL with Spring
Data",
abstract: "NoSQL is taking a
leading ...",
speaker: "Sergi Almar",
topics: ["nosql", "spring"]}

20. Documents
{
amount: 33,
currency: "EUR",
user: {
first_name: "Sergi",
last_name: "Almar"
},
payment : {
cc: "2342",
expiracy: "11/12"
},
fingerprints : [{ index: "right_index", score:
94},
{ index: "right_middle", score:
89}]
}

21. ‣JSON-style documents
‣Full or partial document updates
‣GridFS for efficiently storing large files
‣Index support - secondary and
compound
‣Rich query language for dynamic queries
‣Map / Reduce
‣Replication and auto sharding

22. RDBMS MongoDB
• Table • Collection
• Row • JSON Document
• Index • Index
• Join • Embedding &
• Partition Linking
• Partition Key • Shard
• Shard Key

24. MongoDB Quick Demo

25. Graph stores

26. ‣DB is a collection of graph nodes,
relationships
‣Nodes and relationships have properties
‣Query is done via a traversal API
‣Indexes on node / relationship
properties
‣Written in Java, can be embedded
‣Transactions (ACID)

27. Spring Data

28. Spring Data http://www.springsource.com/spring-
data
‣An umbrella project for:
‣JPA - Repositories
‣JDBC Extensions
‣MongoDB - Document Database
‣Neo4J - Graph Database
‣Redis, Riak - Key Value Database
‣Gemfire - Distributes Data Grid
‣Hadoop / HBase - Big Data Storage and
Analysis platform

29. Spring Data Building Blocks
‣Mapping of POJOs to underlying data
model
‣Familiar Spring ‘Template’
‣MongoTemplate,
RedisTemplate,
Neo4JTemplate...
‣Generic Repository support

30. Spring Data Repositories I
public'interface'Repository<T,'ID'extends'Serializable>'{'
!
}
public'interface'CrudRepository<T,'ID'extends'Serializable>'extends'Repository<T,'ID>'{'
!
''T'save(T'entity);'
'
''Iterable<T>'save(Iterable<?'extends'T>'entities);'
'
''T'findOne(ID'id);'
!
''boolean'exists(ID'id);'
!
''Iterable<T>'findAll();'
!
''long'count();'
!
''void'delete(ID'id);'
!
''void'delete(T'entity);'
'
''void'delete(Iterable<?'extends'T>'entities);'
!
''void'deleteAll();'
}

31. Spring Data Repositories II
public'interface'PagingAndSortingRepository<T,'ID'extends'Serializable>'extends''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''CrudRepository<T,'ID>'{'
''Iterable<T>'findAll(Sort'sort);'
'
''Page<T>'findAll(Pageable'pageable);'
}
public'interface'PersonRepository'extends'CrudRepository<Person,BigInteger>'{'
'
'//'Finder'for'a'single'entity'
'Person'findByEmailAddress(String'emailAddress);'
'
'//'Finder'for'multiple'entities'
'List<Person>'findByLastnameLike(String'lastName);'
'
'//'Finder'with'pagination'
'Page<Person>'findByFirstnameLike(String'firstName,'Pageable'page);'
''
}

32. Spring Data JPA I
@Entity'
public'class'Person'{'
'
''@Id'
''@GeneratedValue(strategy=GenerationType.AUTO)&
''private'BigInteger'id;'
''private'String'firstname,'lastname;'
'
''@Column(name="email")'
''private'String'emailAddress;'
'
''@OneToMany'
''private'Set<Person>'colleagues;'
'
}
By just defining the interface, Spring provides the implementation
<jpa:repositories,base.package="com.java2days.repository"2/>!

33. Spring Data JPA II
‣Query methods use method naming
conventions
‣ Can override with Query annotation
‣ Or method name references a JPA named
public'interface'PersonRepository'extends'CrudRepository<Person,BigInteger>'{'
'
'//'previous'methods'omitted…'
query
'
!@Query("select!p!from!Person!p!where!p.emailAddress!=!?1")!
!Person!findByEmailAddress(String!emailAddress);!
!!!
!@Query("select!p!from!Person!p!where!p.firstname!=!:firstname!or!p.lastname!=!:lastname")!
!Person!findByLastnameOrFirstname(@Param("lastname")!String!lastname,!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!@Param("firstname")!String!firstname);'
''
}

34. Spring Data Key-Value
Key-Value Column Document Graph
MongoDB

35. Spring Data
‣MongoTemplate
‣Object-Document Mapping
‣Repository Support
‣QueryDSL
‣JMX
‣Logging
‣GeoSpatial
‣Spring XML namespace

36. Spring Data MongoDB - Entity Mapping

37. Spring Data MongoTemplate

38. Spring MongoDB Template usage

39. Spring Data MongoDB Repository
{ 'location' : { '$near' : [point.x, point.y], '$maxDistance' : distance}}

40. public'interface'PersonRepository''
'''''''extends'PagingAndSortingRepository'<Person,String>'{''
'
''List<Person>'findByLastName(String'lastName);''
''List<Person>'findByFirstName(String'lastName);'
''List<Person>'findByByShippingAdresses(Address'address);'
''List<Person>'findByByFirstNameAndLastName(String'fn,'String'ln);''
''List<Person>'findByByFirstNameAndLastName(String'fn,'String'ln,'PageRequest'pagingInfo);'
}'

41. public'interface'PersonRepository''
'''''''extends'PagingAndSortingRepository'<Person,String>'{''
'
''List<Person>'findByLastName(String'lastName);''
''List<Person>'findByFirstName(String'lastName);'
''List<Person>'findByByShippingAdresses(Address'address);'
''List<Person>'findByByFirstNameAndLastName(String'fn,'String'ln);''
''List<Person>'findByByFirstNameAndLastName(String'fn,'String'ln,'PageRequest'pagingInfo);'
}'
Keyword Sample Logical result
GreaterThan findByAgeGreaterThan(int age) {"age" : {"$gt" : age}}
LessThan findByAgeLessThan(int age) {"age" : {"$lt" : age}}
Between findByAgeBetween(int from, int to) {"age" : {"$gt" : from, "$lt" : to}}
NotNull findByFirstnameNotNull() {”firstname" : {"$ne" : null}}
Null findByFirstnameNull() {”firstname" : null}
Like findByFirstnameLike(String name) "firstname" : firstname} (regex)

42. Spring Data Mongo Repository usage

43. Spring Data Key-Value
Key-Value Column Document Graph
Redis,
Riak

44. Spring Data Redis
‣Portable API across several Redis connectors
‣RedisTemplate
‣Access all Redis functionality, dedicated interfaces
for each data type
‣Value / Hash / Set / ZSet / List Operations
‣Handles serialization and type conversion automatically
‣String specific class through StringRedisTemplate (JSON,
XML...)
‣Fluent Query API
‣Async Pub / Sub support with MLC
‣Spring 3.1 Cache Abstraction provider

45. Redis Configuration (Jedis connector)
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/
beans/spring-beans.xsd
<bean id="jedisConnectionFactory"
class="org.springframework.data.keyvalue.redis.connection.jedis.JedisConnect
p:use-pool="true"
p:host-name="server"
p:port="6379"
/>
<!-- redis template definition -->
<bean id="redisTemplate"
class="org.springframework.data.keyvalue.redis.core.RedisTemplate"
p:connection-factory-ref="jedisConnectionFactory"/>
...
</beans>

46. Using RedisTemplate
redisTemplate.opsForValue().get(“user:salmar:transactions”);
redisTemplate.opsForValue().set(“user:salmar:transactions”, 20);
redisTemplate.opsForValue().increment(“user:salmar:transactions”, 1);
redisTemplate.opsForSets().add(“user:salmar:friends”, “jlong”);
redisTemplate.opsForSets().intersect(“user:salmar:friends”, “user.jlong:friends”);

47. Thank you!
Q&A
@sergialmar