SpringBoot integra Jpa para classificar, paginar, consultar condicionalmente e filtrar dados

Apresentei o uso simples do Jpa integrado do SpringBoot antes e, em seguida, apresentarei o uso do Jpa para conectar-se ao banco de dados para classificar, paginar, consultar condicional e filtrar operações nos dados. Primeiro crie um projeto Springboot e herde as dependências JPA, (https://www.cnblogs.com/eternality/p/17391141.html)

1. Consulta de classificação

Classifique pela classe Sort do método findAll e classifique de acordo com os campos de classe de entidade. Ordem descendente descendente, ordem ascendente ascendente, o padrão é ordem ascendente ascendente se não for preenchido.

List<User> mapperAll = userMapper.findAll(Sort.by("id").descending()); 
mapperAll.forEach(System.out::println);

resultado da pesquisa:

Sort.by() é um parâmetro variável, que pode passar um ou mais valores.

//Classifique primeiro por status, depois classifique por ID 
List<User> statusAll = userMapper.findAll(Sort.by("status","id").descending()); 
statusAll.forEach(System.out: :println) ;

Defina a primeira propriedade em ordem decrescente e a segunda propriedade em ordem crescente

Sort sort = Sort.by("status").descending().and(Sort.by("id").ascending()); 
 List<Usuário> diffOb= userMapper.findAll(sort); 
 diffOb.forEach(System.out::println);

Caso as informações do campo passadas não existam na classe da entidade, o código de acesso reportará um erro. como:

List<Usuário> exceçãoAll = userMapper.findAll(Sort.by("en_name").descending()); 
exceçãoAll.forEach(System.out::println);

   Uma exceção será relatada de que as informações do campo não podem ser encontradas:

org.springframework.data.mapping.PropertyReferenceException: Nenhuma propriedade encontrada para o tipo de usuário! Será que quis dizer 'id'?

2. Consulta de paginação

O JPA nos fornece um método de paginação e podemos visualizar o diagrama de relacionamento da interface JpaRepository integrada à interface. Descobriu que existe uma interface PagingAndSortingRepository.

 Clique na interface para visualizar:

 Use este método de interface para implementar a consulta de paginação. Descobrimos que esse método precisa passar em um Pageable, clique em Pageable para visualizar e descobrir que também é uma interface, clique para visualizar sua classe de implementação.

A paginação pode ser realizada usando a classe PageRequest. PageRequest tem um método estático de. O parâmetro da página é para exibir o número da página atual e o tamanho é para exibir quantos dados são exibidos no momento.

//第一页，显示4条数据  0为一页 1为二页  输入页数大于总页数则输出内容为空
        PageRequest request = PageRequest.of(0, 4); 
        Page<User> userPage = userMapper.findAll(request);
        System.out.println();
        System.out.println("总页数: "+userPage.getTotalPages()); //总页数
        System.out.println("总条数: "+userPage.getTotalElements()); //总条数
        System.out.println("查询的数据: "+userPage.getContent());//查询的数据
        System.out.println("显示条数: "+userPage.getSize()); //显示条数
        System.out.println("当前页数: "+Integer.valueOf(Integer.valueOf(userPage.getNumber())+1)); //当前页数

O resultado da consulta é:

Você também pode classificar a consulta de paginação, classificando em ordem decrescente de acordo com a chave primária

        PageRequest pageRequest = PageRequest.of(0, 4, Sort.by("id").descending()); 
        Page<User> orderPAge = userMapper.findAll(pageRequest); 
        System.out.println("Dados da consulta: " + orderPAge.getContent());//Dados de consulta 
        orderPAge.getContent().forEach(System.out::println);

Paginação para classificar vários campos no mesmo tipo

        PageRequest pageRequest1 = PageRequest.of(0, 4, Sort.Direction.DESC, "status","id"); 
        Page<User> orde = userMapper.findAll(pageRequest1); 
        System.out.println("Dados da consulta: " +orde.getContent());//Consulta de dados 
        orde.getContent().forEach(System.out::println);

Paginação para classificação diferente de vários campos De acordo com a ordem crescente de status, ordem decrescente de id

        PageRequest de = PageRequest.of(0, 4, Sort.by("status").ascending().and(Sort.by("id").descending())); 
        Page<User> ord = userMapper.findAll(of); 
        ord.getContent().forEach(System.out::println);

Veja os resultados SQL da saída da consulta:

3. Consulta de condição

Vejamos a consulta condicional usando JPA. No JPA, o JPA usa o método findBy para personalizar a consulta. Você também pode usar findAllBy. Não há diferença entre esses dois.Na verdade, finBy... é usado para consulta.

//Consulta de acordo com o nome da conta, coloca de volta os dados se houver informações e retorna null se não houver consulta, se você consultar vários dados, um erro será relatado 
        User user=userMapper.findByAccount("hibernateTest" ); 
//Dao camada

       Usuário findByAccount(String conta);

  Se você consultar vários itens, será relatado um erro javax.persistence.NonUniqueResultException: a consulta não retornou um resultado exclusivo: 4. Altere o parâmetro de recebimento para Listar para consultar vários itens de dados.

List<Usuário> findByAccount(String conta);

 FindBy também pode suportar várias palavras-chave para consulta:

E: equivalente à palavra-chave e no SQL, findByAccountAndPassword(String conta, String senha); 
E: equivalente à palavra-chave e no SQL, findByAccountAndPassword(String conta, String senha); 
Ou: equivalente a SQL na palavra-chave or, findByAccountOrName(String account, String name); 
Between: equivalente à palavra-chave between em SQL, findByIdBetween(int min, int max); 
LessThan: equivalente a "<" em SQL, findByIdLessThan(int id ); 
GreaterThan: equivalente a ">" em SQL , findByIdGreaterThan(int id); 
IsNull: equivalente a "é nulo" no SQL, findByNameIsNull(); 
IsNotNull: equivalente a "não é nulo" no SQL , findByNameIsNotNull(); NotNull: equivalente a IsNotNull; 
Like: equivalente a "like " no SQL, findByNameLike(String name); Dessa forma, você precisa somar %name% para passar o valor, pode usar Containing, esse método ficará nos dois lados da string Somar % em ambos, 
EndingWith , respectivamente?%, %?
NotLike: Equivalente a "não gosto" no SQL, findByNameNotLike(String name); %name% é necessário para passar o valor 
Equivalente a "!=" no SQL, findByUsernameNot(String user); 
OrderBy: Equivalente a " order by" no SQL, findByNameOrderByStatusAsc(String name); 
In: equivalente a "in" no SQL, findByIdIn(Collection userIdList), os parâmetros do método podem ser do tipo Coleção, array ou parâmetros de comprimento variável; NotIn : 
Equivalente a "não in" no SQL, findByNameNotIn(Collection userList), o parâmetro do método pode ser do tipo Collection, ou um array ou parâmetro de comprimento variável; aqui está uma introdução ao uso da consulta difusa 
:

List<User> userList2=userMapper.findByNameLike("%hibernateTest%");
userList2.forEach(System.out::println);
List<User> userList3=userMapper.findByNameContaining("hibernateTest");
userList3.forEach(System.out::println);//dao层
List<User> findByNameLike(String name);List<User> findByNameContaining(String name);

Após a conclusão da introdução das regras findBy acima, combinamos a paginação e a classificação acima para consultar os dados filtrados. Condição + paginação + uso da consulta de classificação:

Page<User> userPage = userMapper.findByNameLike("%hibernateJPa%", PageRequest.of(0, 2, Sort.by("id").descending()));
        System.out.println("总页数: "+userPage.getTotalPages()); //总页数
        System.out.println("总条数: "+userPage.getTotalElements()); //总条数
        System.out.println("查询的数据: "+userPage.getContent());//查询的数据
        System.out.println("显示条数: "+userPage.getSize()); //显示条数
        System.out.println("当前页数: "+Integer.valueOf(Integer.valueOf(userPage.getNumber())+1)); //当前页数//dao层
Page<User> findByNameLike(String name, Pageable pageable);

   resultado da pesquisa:

Concluímos a introdução de consulta, classificação e paginação usando JPA. Existem consultas condicionais SQL complexas por trás do JPA, que precisam herdar a interface JpaSpecificationExecutor. Não existem muitos métodos de interface JpaSpecificationExecutor, mas eles são fáceis de usar. É recomendável que você tenha tempo para aprendê-los.