Comment mettre en œuvre la pagination au printemps de démarrage avec hibernate

Je voudrais envisager d'utiliser org.springframework.data.domain.Pageable directement dans votre contrôleur. Cet objet peut ensuite être transmis à votre JPA couche où il va gérer le nombre de résultats renvoyés et de la taille.

La grande chose au sujet de l'utilisation de Pageable est qu'il renvoie une Page objet qui peut être utilisé sur le front-end pour la forme précédente/page suivante logique.

Par défaut de cette classe utilise des paramètres d'url 'page " et " taille'; donc page=0&size=10 sera de retour les 10 premiers éléments.

Donc dans votre cas, le code pourrait ressembler à quelque chose comme:

@ResponseBody
@RequestMapping("/top/pages/")
public List<Post> getAllPosts(@PageableDefault(value=10, page=0) Pageable pageable) throws ServletException {
    Page page = postDao.findAll(pageable);
    return page.getContent();
}

Avis de l'annotation @PageableDefault est juste pour configurer les paramètres par défaut & il n'est pas nécessaire.

Dans le front-end de la page suivante peut être <a href="/top/pages?page=1">Next</a>; il sera de retour une liste de Postes de 11 à 20.

OriginalL'auteur Ithar

Comment mettre en Œuvre Dynamique de la Pagination à l'Aide d'une Requête Native

Ici, vous pouvez trouver le référentiel et les couches de service et votre objet de transfert de données (DTO), qui sera utilisée pour la cartographie de notre résultat et de l'envoyer à la couche contrôleur.

public interface CustomSomethingRepository {
    List<Something> findPagedResultBySomethingElseId(long somethingElseId, int offset, int limit);
}

public class SomethingRepositoryImpl implements CustomSomethingRepository {
    @Autowired
    private EntityManager em;

    @SuppressWarnings("unchecked")
    @Override
    public List<Something> findPagedResultBySomethingElseId(long somethingElseId, int offset, int limit) {
        String query = "select s.* from Something s "
                + "join somethingelse selse on selse.id = s.fk_somethingelse "
                + "where selse.id = :somethingElseId "
                + "order by selse.date";
        Query nativeQuery = em.createNativeQuery(query);
        nativeQuery.setParameter("somethingElseId", somethingElseId);
        //Paginering
        nativeQuery.setFirstResult(offset);
        nativeQuery.setMaxResults(limit);
        final List<Object[]> resultList = nativeQuery.getResultList();
        List<Something> somethingList = Lists.newArrayList();
        resultList.forEach(object -> somethingList.add(//map obj to something));
        return somethingList;
    }
}

Hibernate traduit votre requête comme suit:

SELECT inner_query.*, ROW_NUMBER() OVER (ORDER BY CURRENT_TIMESTAMP) as __hibernate_row_nr__ FROM ( select TOP(?) t as page0_ from Something s join s.somethingelse as selse order by selse.date ) inner_query ) SELECT page0_ FROM query WHERE __hibernate_row_nr__ >= ? AND __hibernate_row_nr__ < ?
@Service
public class SomethingService {
private SomethingRepository somethingRepository;
@Autowired
public SomethingService(SomethingRepository somethingRepository){
this.somethingRepository = somethingRepository;
}
@Transactional(readOnly=true)
public PageDto getSomething(long somethingElseId, int page, int size){
List<Something> somethings = somethingRepository.findBySomethingElseId(somethingElseId, offset, limit);
return new PagedResult<>(somethings
.stream()
.map(SomethingDto::createDto)
.sorted(comparing(SomethingDto::getDatum))
.collect(toList()), somethings.getTotalElements(), somethings.getTotalPages();
}
}
@Controller
//....
public class PagedResult<T> {
public static final long DEFAULT_OFFSET = 0;
public static final int DEFAULT_MAX_NO_OF_ROWS = 100;
private int offset;
private int limit;
private long totalElements;
private List<T> elements;
public PagedResult(List<T> elements, long totalElements, int offset, int limit) {
this.elements = elements;
this.totalElements = totalElements;
this.offset = offset;
this.limit = limit;
}
public boolean hasMore() {
return totalElements > offset + limit;
}
public boolean hasPrevious() {
return offset > 0 && totalElements > 0;
}
public long getTotalElements() {
return totalElements;
}
public int  getOffset() {
return offset;
}
public int getLimit() {
return limit;
}
public List<T> getElements() {
return elements;
}
}

Avantages et les Inconvénients
Pros: réduire le nombre de requêtes SQL générés, par rapport à l'utilisation de Données du Printemps. Ces requêtes complexes ne peuvent pas être écrites au Printemps de Données, et nous devons préciser notre requête comme un natif, qui peut encore être transférées en utilisant cette méthodologie.

Contre: "L'objet" tableau doit correspondre à un objet Java. Elle est douloureuse et difficile à maintenir.

Comment mettre en Œuvre OffsetLimit la Pagination Avec le Printemps de Données
Autant que je sache, il n'y a pas de "out-of-the-box" soutien pour ce que vous avez besoin à défaut Printemps, référentiels de Données. Mais vous pouvez en créer un personnalisé de mise en œuvre de Paginable des objets qui vont prendre limit/offset paramètres.

Faire un paginable objet et le passer à PaginationAndSortingRepository:

public class OffsetLimitRequest implements Pageable {
private int limit;
private int offset;
public OffsetLimitRequest(int offset, int limit){
this.limit = limit;
this.offset = offset;
}
@Override
public int getPageNumber() {
return 0;
}
@Override
public int getPageSize() {
return limit;
}
@Override
public int getOffset() {
return offset;
}
....
}

Il n'y a pas besoin de modifier le dépôt de la couche. Le seul changement que vous auriez besoin de faire est de la couche de service, comme suit:

@Service
public class SomethingService {
private SomethingRepository somethingRepository;
@Autowired
public SomethingService(SomethingRepository somethingRepository){
this.somethingRepository = somethingRepository;
}
@Transactional(readOnly=true)
public PageDto getSomething(long somethingElseId, int page, int size){
Page<Something> somethings = somethingRepository.findBySomethingElseId(somethingElseId, new OffsetLimitRequest(offset, limit));
return new PageDto(somethings.getContent()
.stream()
.map(SomethingDto::createDto)
.sorted(comparing(SomethingDto::getDatum))
.collect(toList()), somethings.getTotalElements(), somethings.getTotalPages();
}
}

Notez que vous n'avez pas besoin de mapper le résultat manuellement, et il faudra une bonne quantité de temps de développement.

OriginalL'auteur Manas Ranjan Mahapatra