Learn article from: Http://www.ityouknow.com/spring-boot.htmlspring 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 extends Jparepository<user, long> {}
2 Using the default method
@Test Public void throws Exception { user user=new User (); Userrepository.findall (); Userrepository.findone (1l); Userrepository.save (user); Userrepository.delete (user); Userrepository.count (); Userrepository.exists (1l); // ...}
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
@Test Public void throws Exception { int page=1,size=10; New Sort (DIRECTION.DESC, "id"); New pagerequest (page, size, sort); Userrepository.findall (pageable); Userrepository.findbyusername ("testname", pageable);}
restricting queries
Sometimes we just need to query the top n elements, or draw the previous entity.
ser findfirstbyorderbylastnameasc (); User Findtopbyorderbyagedesc (); Page<User> queryfirst10bylastname (String LastName, pageable pageable); List<User> findfirst10bylastname (String LastName, sort sort); List<User> Findtop10bylastname (String LastName, pageable pageable);
Custom SQL queries
In fact, most of the SQL of 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 is related to deletion and modification in need @Modifying
of adding. You can also add @Transactional
support for things as needed, query timeout settings, etc.
@Modifying @query ("Update User u set u.username =? 1 where u.id =? 2") int Modifybyidanduserid (String userName, Long ID); @Transactional @modifying@query ("Delete from User where id =? 1")void Deletebyuserid (Long ID ); = Ten) @Query ("Select u from user u where u.emailaddress =? 1") User findbyemailaddress (String Emailad Dress);
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.
Public Interface hotelsummary {city getcity (); String getName (); Double getaveragerating (); default Integer getaverageratingrounded () { returnnullnull : (int ) Math.Round (getaveragerating ());} }
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 join h.reviews r where h.city = ?1 group by h")Page<HotelSummary> findByCity(City city, Pageable pageable);@Query("select h.name as name, avg(r.rating) as averageRating "- "from Hotel h left outer join h.reviews r group by h")Page<HotelSummary> findByCity(Pageable pageable);
Use
Page<HotelSummary> hotels = this.hotelRepository.findByCity(new PageRequest(0, 10, Direction.ASC, "name"));for(HotelSummary summay:hotels){System.out.println("Name" +summay.getName());}
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
Multi-source support for multiple data sources supporting homogeneous databases
Because of the distributed development pattern used in daily projects, different services have different data sources, often need to use multiple data sources in one project, so it is necessary to configure the use of sping data JPA for multiple data sources, which is generally divided into three steps:
- 1 Configuring multiple data sources
- 2 entity classes of different sources into different package paths
- 3 declaring different package paths using different data sources, transaction support
Here is an article that is very clear: Spring boot multi-data source configuration and use
Heterogeneous database multi-source support
For example, in our project, we need support for MySQL, as well as a query for MongoDB.
Entity classes declare @Entity
relational database support types, declared @Document
as MongoDB support types, and different data sources use different entities to
interface PersonRepository extends Repository<Person, Long> { …}@Entitypublic class Person { …}interface UserRepository extends Repository<User, Long> { …}@Documentpublic class User { …}
However, if user users use both MySQL and MongoDB, they can also do mixed use
interface JpaPersonRepository extends Repository<Person, Long> { …}interface MongoDBPersonRepository extends Repository<Person, Long> { …}@Entity@Documentpublic class Person { …}
You can also declare different package paths, such as using MongoDB under the Mysql,b package path under a packet path
@EnableJpaRepositories(basePackages = "com.neo.repositories.jpa")@EnableMongoRepositories(basePackages = "com.neo.repositories.mongo")interface Configuration { }
Other
Using enumerations
When using enumerations, we want the database to store an enumeration of the corresponding string type, rather than the index value of the enumeration, to add annotations to the attribute @Enumerated(EnumType.STRING)
@Enumerated(EnumType.STRING) @Column(nullable = true)private UserType type;
Properties that do not need to be mapped with the database
Normally when we add annotations to an entity class @Entity
, we make the entity class and the table related if one of the properties we do not need to associate with the database is just a calculation at the time of the presentation, just add the @Transient
attribute.
@Transientprivate String userName;
学习文章来自:
Springboot (v): Use of spring data JPA
耽误了两天,又开始学习了!
由于我的前端框架是easyui,就没有记录学习
Thymeleaf I also want to mybatis about SQL.
Spring-boot (iii) spring data JPA