Spring data presentation

Contents
• Spring Data overview
• Core functionality
– Repository support
– Templating
– Object/Datastore mapping

• Spring data extensions:
– Web support
– Repository populations

• Practice

Spring Data
• Spring Data is high level SpringSource project
• Purpose:
– Ease the work with persistence stores
– Support for new data access technologies
– Improve support for RDBMS
– Unify the access to different kinds of persistence
stores, both RDBMS and NoSQL* data stores.

Spring Data project consists of:

Programming model
Client

Repository
Template
Object Mapping

Datastore

Templating
The main purpose of all Spring templates is
resource allocation and exception
translation.
Spring Data:
Resourse - datastore
ExceptionTranslation – from datastore driver
specific exceptions to well known unchecked
DataAccessException hierarchy

Implementations of Templates
Store specific implementations:
• MongoTemplate
• EntityManager – acts like template for JPA
• GemfireTemplate
• Neo4jTemplate
• RedisTemplate
• …

Object/Datastore mapping
{store}MappingConverter with default configuration
is created implicitly:
Mapping is based on:
– Convention
– Metadata
Explicit conversion {store}MappingConverter can
be configured explicitly via both XML and Java

Object/Datastore mapping
GemFire

References to other objects

Repository
The goal of Spring Data repository abstraction is
to significantly reduce the amount of boilerplate
code required to implement data access layers
for various persistence stores.
org.springframework.data.repository.Repository
org.springframework.data.repository.CrudRepository
org.springframework.data.repository.PagingAndSortingRepository

Cooking Spring Data

1) Declare an interface extending Repository or one of its
subinterfaces and type it to the domain class:
2) Declare query methods on the interface:
3) Set up Spring to create proxy instances for those interfaces:
4) Get the repository instance injected and use it:

How it works?
• Spring Data provides persistence store specific
implementations for all interfaces that extend
Repository.
• … no need to write an implementation?
simple cases – yes
more complex operations – require some additional
code

Benefits:
• no boilerplate for simple CRUD
• full control on persisting

Defining query methods
• The repository proxy has two ways to derive a
store-specific query from the method name:
– Method name
– Additionally created query

• Strategies:
• CREATE
• USE_DECLARED_QUERY
• CREATE_IF_NOT_FOUND (default)

Custom implementations
1. Define an interface

2. Repository interface should extend the custom interface:
3. Implement the defined interface with the custom functionality

4. Put custom interface implementation in the appropriate place:

Spring Data Web support
• Integration with Spring MVC
• No need to write boilerplate code in
controllers
• Spring Data REST project provides a solid
foundation on which to expose CRUD
operations to your JPA Repository-managed
entities using plain HTTP REST semantics.

Web Support configuration

Following components will be registered in basic (not HATEOAS) case:
• DomainClassConverter: enables Spring MVC to resolve instances of
repository managed domain classes from request parameters or path
variables.
• HandlerMethodArgumentResolver implementations to let Spring MVC
resolve Pageable and Sort instances from request parameters.

Web Support examples
• DomainClassConverter usage:

• PageableHandlerMethodArgumentResolver and
SortHandlerMethodArgumentResolver usage:
Request
Parameter

Description

page

Page you want to retrieve.

size

Size of the page you want
to retrieve.

sort

Properties that should be
sorted by in the format
property,property(,ASC|
DESC).

Repository populators
• Can specify data to populate storage independent format:
JSON and XML

• JSON populator configuration:
• XML populator configuration:

JPA support
Provides enhanced support for JPA based data
access layers. It makes it easier to build
Spring-powered applications that use data
access technologies.

MongoDB support
MongoDB (from "humongous") is an opensource document database, and the leading
NoSQL database written in C++.
Spring Data MongoDB works with
• MongoDB 1.4 or higher
• Java SE 5 or higher.

GemFire support
vFabric GemFire is a distributed data management platform
providing dynamic scalability, high performance, and
database-like persistence.

• JDK > 6.0
• Spring Framework 3
• vFabric GemFire > 6.6

Useful links
Spring Data
•
•
•
•
•
•
•

http://projects.spring.io/spring-data/
http://spring.io/guides/tutorials/data/
http://docs.spring.io/spring-data/
http://www.infoq.com/articles/spring-data-intro
http://www.slideshare.net/mcgray/spring-data-new-approach-to-persistence
http://www.odbms.org/blog/2013/01/the-spring-data-project-interview-with-david-turanski/
http://spring.io/guides/gs/accessing-data-mongo/

