Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Spring Data JPA and Spring Data MongoDB by Nik ...

Michael Isvy
January 28, 2014

Spring Data JPA and Spring Data MongoDB by Nik Trevallyn Jones

Michael Isvy

January 28, 2014
Tweet

More Decks by Michael Isvy

Other Decks in Technology

Transcript

  1. Copyright 2005-2008 SpringSource. Copying, publishing or distributing without express written

    permission is prohibit Introduction to Spring Data Writing and Migrating projects using Spring Data JPA and MongoDB
  2. 2 Topics in this session • Overview of Spring Data

    • Spring Data basics • Quick Start • Spring Data JPA • Spring Data MongoDB
  3. 3 Overview of Spring Data • Spring Data is an

    umbrella project to simplify persisting POJOs to various forms of storage – Sub-projects exist for different backend technologies • SQL – JDBC, JPA • NOSQL – MongoDB, CouchDB, Gemfire • Others – REST, Hadoop • Focus is on retrieving POJOs from the backend, and saving POJOs to the backend
  4. 4 Spring Data sub-projects Spring Data JPA vFabric Gemfire MongoDB

    Apache Hadoop REST JDBC extensions And many more ... Core project Sub-projects
  5. 5 Spring Data Goals • Reduce boilerplate code • Automate

    common tasks and code • Automate configuration – Convention over configuration • Avoid the “lowest-common-denominator” syndrome – Many systems that “unify” disparate backends do so by supporting only the features they have in common – Therefore fail to support the feature that make each backend different (interesting)
  6. 6 Topics in this session • Overview of Spring Data

    • Spring Data Basics • Quick Start • Spring Data JPA • Spring Data MongoDB
  7. 7 Spring Data Basics • Repository – Convert retrieved data

    into POJOs – Convert POJOs into saved data • Mapping – Inferred from conventions – Annotations to help automate field mapping • Template – Provide simplified direct-access to database • Automatically managing internal resources • Query – Apply provided native queries directly – Convert QueryDSL into native queries
  8. 8 Spring Data Components • Repositories – Based on the

    successful design in the 3 layer architecture – Implementation of the “adaptor” pattern – Application side of the adaptor deals with “what” – Database side of the adaptor deals with “how” • Mapping – Map data to/from storage and POJO fields – Based on existing mapping systems • ORM, POX, marshaller/unmarshaller
  9. 9 Spring Data Components (2) • Templates – Implementation of

    the “template” pattern – Provide high-level API for backend whilst hiding internal backend complexity • Queries – Declarative native queries • Programmer declares query to use, and Spring Data runs it when needed – QueryDSL • DSL (Domain Specific Language) for queries • Programmer writes in generic DSL • Spring Data converts DSL to native query of backend
  10. 10 3 layer architecture Service Layer Data Access Layer Infrastructure

    Layer • Classic example of a Separation of Concerns – Each layer is abstracted from the others – Data Access Layer (repositories) is an adaptor between service layer and backends (infrastructure)
  11. 11 Spring Data Repositories • Auto-generated – Big saving in

    boilerplate code • Defined by interface declarations – Spring fills in the details • Methods can be overridden – Using annotations – By writing specific code • Can be extended – Define extra methods in an interface – Implement the methods in an Impl class
  12. 12 Spring Data Mapping • Convention over configuration – Mapping

    can be optional • Annotations in class to define mappings @Entity @Table(...) public class Customer { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; private Date firstOrderDate; private String email; // Other data-members } @Document public class Customer { ... @Region public class Customer { ... JPA – map to a Table Gemfire – map to a region MongoDB – map to a JSON document
  13. 13 Spring Data Templates • High-level methods match capabilities of

    the underlying technology – load(), save(), find() ... • Backend resources managed transparently • Passively integrate into Spring components when configured with Spring – Through Dependency Injection
  14. 14 Spring Data Queries • Annotations for declaring native queries

    • QueryDSL for constructing queries in abstract language // native query @Query("select u from User u where u.emailAddress = ?1") User findByEmail(String email); // queryDSL List<User> findAllByZIP(String zip) { return findAll(person.address.zipcode.eq(zip)); }
  15. 15 Topics in this session • Overview of Spring Data

    • Spring Data basics • Quick Start • Spring Data JPA • Spring Data MongoDB
  16. 16 Quick Start • Declare your repository extending Spring Data

    – Note: repository is declared as an interface – Define features by declaring additional methods import org.springframework.data.repository.Repository; import org.springframework.data.jpa.repository.Query; public interface UserRepository extends Repository<User, Long> { <S extends User> save(S entity); // Definition as per CRUDRepository User findById(long i); // Query determined from method name User findByNameIgnoreCase(String name); // Case insensitive search @Query("select u from User u where u.emailAddress = ?1") User findByEmail(String email); // ?1 replaced by method param }
  17. 17 Predefined Repository Interfaces public interface Repository<T, ID> { }

    public interface CrudRepository<T, ID> extends Repository<T, ID> { public <S extends T> T save(S entity); public <S extends T> Iterable<S> save(Iterable<S> entities); public T findOne(ID id); public Iterable<T> findAll(); public void delete(ID id); public void delete(T entity); public void delete(Iterable<? extends T> entities); public void deleteAll(); public long count(); public boolean exists(ID id); } Marker interface – add any methods from CrudRepository or finders You get all these methods automatically PagingAndSortingRepository<T, K> - adds Iterable<T> findAll(Sort) - adds Page<T> findAll(Pageable)
  18. 18 Extending CRUDRepository • Simple repositories define no custom methods!

    – Rely solely on predefined methods import org.springframework.data.repository.CRUDRepository; public interface UserRepository extends CRUDRepository<User, Long> { } import org.springframework.data.repository.CRUDRepository; public interface UserRepository extends CRUDRepository<User, Long> { @Query("select u from User u where u.emailAddress = ?1") User findByEmail(String email); } More complex repositories simply define additional methods
  19. 19 Quick Start (3) • Additional interfaces provided – CRUDRepository

    public interface CRUDRepository<T, I> { T findOne(I id); Iterable<T> findAll(); T save(T entity); Iterable<T> save(Iterable(? extends T> entiries); void delete(T entity); void delete(I id); void delete(T entity); void delete(Iterable<> extends T> entities); void deleteAll(); long count(); boolean exists(I id); }
  20. 20 Quick Start (4) • Additional interfaces provided – PagingAndSortingRepository

    interface PagingAndSortingRepository<T, I> extends CRUDRepository<> { Page<T> findAll(Pageable pageable); Iterable<T> findAll(Sort sort); }
  21. 21 Defining finders public interface CustomerRepository extends CrudRepository<Customer, Long> {

    public Customer findByEmail(String someEmail); // No <Op> for Equals public Customer findByFirstOrderDateGt(Date someDate); public Customer findByFirstOrderDateBetween(Date d1, Date d2); @Query(“SELECT c FROM Customer c WHERE c.email NOT LIKE '%@%'”) public List<Customer> findInvalidEmails(); } Custom query uses query-language of underlying product (here JPQL) ID • Auto-generated finders obey naming convention – findBy<DataMember><Op> – <Op> can be Gt, Lt, Ne, Between, Like … etc
  22. 22 Instant Repositories • Spring implements your repositories at run-time

    – Scans for interfaces implementing Repository <T, ID> – CRUD methods auto-generated – Paging, custom queries, and sorting supported – Variations exist for most Spring Data sub-projects <jpa:repositories base-package="com.acme.**.repository" /> <mongo:repositories base-package="com.acme.**.repository" /> <gfe:repositories base-package="com.acme.**.repository" />
  23. 23 Internal behavior • Before startup • After startup Interface

    UserRepository Interface UserRepository $Proxy1 implements You can conveniently use Spring to inject a dependency of type UserRepository. Implementation is generated at startup time. <jpa:repositories base-package="com.acme.repository" />
  24. 24 Using Dependency Injection Service Layer Data Access Layer Infrastructure

    Layer • Layers are connected using Dependency Injection – Repository objects are injected into Service layer – Service layer objects do not know which concrete implementation is used
  25. 25 Topics in this session • Overview of Spring Data

    • Spring Data basics • Quick Start • Spring Data JPA • Spring Data MongoDB
  26. 27 Topics in this session • Overview of Spring Data

    • Spring Data basics • Quick Start • Spring Data JPA • Spring Data MongoDB
  27. 28 Spring Data MongoDB • Generated repositories map mongodb Documents

    to POJO objects • Mapping can be completely automatic – Annotations used to override or clarify • Template class allows simplified, direct access to mongo database • @Query supports mongodb queries – JSON syntax • QueryDSL can be used to avoid writing mongo queries
  28. 30 MongoDB ObjectIDs • MongoDB creates object ids in the

    client – Not in the server • Object ids are a UUID (Universally Unique ID) – 12 bytes: TTTTmmmPPccc – Can be converted to/from String and BigInteger • not Integer or Long – Integer and Long ids can be stored and retrieved, but they cannot be initialised automatically • Must do it manually in code • Simplest approach: don't fight it – Managing db-wide unique keys is hard work
  29. 31 MongoDB and transactions • MongoDB does not support an

    explicit transactional model – @Transactional not used by MongoDB – TransactionManager bean not needed – If you are using JPA and MongoDB together, then you would still configure @Transactional and TransactionManager for JPA
  30. 33 Summary • Spring Data focuses on mapping POJOs to/from

    data backends (typically databases) • Based on the adaptor pattern – Convert “what” into “how” • Implemented using dynamically generated repositories • Repositories are declared as interfaces – Spring Data implements the details • Annotations allow tailoring of the generated implementation • Any implementation can be manually overridden
  31. 34 Summary (2) • Mapping is inferred where possible •

    Annotations in domain classes help drive the mapping • Template classes allow direct access to backend whilst still automatically managing resources • Range of query support – Dynamically generate finders – Declarative query in native syntax – DSL translated into native syntax