introduction to spring data n.
Skip this Video
Loading SlideShow in 5 Seconds..
Introduction to Spring Data PowerPoint Presentation
Download Presentation
Introduction to Spring Data

Introduction to Spring Data

251 Views Download Presentation
Download Presentation

Introduction to Spring Data

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Introduction to Spring Data Dr. Mark Pollack

  2. Agenda The current data landscape Project Goals Project Tour

  3. Enterprise Data Trends

  4. Enterprise Data Trends • Unstructured Data • No predefined data model • Often doesn’t fit well in RDBMS • Pre-Aggregated Data • Computed during data collection • Counters • Running Averages

  5. The Value of Data Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/418.9 (KHTML, like Gecko) Safari/419.3 • Value from Data Exceeds Hardware & Software costs • Value in connecting data sets • Grouping e-commerce users by user agent

  6. The Data Revolution • Extremely difficult/impossible to scale writes in RDBMS • Vertical scaling is limited/expensive • Horizontal scaling is limited or requires $$ • Shift from ACID to BASE • Basically Available, Scalable, Eventually Consistent • NoSQL datastores emerge as “point solutions” • Amazon/Google papers • Facebook, LinkedIn …

  7. NoSQL “Not Only SQL” NOSQL \no-seek-wool\ n. Describes ongoing trend where developers increasingly opt for non-relational databases to help solve their problems, in an effort to use the right tool for the right job. • Query Mechanisms: • Key lookup, map-reduce, query-by-example, query language, traversals

  8. Big Data “Big data” refers to datasets whose size is beyond the ability of typical database software tools to capture, store, manage, and analyze. A subjective and moving target. Big data in many sectors today range from 10’s of TB to multiple PB

  9. Reality Check

  10. Reality Check

  11. Project Goals

  12. Spring Data - Background and Motivation • Data access landscape has changed considerably • RDBMS are still important and predominant • but no longer considered a “one size fits all” solution • But they have limitations • Hard to scale • New data access technologies are solving problems RDBMS can’t • Higher performance and scalability, different data models • Often limited transactional model and relaxed consistency • Polyglot persistence is becoming more prevalent • Combine RDBMS + other DBs in a solution

  13. Spring and Data Access • Spring has always provided excellent data access support • Transaction Management • Portable data access exception hierarchy • JDBC – JdbcTemplate • ORM - Hibernate, JPA, JDO, Ibatis support • Cache support (Spring 3.1) • Spring Data project started in 2010 • Goal is to “refresh” Spring’s Data Access support • In light of new data access landscape

  14. Spring Data Mission Statement 89% of all virtualized applications in the world run on VMware. Gartner, December 2008 “ Provides a familiar and consistent Spring-based programming model for Big Data, NoSQL, and relational stores while retaining store-specific features and capabilities.

  15. Spring Data Mission Statement 89% of all virtualized applications in the world run on VMware. Gartner, December 2008 “ Provides a familiar and consistent Spring-based programming model for Big Data, NoSQL, and relational stores while retaining store-specific features and capabilities.

  16. Spring Data Mission Statement 89% of all virtualized applications in the world run on VMware. Gartner, December 2008 “ store-specific features and capabilities.

  17. Spring Data – Supported Technologies • Big Data • Hadoop • HDFS and M/R • Hive • Pig • Cascading • Splunk • Access • Repositories • QueryDSL • REST • Relational • JPA • JDBC Extensions • NoSQL • Redis • HBase • Mongo • Neo4j • Lucene • Gemfire

  18. Spring Data – Have it your way • Shared programming models and data access mechanisms • Repository Model • Common CRUD across data stores • Integration with QueryDSL • Typesafe query language • REST Exporter • Expose repository over HTTP in a RESTful manner. • Database specific features are accessed through familiar Spring Template pattern • RedisTemplate • HBaseTemplate • MongoTemplate • Neo4jTemplate • GemfireTemplate

  19. Project Tour

  20. JDBC and JPA

  21. Spring Data JDBC Extensions – Oracle Support • Easy Access to native XML, Struct, Array data types • API for customizing the connection environment • Fast Connection Failover • Simplified configuration for Advanced Queuing JMS support and DataSource • Single local transaction for messaging and database access

  22. QueryDSL “ Enables the construction of type-safe SQL-like queries for multiple backends including JPA, JDO, MongoDB, Lucence, SQL and plain collections in Java • - Open Source, Apache 2.0

  23. Problems using Strings for a query language Using strings is error-prone Must remember query syntax, domain classes, properties and relationships Verbose parameter binding by name or position Each back-end has its own query language and API Note: .NET has LINQ

  24. QueryDSL Features QCustomer customer = QCustomer.customer; JPQLQuery query = new JPAQuery(entityManger) Customer bob = query.from(customer) .where(customer.firstName.eq(“Bob”) .uniqueResult(customer) • Code completion in IDE • Almost no syntactically invalid queries allowed • Domain types and properties can be references safely (no Strings) • Helper classes generated via Java annotation processor • Much less verbose than JPA2 Criteria API

  25. Using QueryDSL for JDBC QAddress qAddress = QAddress.address; SQLTemplates dialect = new HSQLDBTemplates(); SQLQuery query = new SQLQueryImpl(connection, dialect) .from(qAddress) .where("London")); List<Address> results = query.list(new QBean<Address>(Address.class, qAddress.street,,; Querydsl Predicate • Incorporate code-generation into your build process • To create a query meta-model of domain classes or Tables (JDBC) • For SQL

  26. Spring JDBC Extension – QueryDslJdbcTemplate • Wrapper around JdbcTemplate that supports • Using Querydsl SQLQuery classes to execute queries • Integrates with Spring’s transaction management • Automatically detects DB type and set SQLTemplates dialect • Spring RowMapper and ResultSetExtractors for mapping to POJOs • Executing insert, updates and deletes with Querdsl’s SQLInsertClause, SQLUpdateClause, and SQLDeleteClause

  27. Spring JDBC Extension – QueryDslJdbcTemplate // Query with join QCustomer qCustomer = QCustomer.customer; SQLQuery findByIdQuery = qdslTemplate.newSqlQuery() .from(qCustomer) .leftJoin(qCustomer._addressCustomerRef, qAddress) .where(;

  28. JPA and Repositories

  29. Repositories Mediates between the domain and data mapping layers using a collection-like interface for accessing domain objects.

  30. Spring Data Repositories We remove the busy work of developing a repository

  31. For Example… publicinterface CustomerRepository { Customer findOne(Long id); Customer save(Customer customer); Customer findByEmailAddress(EmailAddress emailAddress); } @Entity publicclass Customer { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; @Column(unique = true) private EmailAddress emailAddress; @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true) @JoinColumn(name = "customer_id") private Set<Address> addresses = new HashSet<Address>(); // constructor, properties, equals, hashcode omitted for brevity }

  32. Traditional JPA Implementation @Repository public class JpaCustomerRepository implements CustomerRepository { @PersistenceContext private EntityManager em; @Override public Customer findOne(Long id) { returnem.find(Customer.class, id); } public Customer save(Customer customer) { if (customer.getId() == null) { em.persist(customer); return customer; } else { returnem.merge(customer); } } ...

  33. Traditional JPA Implementation . . . @Override public Customer findByEmailAddress(EmailAddress emailAddress) { TypedQuery<Customer> query = em.createQuery("select c from Customer c where c.emailAddress = :email", Customer.class); query.setParameter("email", emailAddress); return query.getSingleResult(); } }

  34. Spring Data Repositories • A simple recipe • Map your POJO using JPA • Extend a repository (marker) interface or use an annotation • Add finder methods • Configure Spring to scan for repository interfaces and create implementations • Inject implementations into your services and use as normal…

  35. Spring Data Repository Example publicinterface CustomerRepository extends Repository<Customer, Long> { // Marker Interface Customer findOne(Long id); Customer save(Customer customer); Customer findByEmailAddress(EmailAddress emailAddress); } @RepositoryDefinition(domainClass=Customer.class, idClass=Long.class) publicinterface CustomerRepository { . . . } or

  36. Spring Data Repository Example @Configuration @EnableJpaRepositories @Import(InfrastructureConfig.class) publicclass ApplicationConfig { } <jpa:repositories base-package="com.oreilly.springdata.jpa" /> Boostratp with JavaConfig Or XML And Spring will create an implementation the interface

  37. Spring Data JPA - Usage Wire into your transactional service layer as normal

  38. Query Method Keywords How does findByEmailAddres work…

  39. Spring Data Repositories - CRUD publicinterface 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(); }

  40. Paging, Sorting, and custom finders publicinterface PagingAndSortingRepository<T, ID extends Serializable> extends CrudRepository<T, ID> { Iterable<T> findAll(Sort sort); Page<T> findAll(Pageable pageable); } publicinterfacePersonRepositoryextendsCrudRepository<Person,BigInteger> { // Finder for a single entity Person findByEmailAddress(String emailAddress); // Finder for a multiple entities List<Person> findByLastnameLike(String lastName); // Finder with pagination Page<Person> findByFirstnameLike(String firstName, Pageable page); }

  41. Spring Data JPA – Customize Query Methods publicinterfaceCustomerRepositoryextendsCrudRepository<Customer,Long> { // previous methods omitted… @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); } • Query methods use method naming conventions • Can override with Query annotation • Or method name references JPA named query

  42. Spring Data JPA – Other features Specifications using JPA Criteria API LockMode, override Transactional metadata, QueryHints Auditing, CDI Integration QueryDSL support

  43. Querydsl and JPA CriteriaBuilder builder = entityManagerFactory.getCriteriaBuilder(); CriteriaQuery<Person> query = builder.createQuery(Person.class); Root<Person> men = query.from( Person.class ); Root<Person> women = query.from( Person.class ); Predicate menRestriction = builder.and( builder.equal( men.get( Person_.gender ), Gender.MALE ), builder.equal( men.get( Person_.relationshipStatus ), RelationshipStatus.SINGLE ) ); Predicate womenRestriction = builder.and( builder.equal( women.get( Person_.gender ), Gender.FEMALE ), builder.equal( women.get( Person_.relationshipStatus ),RelationshipStatus.SINGLE ) ); query.where( builder.and( menRestriction, womenRestriction ) ); • Easier and less verbose and JPA2 Criteria API • “equals property value” vs. “property equals value” • Operations via a builder object

  44. Querydsl and JPA JPAQuery query = new JPAQuery(entityManager); QPerson men = new QPerson("men"); QPerson women = new QPerson("women"); query.from(men, women).where(men.gender.eq(Gender.MALE), men.relationshipStatus.eq(RelationshipStatus.SINGLE), women.gender.eq(Gender.FEMALE), women.relationshipStatus.eq(RelationshipStatus.SINGLE)); Querydsl Predicates verus…

  45. QueryDSL - Repositories publicinterface QueryDSLPredicateExecutor<T> { long count(com.mysema.query.types.Predicate predicate); T findOne(Predicate predicate); List<T> findAll(Predicate predicate); List<T> findAll(Predicate predicate, OrderSpecifier<?>... orders); Page<T> findAll(Predicate predicate, Pageable pageable); } public interface ProductRepository extends Repository<Product,Long>, QueryDslPredicateExecutor<Product> { … } Product iPad = productRepository.findOne("iPad")); Predicate tablets = product.description.contains("tablet"); Iterable<Product> result = productRepository.findAll(tablets);

  46. Tooling Support

  47. Code Tour - JPA

  48. NoSQL Data Models

  49. Key/Value Familiar, much like a hash table Redis, Riak, Voldemort,… Amazon Dynamo inspired

  50. Column Family • Extended key/value model • values can also be key/value pairs • HBase, Cassandra • Google Bigtable inspired