Using the methods in the repository to solve practical problems

author ：Damon

Blog ：

http://www.damon8.cn

Make a friend of the ape world  |  Microservices  |  Containerization  |  automation

Repository  What are the returned results of

We've already introduced  Repository  The interface of , Now let's take a look at the return results supported by these interfaces , As shown in the figure below ：

open  SimpleJpaRepository  Look directly at it  Structure  We can know , Its implementation method , And the methods and return types of the parent class interface, including ：Optional、Iterable、List、Page、Long、Boolean、Entity  Object etc. , In fact, more return types are supported .

because  Repository  It supports  Iterable, So actually  java  The standard  List、Set  Can be returned as a result , And will also support its subclasses ,Spring Data  It defines a special subclass  Steamable,Streamable  Can replace  Iterable  Or any collection type . It also provides a convenient way to access  Stream, You can do it directly on the element  ….filter(…)  and  ….map(…)  operation , And will  Streamable  Connect to other elements . Let's see a story about  UserRepository  Direct inheritance  JpaRepository  Example .

public interface UserRepository extends JpaRepository<User,Long> {

}


Use the old one  UserRepository  class , Make the following calls in the test class ：

User user = userRepository.save(User.builder().name("jackxx").email("[email protected]").sex("man").address("shanghai").build());

Assert.assertNotNull(user);

Streamable<User> userStreamable = userRepository.findAll(PageRequest.of(0,10)).and(User.builder().name(&quot;jack222&quot;).build());

userStreamable.forEach(System.out::println);


Then we will get the following output ：

User(id=1, name=jackxx, [email protected], sex=man, address=shanghai)

User(id=null, name=jack222, email=null, sex=null, address=null)


This example  Streamable

<User>

 userStreamable, Realized  Streamable  Return result of , If you want to customize the method , You can do the following .

Customize  Streamable

The official has provided us with customized  Streamable  Methods , However, in practical work, it is rare to customize the guaranteed result class , Here I briefly introduce the method , Here's an example ：

class Product { (1)

 MonetaryAmount getPrice() { … }

}

@RequiredArgConstructor(staticName = "of")

class Products implements Streamable<Product> { (2)

 private Streamable<Product> streamable;

 public MonetaryAmount getTotal() { (3)

 return streamable.stream() //

 .map(Priced::getPrice)

 .reduce(Money.of(0), MonetaryAmount::add);

 }

}

interface ProductRepository implements Repository<Product, Long> {

 Products findAllByDescriptionContaining(String text); (4)

}


The above four steps introduce customization  Streamable  Methods , Respectively ：

（1）Product  Entity , Open  API  To access product prices .

（2）Streamable

<Product>

  The type of packaging can be through  Products.of(…)  structure （ adopt  Lombok  Annotation creates factory methods ）.

（3） The type of wrapper is  Streamable

<Product>

  Other methods for calculating new values are disclosed on  API.

（4） The wrapper type can be used directly as the return type of the query method . No need to return  Stremable

<Product>

  And manually wrap it in the repository  Client  In the middle .

Through the above example, you can customize  Streamable, The principle is simple , Is to achieve Streamable Interface , Define your own implementation class . We can also look at the source code  QueryExecutionResultHandler  Is there any  Streamable  Judgment of subclasses , To support customization  Streamable, The key source code is as follows ：

Through the source code you will find  Streamable  Why it works , Let's take a look at the return implementation of common collection classes .

Return result type  List/Stream/Page/Slice

In actual development , How do we get back to  List/Stream/Page/Slice  Well ？

First , Build our new  UserRepository：

package com.example.jpa.example1;

import org.springframework.data.domain.Pageable;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.data.jpa.repository.Query;

import java.util.stream.Stream;

public interface UserRepository extends JpaRepository<User,Long> {

 // Customize a query method , return Stream object , And has paging properties

 @Query(&quot;select u from User u&quot;)

 Stream<User> findAllByCustomQueryAndStream(Pageable pageable);

 // test Slice Return result of

 @Query(&quot;select u from User u&quot;)

 Slice<User> findAllByCustomQueryAndSlice(Pageable pageable);

}


then , Modify our test case class , as follows , Verify the result ：

package com.example.jpa.example1;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.ObjectMapper;

import org.assertj.core.util.Lists;

import org.junit.Assert;

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;

import org.springframework.data.domain.Page;

