Data access 2.0? Please welcome: Spring Data!

Data Access 2.0?
…please welcome…

Spring Data!

Oliver Gierke

Oliver Gierke

Spring Data
Core/JPA/MongoDB

ogierke@vmware.com
www.olivergierke.de
olivergierke

Hibari Voldemort
Membase
Riak Cassandra
Redis
SimpleDB (No)SQL MongoDB

OrientDB CouchDB
HBase
Sones
Neo4J

Document database
JSON documents
JSON queries

MongoDB Infrastructure API

Mongo mongo = new Mongo(…);
DB db = mongo.getDB("myDatabase");
Collection collection = db.getCollection("myCollection");

DBObject address = new BasicDBObject();
address.put("city", "London");

DBObject person = new BasicDBObject();
person.put("ﬁrstname", "Dave");
person.put("lastname", "Matthews");
person.put("address", address);

collection.save(person);

19

MongoDB Query API

Mongo mongo = new Mongo(…);
DB db = mongo.getDB("myDatabase");
Collection collection = db.getCollection("myCollection");

DBObject query = new BasicDBObject();
query.put("address.city", "London");

DBCursor cursor = collection.ﬁnd(query);

for (DBObject element : cursor) {
// Map data onto object
}

20

Graph database
Nodes / Relationships
Traversals / Cypher / Gremlin

Neo4J Infrastructure API

GraphDatabaseService database = new EmbeddedGraphDatabase(…);
Transaction tx = database.beginTx();

try {
Node mrAnderson = database.createNode();
mrAnderson.setProperty("name", "Thomas Anderson");
Node morpheus = database.createNode();
morpheus.setProperty("name", "Morpheus");

Relationship friendship = mrAnderson.createRelationshipTo(
morpheus, FriendTypes.KNOWS);

tx.success();
} ﬁnally {
tx.ﬁnish();
}

22

Neo4J Query API

GraphDatabaseService database = new EmbeddedGraphDatabase(…);

CypherParser parser = new CypherParser();
Query query = parser.parse("start person = Person(id = *) match " +
"person-[:colleagues]->colleague where colleague.ﬁrstname = {name}");

Map<String, Object> parameters = new HashMap<String, Object>();
parameters.put("name", "Dave");

ExecutionEngine engine = new ExecutionEngine(database);
ExecutionResult result = engine.execute(query, parameters);

for (EntrySet<String, Object> element : result) {
// Map data onto object
}

23

Neo4J entity

class Actor {

private ﬁnal Node node;

public Actor(Node node) { … }

public String getName() {
return (String) node.getProperty(„name“);
}

…
}

24

"
This document is the speciﬁcation of the
Java API for the management of
persistence and object/relational mapping
with Java EE and Java SE. The technical
objective of this work is to provide an
object/relational mapping facility for the
Java application developer using a Java
domain model to man- age a relational
database.

There‘s some
Spring for that!

" … provide a familiar and
consistent Spring-based
programming model while
retaining store-speciﬁc
features and capabilities.

JPA entity mapping

@Entity
class Person {

@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private BigInteger id;
private String ﬁrstname, lastname;

@Column(name="email")
private String emailAddress;

@OneToMany
private Set<Person> colleagues;
}

40

Entity mapping - MongoDB

@Document
class Person {

@Id private BigInteger id;
@Indexed private String firstname, lastname;
@Field("email") private String emailAddress;
@DBRef private Set<Person> colleagues;

public Person(String firstname) { … }

@PersistenceConstructor
public Person(String firstname, String lastname) { … }

…
}

41

Entity mapping - Neo4J

@NodeEntity
class Person {

@GraphId private long id;
@Indexed private String firstname, lastname;
@RelatedTo(direction = Direction.INCOMING)
private Set<Person> colleagues;

public Person(String firstname) { … }

@PersistenceConstructor
public Person(String firstname, String lastname) { … }

…
}

42

MongoOperations / -Template

public interface MongoOperations {

// Generic callback-accepting methods
<T> T execute(DbCallback<T> action);
<T> T execute(Class<?> entityClass, CollectionCallback<T> action);
<T> T execute(String collectionName, CollectionCallback<T> action);

// Higher level access methods
<T> List<T> ﬁnd(Query query, Class<T> entityClass);
void save(Object objectToSave, String collectionName);
WriteResult updateFirst(Query query, Update update, Class<?>
entityClass);

// Geo API
<T> GeoResults<T> geoNear(NearQuery near, Class<T> entityClass);
}

44

MongoTemplate usage

// Setup infrastructure
Mongo mongo = new Mongo();
MongoDbFactory factory = new SimpleMongoDbFactory(mongo, „foo“);
MongoTemplate template = new MongoTemplate(factory);

// Create and save entity
Person dave = new Person("Dave", "Matthews");
dave.setEmailAddress("dave@dmband.com");
template.save(person);

// Query entity
Query query = new Query(new Criteria("emailAddress")
.is("dave@dmband.com"));
assertThat(template.ﬁnd(query), is(dave));

45

Repositories - JPA

<jpa:repositories base-package="com.acme.repositories" />

public interface PersonRepository extends Repository<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);
}

47

Repositories - MongoDB

public interface PersonRepository extends Repository<Person, BigInteger>
{



// Geospatial queries
List<Person> ﬁndByLocationNear(Point location, Distance distance);
GeoResults<Person> ﬁndByLocationNear(Point location);
}

48

Repositories - MongoDB

<mongo:repositories base-package="com.acme.repositories" />

@Component
public class MyClient {

@Autowired
private PersonRepository repository;

public List<Person> doSomething() {

Point point = new Point(43.7, 48.8);
Distance distance = new Distance(200, Metrics.KILOMETERS);
return repository.ﬁndByLocationNear(point, distance);
}
}

49

Repositories - Neo4J

interface PersonRepository extends GraphRepository<Person, Long>



@Query("start person = Person(id = *) " +
"match person-[:colleagues]->colleague where " +
"colleague.ﬁrstname = {name}")
List<Person> getPersonsWithColleaguesName(
@Param("name") Movie m);
}

50

Repositories
Querydsl

51

Querydsl

QPerson $ = QPerson.person;
BooleanExpression left = $.lastname.contains("eth");
BooleanExpression right = $.firstname.is("Carter");

public interface QueryDslPredicateExecutor<T> {
T findOne(Predicate predicate);
List<T> findAll(Predicate predicate);
}

public interface PersonRepository extends Repository<Person, BigInteger>,
QueryDslPredicateExecutor { … }

List<Person> result = repository.findAll(left.or(right));
assertThat(result.size(), is(2));
assertThat(result, hasItems(dave, carter));

52

Wrap up
Sophisticated mapping support
Templates
Repositories
Querydsl
Spring namespace
Geospatial support (MongoDB)
Cross-store persistence

Resources

• www.springframework.org/spring-data

• github.com/SpringSource/spring-data-mongodb

• github.com/SpringSource/spring-data-neo4j

• http://www.se-radio.net/2010/07/episode-165-nosql-and-
mongodb-with-dwight-merriman

• http://kkovacs.eu/cassandra-vs-mongodb-vs-couchdb-vs-redis

Data access 2.0? Please welcome: Spring Data!

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Data access 2.0? Please welcome: Spring Data! (20)

Recently uploaded (20)

Data access 2.0? Please welcome: Spring Data!