La Pagination dans Spring Data JPA (limit et offset)

Je veux que l'utilisateur puisse spécifier la limite de la taille de la valeur retournée) et l'offset (le premier enregistrement retourné /index retourné dans ma méthode de requête.

Voici mes classes, sans pagination capacités.
Mon entité:

@Entity
public Employee {
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private int id;

    @Column(name="NAME")
    private String name;

    //getters and setters
}

Mon référentiel:

public interface EmployeeRepository extends JpaRepository<Employee, Integer> {

    @Query("SELECT e FROM Employee e WHERE e.name LIKE :name ORDER BY e.id")
    public List<Employee> findByName(@Param("name") String name);
}

Mon interface de service:

public interface EmployeeService {

    public List<Employee> findByName(String name);
}

Mon service de mise en œuvre:

public class EmployeeServiceImpl {

    @Resource
    EmployeeRepository repository;

    @Override
    public List<Employee> findByName(String name) {
        return repository.findByName(name);
    }
}

Maintenant ici est une tentative de ma part lors de la fourniture de la pagination des capacités de charge offset et la limite.
Ma classe d'entité reste le même.

Mon "nouveau" référentiel prend en paginable paramètre:

public interface EmployeeRepository extends JpaRepository<Employee, Integer> {

    @Query("SELECT e FROM Employee e WHERE e.name LIKE :name ORDER BY e.id")
    public List<Employee> findByName(@Param("name") String name, Pageable pageable);
}

Ma "nouvelle" interface de service prend deux paramètres supplémentaires:

public interface EmployeeService {

    public List<Employee> findByName(String name, int offset, int limit);
}

Mon "nouveau" service de la mise en œuvre:

public class EmployeeServiceImpl {

    @Resource
    EmployeeRepository repository;

    @Override
    public List<Employee> findByName(String name, int offset, int limit) {
        return repository.findByName(name, new PageRequest(offset, limit);
    }
}

Ce n'est cependant pas ce que je veux. PageRequest spécifie la page et la taille (numéro de page et la taille de la page). Maintenant, en spécifiant la taille est exactement ce que je veux, cependant, je ne veux pas de spécifier la page de départ #, je veux que l'utilisateur puisse spécifier l'enregistrement de début /d'index. Je veux quelque chose de semblable à

public List<Employee> findByName(String name, int offset, int limit) {
    TypedQuery<Employee> query = entityManager.createQuery("SELECT e FROM Employee e WHERE e.name LIKE :name ORDER BY e.id", Employee.class);
    query.setFirstResult(offset);
    query.setMaxResults(limit);
    return query.getResultList();
}

Spécifiquement la setFirstResult() et setMaxResult() méthodes. Mais je ne peux pas utiliser cette méthode parce que je veux utiliser l'Employé référentiel de l'interface. (Ou est-il réellement meilleur pour définir des requêtes par le biais de l'entityManager?) De toute façon, il est un moyen pour spécifier le décalage sans l'aide de l'entityManager? Merci à l'avance!

OriginalL'auteur chinesewhiteboi | 2014-07-29

Code ci-dessous devrait le faire. J'utilise dans mon propre projet et testé pour la plupart des cas.

utilisation:

   Pageable pageable = new OffsetBasedPageRequest(offset, limit);
   return this.dataServices.findAllInclusive(pageable);

et le code source:

import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.springframework.data.domain.AbstractPageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import java.io.Serializable;
/**
* Created by Ergin
**/
public class OffsetBasedPageRequest implements Pageable, Serializable {
private static final long serialVersionUID = -25822477129613575L;
private int limit;
private int offset;
private final Sort sort;
/**
* Creates a new {@link OffsetBasedPageRequest} with sort parameters applied.
*
* @param offset zero-based offset.
* @param limit  the size of the elements to be returned.
* @param sort   can be {@literal null}.
*/
public OffsetBasedPageRequest(int offset, int limit, Sort sort) {
if (offset < 0) {
throw new IllegalArgumentException("Offset index must not be less than zero!");
}
if (limit < 1) {
throw new IllegalArgumentException("Limit must not be less than one!");
}
this.limit = limit;
this.offset = offset;
this.sort = sort;
}
/**
* Creates a new {@link OffsetBasedPageRequest} with sort parameters applied.
*
* @param offset     zero-based offset.
* @param limit      the size of the elements to be returned.
* @param direction  the direction of the {@link Sort} to be specified, can be {@literal null}.
* @param properties the properties to sort by, must not be {@literal null} or empty.
*/
public OffsetBasedPageRequest(int offset, int limit, Sort.Direction direction, String... properties) {
this(offset, limit, new Sort(direction, properties));
}
/**
* Creates a new {@link OffsetBasedPageRequest} with sort parameters applied.
*
* @param offset zero-based offset.
* @param limit  the size of the elements to be returned.
*/
public OffsetBasedPageRequest(int offset, int limit) {
this(offset, limit, new Sort(Sort.Direction.ASC,"id"));
}
@Override
public int getPageNumber() {
return offset / limit;
}
@Override
public int getPageSize() {
return limit;
}
@Override
public int getOffset() {
return offset;
}
@Override
public Sort getSort() {
return sort;
}
@Override
public Pageable next() {
return new OffsetBasedPageRequest(getOffset() + getPageSize(), getPageSize(), getSort());
}
public OffsetBasedPageRequest previous() {
return hasPrevious() ? new OffsetBasedPageRequest(getOffset() - getPageSize(), getPageSize(), getSort()) : this;
}
@Override
public Pageable previousOrFirst() {
return hasPrevious() ? previous() : first();
}
@Override
public Pageable first() {
return new OffsetBasedPageRequest(0, getPageSize(), getSort());
}
@Override
public boolean hasPrevious() {
return offset > limit;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof OffsetBasedPageRequest)) return false;
OffsetBasedPageRequest that = (OffsetBasedPageRequest) o;
return new EqualsBuilder()
.append(limit, that.limit)
.append(offset, that.offset)
.append(sort, that.sort)
.isEquals();
}
@Override
public int hashCode() {
return new HashCodeBuilder(17, 37)
.append(limit)
.append(offset)
.append(sort)
.toHashCode();
}
@Override
public String toString() {
return new ToStringBuilder(this)
.append("limit", limit)
.append("offset", offset)
.append("sort", sort)
.toString();
}
}

C'est sympa, juste ce dont j'ai besoin, mais qu'est ce qu'un EqualsBuilder?
c'est Apache bibliothèque commune pour la comparaison de l'égalité des champs. Vous pouvez simplement comparer chaque champs un par un. Consultez cet article pour plus de détails mkyong.com/java/java-how-to-overrides-equals-and-hashcode
Pour hasPrevious(), ne devrait-elle pas être return offset >= limit; ?
Ce serait une bonne idée d'inclure ce ou quelque chose de similaire directement dans le cadre...

OriginalL'auteur codingmonkey

Vous pouvez le faire en créant votre propre Paginable.

Essayer cet échantillon de base. Fonctionne très bien pour moi:

public class ChunkRequest implements Pageable {
private int limit = 0;
private int offset = 0;
public ChunkRequest(int skip, int offset) {
if (skip < 0)
throw new IllegalArgumentException("Skip must not be less than zero!");
if (offset < 0)
throw new IllegalArgumentException("Offset must not be less than zero!");
this.limit = offset;
this.offset = skip;
}
@Override
public int getPageNumber() {
return 0;
}
@Override
public int getPageSize() {
return limit;
}
@Override
public int getOffset() {
return offset;
}
@Override
public Sort getSort() {
return null;
}
@Override
public Pageable next() {
return null;
}
@Override
public Pageable previousOrFirst() {
return this;
}
@Override
public Pageable first() {
return this;
}
@Override
public boolean hasPrevious() {
return false;
}
}

OriginalL'auteur Tobias Michelchen

5

Peut-être que la réponse est à peu de retard, mais j'ai pensé à la même chose. Calculer le courant de page basée sur le décalage et la limite. Eh bien, ce n'est pas exactement la même parce qu'il "suppose" que l'offset est un multiple de la limite, mais peut-être que votre application est adapté pour cela.
```
@Override
public List<Employee> findByName(String name, int offset, int limit) {
//limit != 0 ;)
int page = offset / limit;
return repository.findByName(name, new PageRequest(page, limit);
}
```
Je vous suggère un changement de l'architecture. Changement de votre contrôleur ou tout ce que les appels au service d'abord de vous donner la page et de limiter si possible.

Cela ne fonctionne que sous des conditions contrôlées. Si le décalage est inférieur à une limite, il sera buggé parce que la page va s'arrondir de façon incontrôlable. Offset = 9, Limit = 100 par exemple, sera toujours retourner les 9 premières lignes.

OriginalL'auteur Sebastian
4

Vous ne pouvez pas faire cela avec spring data jpa. Si le décalage est très petite, vous pouvez juste enlever le haut X consolidés à partir de la requête après la récupération.

Sinon, vous pouvez définir la taille de la page à l'offset et de commencer à la page+1.

J'aime votre idée de définir la taille de la page à l'offset, mais le seul inconvénient serait que je ne pouvais pas le format de page (limite) des résultats. Merci pour les commentaires!

OriginalL'auteur membersound

Ici, vous allez:

public interface EmployeeRepository extends JpaRepository<Employee, Integer> {
@Query(value="SELECT e FROM Employee e WHERE e.name LIKE ?1 ORDER BY e.id offset ?2 limit ?3", nativeQuery = true)
public List<Employee> findByNameAndMore(String name, int offset, int limit);
}

Lecteurs, sachez que cette solution utilise un natif de la requête SQL, pas un JPQL.

OriginalL'auteur supercobra

Vous devez vous connecter pour publier un commentaire.