Spring Data

Oleksii Usyk

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:

Structure

Programming model

Repository

Template

Object Mapping

Datastore

Client

Templating

The main purpose of all Spring templates is resource allocation and exception translation.

Spring Data:Resourse - datastoreExceptionTranslation – 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 mappingGemFire

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 Data1) 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 – yesmore complex operations – require some additional

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

Query creation

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 implementations1. 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:

Configuration

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 supportMongoDB (from "humongous") is an open-

source 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

Practice

Questions

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/

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

Mongohttp://docs.mongodb.org/manual/

GemFirehttp://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 aMongo 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 usingMongoDB• Log4j log appender• GeoSpatial integration

Mongo Configuration

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.

Custom Converters

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

Repository

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