What Is Spring Data JPA?
Firstly, Spring Data is a subproject of Spring, which used to simplify database access. It supports both NoSQL and relational data storage. Spring Data JPA is not a JPA provider, it just adds an extra layer of abstraction on top of the JPA provider.
At first, it seems like Spring Data JPA makes our code more complex. To some extent, that’s true. It does add an extra layer. But at the same time, it also eliminates the need to write boilerplate code.
If we use Spring Data JPA, we don’t need to worry about the actual implementation of repository abstraction. What we need to do is become familiar with the Spring Data Repository Interface, shown as below:
Configuration
First, we must configure the environment for our application which uses Spring Data JPA. We need to add necessary libraries (Spring, Spring Data JPA, Spring Data Common, MySQL, c3p0, slf4j…) and configure the application context of our Spring application.
In applicationContext.xml:
1.Configure the Datasource Bean.
2.Configure the Entity Manager Factory Bean.
3.Configure the Transaction Manager Bean.
4.Configure Annotation-Driven Transaction Management.
5.Configure Spring Data JPA.
6.Configure automatic scanning of packages
Creating the Repository
1.Before we create the repository, we must create an entity class. The relevant parts of our entity are shown below:
2.Now we can create our first repository. We need to create an interface that extends the interface that is provided by Spring Data (e.g. Repository, CrudRepository, PagingAndSortingRepository, QueryDslPredicateExecutor, JpaRepository, JpaSpecificationExecutor…).
- Repository is an empty interface. It is a tag interface. The interface which inherits the Repository interface will be recognized as a Repository Bean by the IOC container. Then we can use the methods provided by the Repository interface and define some simple methods which meet certain norms in this interface. In fact, we can also use the @RepositoryDefinition annotation instead of inheriting the Repository.
- If we create the repository by extending the JpaRepository interface, we must provide two parameters: one is the type of the entity that we use in this repository, the other one is the type of the entity’s id field. The source code about the whole repository is as follows:
2.1 Creating Database Queries From Method Names
If we create query methods using the method name, we should follow these rules:
- The method name must start with a special prefix (e.g. find…By, read…By, get…By, count…By, and query…By).
- If we want to select unique results, we need to add Distinct
- We can use Top or First keywords to limit the number of returned query results.
- We can specify the search criteria by combining property expressions with supported keywords.
- We are supposed to use the method name strategy only when the query is simple or only has one or two search conditions.
2.2 Creating Database Queries Using @Query Annotation
- Using @Query annotation to create a database query precedes all other query generation strategies.
- @Query annotation supports both JPQL and SQL. You need to set the JPQL or SQL query as the value of the @Query
- If you use SQL, you should set the value of @Query annotation’s nativeQuery attribute to true.
- We can add method parameters to the query method and configure the name of the named parameter by annotating the method parameter with @Param
The relevant code is as follows:
- We can also use custom JPQL to use UPDATE and DELETE But it must be modified with @Modifying annotation which is used to inform Spring Data that it is an UPDATE or DELETE operation. It also needs to use the transaction in the service layer.
The relevant code is as follows:
2.3 Simple Sorting and Pagination Using PagingAndSortingRepository
If the repository we created extending the PagingAndSortingRepository interface or the subinterface of it, we can use the findAll (Pageable var1) method which is very simple to implement paging queries.
The relevant code is as follows:
2.4 Creating Database Queries With the JPA Criteria API
- Our repository interface must extend the JpaSpecificationExecutor<T> interface so we can specify the conditions of our database queries by creating new Specification<T> objects.
Relevant code about Pagination (condition: data whose id>5) is as follows:
2.5 Adding Custom Methods Into a Single Repository
Now we can use plenty of CRUD operations provided by Spring Data JPA and creating database queries using method names and @Query Annotation.
If that’s still not enough, for example, sometimes we need to do things that are not supported by Spring Data JPA. In this case, we can extend our own repository by adding custom methods into it following these steps:
2.5.1 Create a custom repository interface:
- Create an interface: CustomPersonRepository
- Add custom method to the created interface.
2.5.2 Implementing the custom repository interface:
- Create a class which implements the CustomPersonRepository The name of this class must follow the syntax: [The name of the repository]Impl.
2.5.3 Adding the custom method into repository:
- Modify the repository to extend the CustomPersonRepository.
2.5.4 Then we can use our own custom method:
