Core Spring Data Cheat Sheet

The Spring Data project is part of the ecosystem surrounding the Spring Framework and constitutes an umbrella project for advanced data access related topics. It contains modules to support traditional relational data stores (based on plain JDBC or JPA), NoSQL stores such as MongoDB, Neo4j or Redis, and big data technologies like Apache Hadoop.

At the lowest level, Spring Data provides support to configure infrastructure components and enable features such as repository support. Individual modules provide Spring XML namespaces and, where reasonable, JavaConfig equivalents implemented as @Enable... annotations.

Spring Data provides annotation-based mapping support for different persistence technologies. The supplied refcard shows JPA, MongoDB and Neo4j examples.

Spring Data template implementations have three major responsibilities: transparent integration of object-to-store mapping, resource management, and exception translation into Spring's DataAccessException hierarchy.

Spring Data uses an interface-based programming model to reduce repetitive repository boilerplate. The general quickstart is to create a repository interface, add query methods, and optionally add custom implementation where necessary.

PagingAndSortingRepository provides an API for sorting and page-by-page access. The core abstractions are Sort and Pageable, while Page captures result metadata such as total pages and whether the current page is first or last.

Spring Data also provides integration with third-party projects and technologies. The supplied refcard highlights Querydsl, CDI integration, Spring/SpringMVC integration, and Spring Data REST.

The refcard lists XML namespace elements and JavaConfig support for JPA, MongoDB and Neo4j. fileciteturn4file0L81-L103

JPA Customer

@Entity
public class Customer {
    @Id @GeneratedValue
    private Long id;
    private String firstname, lastname;
    @Column(unique = true)
    private EmailAddress emailAddress;
    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
    @JoinColumn(name = "customer_id")
    private Set<Address> addresses = new HashSet<Address>();
    ...
}

Spring Data JPA supports JPA mapping annotations and essentially does not deal with the mapping itself. fileciteturn4file0L167-L182

MongoDB Customer

@Document
public class Customer {
    @Id
    private BigInteger id;
    private String firstname, lastname;
    @Field("email")
    @Indexed(unique = true)
    private EmailAddress emailAddress;
    private Set<Address> addresses = new HashSet<Address>();
    ...
}

Neo4j Customer

@NodeEntity
public class Customer {
    @GraphId
    private Long id;
    private String firstName, lastName;
    @Indexed(unique = true)
    private String emailAddress;
    @RelatedTo(type = "ADDRESS")
    private Set<Address> addresses = new HashSet<Address>();
    ...
}

Spring Data MongoDB Mapping Annotations

Spring Data Neo4j Mapping Annotations

The Spring Data template classes have three major responsibilities: transparent object-to-store mapping, resource management, and exception translation into Spring's DataAccessException hierarchy. fileciteturn4file0L262-L287

Template method groups

Spring Data uses an interface-based programming model to reduce repetitive repository boilerplate. fileciteturn4file0L288-L302

CustomerRepository

interface CustomerRepository extends Repository<Customer, Long> {
    Customer findByEmailAddress(EmailAddress email);
    List<Customer> findByAddressCity(String city);
    Page<Customer> findByLastnameLike(String lastname, Pageable pageable);
}

The source explains that method names are parsed into store-specific queries and that the query is created during application bootstrap. fileciteturn4file0L309-L355

Customizing Query Execution with @Query

interface CustomerRepository extends Repository<Customer, Long> {
    @Query("select c from Customer c where c.emailAddress = ?1")
    Customer findByEmailAddress(EmailAddress email);
}

The source also describes JPA named queries and store-named query properties files as alternatives for keeping queries outside the repository interface. fileciteturn4file0L375-L389

Repository Base Interfaces

The refcard recommends avoiding store-specific interfaces when possible because they reveal persistence technology to the client and couple the code to it. fileciteturn4file0L390-L413

PagingAndSortingRepository captures sorting and page-by-page access through Sort, Pageable, and Page. fileciteturn4file0L414-L445

// Create request for the 2nd page by a page size of 10
Sort sort = new Sort(Direction.ASC, "lastname", "firstname");
Pageable pageable = new PageRequest(1, 10, sort);
Page<Customer> customers = repository.findAll(pageable);

assertThat(customers.isFirstPage(), is(false));
assertThat(customers.hasNextPage(), is(true));

for (Customer customer : customers) {
    // ... do something with the Customer
}

Request Parameters

Customization Annotations

Querydsl

Querydsl brings LINQ-style query capabilities to Java. It is centered around a meta-model generated from domain classes, which can define predicates executed through a Spring Data repository. fileciteturn4file0L446-L490

Maven Meta-model Generation

<plugin>
    <groupId>com.mysema.maven</groupId>
    <artifactId>apt-maven-plugin</artifactId>
    <version>1.0.9</version>
    <executions>
        <execution>
            <goals>
                <goal>process</goal>
            </goals>
            <configuration>
                <outputDirectory>
                    target/generated-sources/java
                </outputDirectory>
                <processor>
                    com.mysema.query.apt.jpa.JPAAnnotationProcessor
                </processor>
            </configuration>
        </execution>
    </executions>
</plugin>

Predicate Definition

QCustomer customer = Qcustomer.customer;
Predicate predicate = customer.lastname.endswith(...).
    or(customer.firstname.startsWith(...));

Predicate Execution

interface CustomerRepository extends Repository<Customer, Long>,
        QueryDslPredicateExecutor<Customer, Long> {
}

CDI Integration

The source describes four steps: include the necessary Spring Data JARs, declare infrastructure components as CDI beans, declare repositories, and inject repository instances with @Inject. fileciteturn4file0L510-L519

DomainClassConverter Example

@Controller
public class CustomerController {
    @RequestMapping("/customers/{id}")
    public String showUserForm(
        @PathVariable("id") Customer customer, Model model) {
        ...
    }
}

Pagination Argument Resolvers

class WebConfiguration extends WebMvcConfigurationSupport {
    protected void addArgumentResolvers(
        List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(new SortHandlerMethodArgumentResolver());
        resolvers.add(new PageableHandlerMethodArgumentResolver());
    }
}

The source also shows a controller accepting a Pageable argument and using repository.findAll(pageable). fileciteturn4file0L652-L685

Spring Data REST automatically exports repository-managed entities in a hypermedia-driven way, rendering customizable JSON representations and providing extension/customization hooks for validation, security and integration. fileciteturn4file0L686-L700

The repository infrastructure parses query method names into store-specific queries. The refcard lists logical keywords including AFTER, BEFORE, BETWEEN, CONTAINING, ENDING_WITH, EXISTS, GREATER_THAN, IN, IS, NULL checks, LESS_THAN, LIKE, NOT, STARTING_WITH, TRUE, NEAR, WITHIN and REGEX. fileciteturn4file0L309-L364

Example Store Queries