import org.springframework.data.domain.PageRequest;

import org.springframework.data.domain.Slice;

import org.springframework.data.util.Streamable;

import java.util.List;

import java.util.stream.Stream;

@DataJpaTest

public class UserRepositoryTest {

 @Autowired

 private UserRepository userRepository;

 @Test

 public void testSaveUser() throws JsonProcessingException {

 // We added 7 This piece of data is convenient for testing paging results

 userRepository.save(User.builder().name("jack1").email("[email protected]").sex("man").address("shanghai").build());

 userRepository.save(User.builder().name("jack2").email("[email protected]").sex("man").address("shanghai").build());

 userRepository.save(User.builder().name("jack3").email("[email protected]").sex("man").address("shanghai").build());

 userRepository.save(User.builder().name("jack4").email("[email protected]").sex("man").address("shanghai").build());

 userRepository.save(User.builder().name("jack5").email("[email protected]").sex("man").address("shanghai").build());

 userRepository.save(User.builder().name("jack6").email("[email protected]").sex("man").address("shanghai").build());

 userRepository.save(User.builder().name("jack7").email("[email protected]").sex("man").address("shanghai").build());

 // We make use of ObjectMapper Return our results Json to String

 ObjectMapper objectMapper = new ObjectMapper();

 // return Stream Type the results （1）

 Stream<User> userStream = userRepository.findAllByCustomQueryAndStream(PageRequest.of(1,3));

 userStream.forEach(System.out::println);

 // Return paging data （2）

 Page<User> userPage = userRepository.findAll(PageRequest.of(0,3));

 System.out.println(objectMapper.writeValueAsString(userPage));

 // return Slice result （3）

 Slice<User> userSlice = userRepository.findAllByCustomQueryAndSlice(PageRequest.of(0,3));

 System.out.println(objectMapper.writeValueAsString(userSlice));

 // return List result （4）

 List<User> userList = userRepository.findAllById(Lists.newArrayList(1L,2L));

 System.out.println(objectMapper.writeValueAsString(userList));

 }

}


At this time, let's look at the four test results ：

The first one is ： adopt

Stream

<User>

Take the data on the second page , The results are as follows ：

User(id=4, name=jack4, [email protected], sex=man, address=shanghai)

User(id=5, name=jack5, [email protected], sex=man, address=shanghai)

User(id=6, name=jack6, [email protected], sex=man, address=shanghai)

Spring Data  Support can be provided by using  Java 8 Stream  The result of the query is processed as a step-by-step method .

It should be noted that ： Flow closure problem

,try catch  Is a common closing method , As shown below ：

Stream<User> stream;

try {

 stream = repository.findAllByCustomQueryAndStream()

 stream.forEach(…);

} catch (Exception e) {

 e.printStackTrace();

} finally {

 if (stream!=null){

 stream.close();

 }

}


The second kind ： return  Page

<User>

  Paging data results , As shown below ：

{

 "content":[

 {

 "id":1,

 "name":"jack1",

 "email":"[email protected]",

 "sex":"man",

 "address":"shanghai"

 },

 {

 "id":2,

 "name":"jack2",

 "email":"[email protected]",

 "sex":"man",

 "address":"shanghai"

 },

 {

 "id":3,

 "name":"jack3",

 "email":"[email protected]",

 "sex":"man",

 "address":"shanghai"

 }

 ],

 "pageable":{

 "sort":{

 "sorted":false,

 "unsorted":true,

 "empty":true

 },

 "pageNumber":0, The current page number

 "pageSize":3, Page size

 "offset":0, Offset

 "paged":true, Whether it is paged

 "unpaged":false

 },

 "totalPages":3, How many pages are there in all

 "last":false, Whether it is in the end

 "totalElements":7, How many keys are there

 "numberOfElements":3, Current data subscript

 "sort":{

 "sorted":false,

 "unsorted":true,

 "empty":true

 },

 "size":3, At present content size

 "number":0, Index of the current page code

 "first":true, Is it the first page

 "empty":false Is there any data

}


Here we can see  Page

<User>

  The data of the first page is returned , And tell us that there are three parts of data ：

• content
  ： Content of data , Now refers to  User  Of  List 3  strip .

• pageable
  ： Paging data , Including what sort field is and its direction 、 What page is it now 、 How many pages altogether 、 Is it the last one .

