Spring Data JPA Introduction First understand what JPA is?
JPA (Java Persistence API) is the Java Persistence specification proposed by Sun . It provides Java developers with an object/association mapping tool to manage relational data in Java applications. The main purpose of his presence is to simplify existing persistent development efforts and integrate ORM technology, and to end the current Hibernate,toplink,jdo and other ORM frameworks for each battalion. It is worth noting that JPA is developed on the basis of fully absorbing the existing HIBERNATE,TOPLINK,JDO and other ORM frameworks, with the advantages of ease of use and strong scalability. In response to the current development community, JPA has been greatly supported and praised, including the spring and EJB3.0 development teams.
Note:JPA is a set of specifications, not a set of products, then like hibernate,toplink,jdo they are a set of products, if these products implement this JPA specification, then we can call them to implement products for JPA .
Spring Data JPA
Spring Data JPA is a set of JPA application frameworks encapsulated on the basis of the ORM framework and JPA specifications of spring, enabling developers to access and manipulate data with minimalist code. It provides common functions including additions and deletions, and is easy to expand! Learning and using Spring Data JPA can greatly improve development efficiency!
Spring data JPA frees us from the DAO layer operations, and basically all crud can rely on it to implement
Basic Query
The basic query is also divided into two, one is spring data by default has been implemented, one is based on the query method to automatically parse into SQL.
Pre-build method
Spring Data JPA defaults to pre-generating some basic curd methods, such as: Add, delete, change, etc.
1 Inheritance Jparepository
public interface UserRepository extends JpaRepository<User, Long> {}
2 Using the default method
@TestPublicvoidTestbasequery()ThrowsException{UserUser=NewUser();userrepository.. (1l. (user. (user.. (1l // ... /span>
It doesn't explain what you mean by the method name.
customizing simple Queries
A custom simple query is the automatic generation of SQL based on the method name, the main syntax being,,, followed by the findXXBy
readAXXBy
queryXXBy
countXXBy
getXXBy
property name:
User findByUserName(String userName);
Also use some keywords plus some And
,Or
User findByUserNameOrEmail(String username, String email);
Modifications, deletions, and statistics are similar syntax
Long deleteById(Long id);Long countByUserName(String userName)
Basically the keywords in the SQL system can be used, for example: LIKE
,, IgnoreCase
OrderBy
.
List<User> findByEmailLike(String email);User findByUserNameIgnoreCase(String userName); List<User> findByUserNameOrderByEmailDesc(String email);
Specific keywords, using methods and production into SQL are shown in the following table
Keyword |
Sample |
JPQL Snippet |
and |
Findbylastnameandfirstname |
... where x.lastname =? 1 and x.firstname =? 2 |
Or |
Findbylastnameorfirstname |
... where x.lastname =? 1 or x.firstname =? 2 |
Is,equals |
Findbyfirstnameis,findbyfirstnameequals |
... where x.firstname =? 1 |
Between |
Findbystartdatebetween |
... where x.startdate between? 1 and? 2 |
LessThan |
Findbyagelessthan |
.. where X.age <? 1 |
Lessthanequal |
Findbyagelessthanequal |
... where x.age?? 1 |
GreaterThan |
Findbyagegreaterthan |
.. where X.age >? 1 |
Greaterthanequal |
Findbyagegreaterthanequal |
... where x.age >=? 1 |
After |
Findbystartdateafter |
.. where X.startdate >? 1 |
Before |
Findbystartdatebefore |
.. where X.startdate <? 1 |
IsNull |
Findbyageisnull |
... where x.age is null |
Isnotnull,notnull |
Findbyage (IS) notnull |
... where x.age not null |
Like |
Findbyfirstnamelike |
... where x.firstname like? 1 |
Notlike |
Findbyfirstnamenotlike |
... where x.firstname not? 1 |
Startingwith |
Findbyfirstnamestartingwith |
... where x.firstname like? 1 (parameter bound with appended%) |
Endingwith |
Findbyfirstnameendingwith |
... where x.firstname like? 1 (parameter bound with prepended%) |
Containing |
Findbyfirstnamecontaining |
... where x.firstname like? 1 (parameter bound wrapped in%) |
By |
Findbyageorderbylastnamedesc |
... where x.age =? 1 ORDER BY X.lastname DESC |
Not |
Findbylastnamenot |
.. where X.lastname <>? 1 |
Inch |
Findbyagein (Collection Ages) |
... where x.age in? 1 |
Notin |
Findbyagenotin (Collection Age) |
... where x.age not in? 1 |
TRUE |
Findbyactivetrue () |
... where x.active = True |
FALSE |
Findbyactivefalse () |
... where x.active = False |
IgnoreCase |
Findbyfirstnameignorecase |
... where UPPER (x.firstame) = UPPER (? 1) |
Complex queries
In the actual development we need to use the paging, delete, and even the table query when you need a special method or custom SQL
Paging Query
Paged query in the actual use of the very common, spring data JPA has helped us achieve the function of paging, in the query method, the need to pass in Parameters Pageable
, when the query has more than one parameter is Pageable
recommended as the last parameter passed in
Page<User> findALL(Pageable pageable); Page<User> findByUserName(String userName,Pageable pageable);
Pageable
is a spring-encapsulated paging implementation class that requires an incoming number of pages, a per-page count, and a collation
@TestPublicvoidTestpagequery()ThrowsException{IntPage=1,Size=10;SortSort=Newsort (direction. Desc "id" pageable pageable = new Pagerequest (pagesizesortuserrepository. (pageableuserrepository. ( "testname" pageable /span>
restricting queries
Sometimes we just need to query the top n elements, or draw the previous entity.
SerFindfirstbyorderbylastnameasc();UserFindtopbyorderbyagedesc();Page<user> queryfirst10bylastname ( string lastnamepageable Pageablelist<user> Findfirst10bylastname (string lastnamesort sort); <user> findtop10bylastname (string lastnamepageable pageable
Custom SQL queries
In fact, most of the SQL in spring data can be implemented according to the method name definition, but for some reason we want to use custom SQL to query, spring data is also the perfect support;
Use annotations on SQL query methods @Query
, such as those related to delete and modify when required @Modifying
. You can also add @Transactional
support for things, query timeout settings, etc. as needed.
@Modifying@Query("Update User u set u.username =? 1 where c.id =? 2")IntModifybyidanduserid(StringUserName, Long ID); @Transactional@Modifying@Query("Delete from User where id =? 1")void Deletebyuserid (Long ID); @Transactional(timeout = ten)@Query("Select u from User u where u.emailaddress =? 1 ") User findbyemailaddress(String emailaddress);
Multi-Table Query
There are two implementations of multi-table queries in spring data JPA, the first of which is implemented using Hibernate cascade queries, and the second is to create a result set interface to receive the results of a query with a table, the main second way.
You first need to define an interface class for a result set.
PublicInterfaceHotelsummary{city getcity (); getname () getaveragerating () Default integer getaverageratingrounded () {return getaveragerating () == null Span class= "O"? null : (int) Math. (getaveragerating ()); /span>
The method return type of the query is set to the newly created interface
@Query("Select H.city as City, H.name as name, AVG (r.rating) as averagerating"- "from Hotel H left outer joins h.reviews r where h.city =? 1 Group by H" pa Ge<hotelsummary> findbycity (city citypageable pageable @Query ( "select H.name as Name, AVG (r.rating) as averagerating" - "from Hotel H left Outer joins h.reviews R GROUP by H" page
<
hotelsummary> findbycity ( span class= "n" >pageable pageable
Use
Page<Hotelsummary>Hotels=This.hotelrepository. (new pagerequest (0< Span class= "O", 10direction. Asc (hotelsummary summay:hotels {system.. ( "Name" +summay. Getname /span>
In the run spring will automatically produce a proxy class for the interface (Hotelsummary) to receive the returned result, which is used in getXX
the form of code summarization to get
Reproduced in: http://www.ityouknow.com/
Http://www.ityouknow.com/springboot/2016/08/20/springboot (%e4%ba%94)-spring-data-jpa%e7%9a%84%e4%bd%bf%e7%94% A8.html
Some understandings about SPRING-DATA-JPA