JPA
http://www.spring-source.ru/docs_simple.php?type=manual&theme=docs_simple&docs_simple=chap03_p02

Mongo
http://docs.mongodb.org/manual/

GemFire
http://community.gemstone.com/display/gemfire/GemFire+Tutorial

That’s all folks
Thank you for your attention!

Spring Data MongoDB features
• Spring configuration support using Java based @Configuration classes or an XML namespace for a
Mongo driver instance and replica sets
• MongoTemplate helper class that increases productivity performing common Mongo operations.
Includes integrated object mapping between documents and POJOs.
• Exception translation into Spring's portable Data Access Exception hierarchy
• Feature Rich Object Mapping integrated with Spring's Conversion Service
• Annotation based mapping metadata but extensible to support other metadata formats
• Persistence and mapping lifecycle events
• Java based Query, Criteria, and Update DSLs
• Automatic implementation of Repository interfaces including support for custom finder methods.
• QueryDSL integration to support type-safe queries.
• Cross-store persistence - support for JPA Entities with fields transparently persisted/retrieved using
MongoDB
• Log4j log appender
• GeoSpatial integration

MongoTemplate
• The class MongoTemplate is the central class of the Spring's
MongoDB support providing a rich feature set to interact with
the database.
• Provides wide range of convenience CRUD operations for
MongoDB documents
• Provides a mapping between domain objects and MongoDB
documents.
• Provides similar functionality to MongoDB driver methods but
also gracefully handles mapping for you.
(Using pure driver methods you have to deal with DBObject
instead of your domain object.)

MongoDB type mapping
Java Person class

Document in mongo “prs” collection

Mapping annotations overview
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•

The MappingMongoConverter can use metadata to drive the mapping of objects to documents. An
overview of the annotations is provided below
@Id - applied at the field level to mark the field used for identiy purpose.
@Document - applied at the class level to indicate this class is a candidate for mapping to the
database. You can specify the name of the collection where the database will be stored.
@DBRef - applied at the field to indicate it is to be stored using a com.mongodb.DBRef.
@Indexed - applied at the field level to describe how to index the field.
@CompoundIndex - applied at the type level to declare Compound Indexes
@GeoSpatialIndexed - applied at the field level to describe how to geoindex the field.
@Transient - by default all private fields are mapped to the document, this annotation excludes the
field where it is applied from being stored in the database
@PersistenceConstructor - marks a given constructor - even a package protected one - to use
when instantiating the object from the database. Constructor arguments are mapped by name to the
key values in the retrieved DBObject.
@Value - this annotation is part of the Spring Framework . Within the mapping framework it can
be applied to constructor arguments. This lets you use a Spring Expression Language statement
to transform a key's value retrieved in the database before it is used to construct a domain
object. In order to reference a property of a given document one has to use expressions like:
@Value("#root.myProperty") where root refers to the root of the given document.
@Field - applied at the field level and described the name of the field as it will be represented in the
MongoDB BSON document thus allowing the name to be different than the fieldname of the class.

MongoTemplate features
• MapReduce operations support

• Group operations support

• Aggregation Framework support (introduced in Mongo
version 2.2)
• Index and Collection management
• Executing Commands
• Lifecycle Events (do smth Before,After x Save,Load,Convert)
• Exception Translation (DataAccessException and its children)
• GridFs support

MongoDB JSON based query
methods and field restriction
@org.springframework.data.mongodb.repository.Query

Simple querying:

Querying with field restriction:

QueryDSL and type-safe query methods
MongoDB repository support integrates with the QueryDSL
project which provides a means to perform type-safe queries
in Java.
Features:
• Code completion in IDE (all properties, methods and
operations can be expanded in your favorite Java IDE)
• Almost no syntactically invalid queries allowed (type-safe on
all levels)
• Domain types and properties can be referenced safely (no
Strings involved!)
• Adopts better to refactoring changes in domain types
• Incremental query definition is easier

QueryDSL and type-safe query methods
1) QueryDslPredicateExecutor
interface is provided for you by
Spring Data

2) Just make your
repository interface
extend
QueryDslPredicateExecutor

3) Enjoy type-safe
queries

Miscellaneous
• Cross store support
• Logging support
• JMX support

Spring data presentation

More Related Content

What's hot (20)

Similar to Spring data presentation (20)

Recently uploaded (20)

Spring data presentation

Editor's Notes