• Description of the current data
  ：“size”：3, At present  content  size ;“number”：0, Index of the current page code ;  “first”：true, Is it the first page ;“empty”：false, Whether there is no data .

Through these three parts of data, we can know the paging information of the number to be checked . Let's move on to the third test result .

The third kind of ： return  Slice

<User>

  result , As shown below ：

{

 "content":[

 {

 "id":4,

 "name":"jack4",

 "email":"[email protected]",

 "sex":"man",

 "address":"shanghai"

 },

 {

 "id":5,

 "name":"jack5",

 "email":"[email protected]",

 "sex":"man",

 "address":"shanghai"

 },

 {

 "id":6,

 "name":"jack6",

 "email":"[email protected]",

 "sex":"man",

 "address":"shanghai"

 }

 ],

 "pageable":{

 "sort":{

 "sorted":false,

 "unsorted":true,

 "empty":true

 },

 "pageNumber":1,

 "pageSize":3,

 "offset":3,

 "paged":true,

 "unpaged":false

 },

 "numberOfElements":3,

 "sort":{

 "sorted":false,

 "unsorted":true,

 "empty":true

 },

 "size":3,

 "number":1,

 "first":false,

 "last":false,

 "empty":false

}


Then we found the above  Page  The returned results are less , So how many results are there 、 How many pages of data ？ Let's compare the execution of the second and third test results  SQL：

The second is to perform ordinary paging queries  SQL：

Query paging data

Hibernate: select user0_.id as id1_0_, user0_.address as address2_0_, user0_.email as email3_0_, user0_.name as name4_0_, user0_.sex as sex5_0_ from user user0_ limit ?

Calculate paging data

Hibernate: select count(user0_.id) as col_0_0_ from user user0_


The third kind of execution  SQL  as follows ：

Hibernate: select user0_.id as id1_0_, user0_.address as address2_0_, user0_.email as email3_0_, user0_.name as name4_0_, user0_.sex as sex5_0_ from user user0_ limit ? offset ?


By contrast, we can see , Only query offset , Do not calculate paging data , This is it.  Page  and  Slice  The main difference . Let's move on to the fourth test result .

A fourth ： return  List

<User>

  give the result as follows ：

[

 {

 "id":1,

 "name":"jack1",

 "email":"[email protected]",

 "sex":"man",

 "address":"shanghai"

 },

 {

 "id":2,

 "name":"jack2",

 "email":"[email protected]",

 "sex":"man",

 "address":"shanghai"

 }

]


Come here , We can easily find out  ID=1  and  ID=2  The data of , No paging information .

The above four methods introduce the common forms of multiple data return results , I won't introduce more about a single one , I believe you can understand at a glance , It's just right  JDK8  Of  Optional  Support for . Like supporting  Null  Your elegant judgment , Another is to support direct return  Entity, Or something  /  There is no the  Boolean  The results and some  count  The return result of the number of entries is just .

Let's take a look at  Repository  How to support asynchrony ？

Repository  Yes  Feature/CompletableFuture  Support for asynchronously returning results ：

We can use  Spring  Asynchronous method execution Repository Inquire about , This means that the method will return immediately when called , And the actual query execution will occur when it has been submitted to  Spring TaskExecutor  In the task of , It is more suitable for the actual scenario of scheduled tasks . Asynchrony is relatively simple to use , Direct addition @Async  Annotations can be , As shown below ：

@Async

Future<User> findByFirstname(String firstname); (1)

@Async

CompletableFuture<User> findOneByFirstname(String firstname); (2)

@Async

ListenableFuture<User> findOneByLastname(String lastname);(3)


The return results of the above three asynchronous methods , Explain as follows ：

• First of all ： Use  java.util.concurrent.Future  The return type of ;

• The second place ： Use  java.util.concurrent.CompletableFuture  As return type ;

• The third place ： Use  org.springframework.util.concurrent.ListenableFuture  As return type .

The above is right  @Async  Support for , The following three points should be paid attention to in practical use ：

• In practice , Directly in  Repository  There are few scenarios in which asynchronous methods are used in this layer , Generally, asynchronous annotations are placed in  Service  The method above , In this case , There can be some additional logic , If you send a text message 、 email 、 Send messages, etc ;

• When using asynchrony, you must configure the thread pool , Remember this , otherwise “ die ” It will be ugly .