J'utilise JPARespository
pour toutes mes opérations CRUD. Récemment, je voulais implémenter le tri, alors j'ai continué avec Pagable
.
Le problème est que je veux que les méthodes du référentiel retournent des objets List
, je les utilise dans ma couche de service.
Comment puis-je y parvenir, existe-t-il un moyen de convertir ces objets Page
en List
?
Si vous utilisez la pagination dans une méthode de référentiel jpa, spring renvoie toujours une page et non une liste. Je vous suggère d'avoir une méthode de service qui appelle la méthode du référentiel et extrait le contenu du résultat de la page dans une liste.
Donc, si votre méthode de dépôt est donc:
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface RecordRepository extends JpaRepository<Record, Integer>{
Page<Record> findAll(Pageable pageable);
}
alors vous pouvez avoir une classe de service qui a une méthode qui appelle la méthode du référentiel
@Service
public class RecordService{
@Autowired
RecordRepository recordRepository;
public List<Record> findAll(PageRequest pageRequest){
Page<Record> recordsPage = recordRepository.findAll(pageRequest);
return recordsPage.getContent();
}
}
donc dans votre classe appelante au lieu d'appeler directement le référentiel, vous pouvez simplement utiliser le service. Donc:
public class MyRecordImpl{
@Autowired
RecordService recordService;
public void doSomething(){
int page = 0; int pageSize = 5;
List<Record> recordList = recordService.findAll(new PageRequest(page, pageSize, new Sort(Sort.Direction.DESC, "recordId")));
//do other implementations here
}
}
La façon la plus simple de récupérer tous vos résultats à la fois est d'utiliser Pageable.unpaged () , comme ci-dessous:
Page<Employee> allEmployees = employeeRepository.findAll(Pageable.unpaged());
allEmployees.getContent();
Mais si vous craignez de récupérer trop de données à la fois et préférez plutôt effectuer la récupération en petits morceaux, vous pouvez utiliser un service ou une méthode de référentiel similaire à ci-dessous:
private List<Employee> findAll() {
List<Employee> allEmployees = new ArrayList<>();
// First page of employees -- 5000 results per page
PageRequest pageRequest = PageRequest.of(0, 5000);
Page<Employee> employeePage = employeeRepository.findAll(pageRequest);
allEmployees.addAll(employeePage.getContent());
// All the remaining employees
while (employeePage.hasNext()) {
Page<Employee> nextPageOfEmployees = employeeRepository.findAll(employeePage.nextPageable());
allEmployees.addAll(nextPageOfEmployees.getContent());
// update the page reference to the current page
employeePage = nextPageOfEmployees;
}
return allEmployees;
}
Vérifiez ceci page pour les avantages et les inconvénients de la récupération des données par blocs.
Je sais que je suis en retard, mais c'est la première option qui apparaît dans Google et les gens peuvent avoir besoin de plus de réponses lorsque toutes les informations de toutes les pages doivent être converties en liste ...
Une aproximation peut être:
xRepository.findAll(new PageRequest(0, Integer.MAX_VALUE)).getContent();
Le problème ici est que le printemps définit la taille maximale à 1000, vous obtiendrez donc une liste de 1000 éléments maximum.
Une autre façon de le faire peut être la recherche multiple avec différents index de page, puis l'ajout des résultats dans une liste avec getContent ():
Page<T> pageData = xRepository.findAll(new PageRequest(0, 20));
List<T> finalList = pageData.getContent();
while(!pageData.isLast()){
pageData = xRepository.findAll(pageData.nextPageable());
List<T> listData = pageData.getContent();
//append listData into finalList
}