Wie die Umsetzung der Paginierung in den Frühling starten mit hibernate

Ich würde prüfen, mit org.springframework.data.domain.Pageable direkt in den controller. Dieses Objekt kann übergeben werden, um Ihre JPA-layer, wo es sich um die Anzahl der zurückgegebenen Ergebnisse und die Größe.

Die große Sache über die Verwendung von Pageable ist, dass es gibt eine Page Objekt, die verwendet werden auf dem front-end-Formular vorherigen/nächsten Seite der Logik.

Standardmäßig wird diese Klasse verwendet url-Parameter "Seite " und " Größe'; folglich page=0&size=10 wird die Rückkehr der ersten 10 Elemente.

Also in deinem Fall der code könnte ungefähr so Aussehen:

@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();
}

Beachten Sie die Anmerkung @PageableDefault ist nur zum einrichten der Standardwerte & es ist nicht erforderlich.

In der front-end der nächsten Seite nennen kann <a href="/top/pages?page=1">Next</a>; dieser gibt eine Liste der Beiträge von 11 bis 20.

Wie Implementieren Sie eine Dynamische Paginierung Mit einer Nativen Query

Hier finden Sie die repository-und Dienst Schichten und Ihre Daten transfer object (DTO), die für die Zuordnung verwendet unser Ergebnis und senden Sie es an die controller-Schicht.

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 übersetzt Ihre Abfrage wie folgt:

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;
    }
}

Vor-und Nachteile
Profis: Weniger SQL-Abfragen generiert werden, verglichen mit Spring-Data. Diese komplexen Abfragen kann nicht geschrieben werden im Frühjahr, Daten, und wir haben zu geben Sie die Abfrage als einheimischer, der noch ausgelagert werden, die durch die Nutzung dieser Methodik.

Nachteile: Das "Objekt" array abbilden muss, um ein Java-Objekt. Es ist schmerzhaft und schwer zu pflegen.

Wie die Umsetzung OffsetLimit Paginierung Mit Spring Data
Soweit ich weiß, gibt es keine "out-of-the-box" Unterstützung für das, was Sie benötigen, in der Standard-Spring-Data repositories. Aber Sie können erstellen Sie eine benutzerdefinierte Implementierung von Navigierbaren Objekte, die dauern wird-Grenze/offset-Parameter.

Machen ein pageable-Objekt und übergeben es an 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;
    }
    ....
}

Es bedeutet, es gibt keine Notwendigkeit, ändern Sie die repository-Schicht. Die einzige änderung, die Sie benötigen würde, ist zu machen, ist die service-Schicht, wie folgt:

@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();
    }
}

Beachten Sie, dass Sie nicht brauchen, um Karte das Ergebnis manuell, und es wird sich eine gute Menge an Zeit von der Entwicklung.