Spring Data JPA. Comment obtenir uniquement une liste d'ID de la méthode findAll ()

J'ai un très compliquée modèle. L'entité a beaucoup de relations et ainsi de suite.

J'essaie d'utiliser Spring Data JPA, et j'ai préparé un référentiel.

mais quand j'invoque un metod findAll() avec la spécification de l'objet a qui ont un problème de performances, car les objets sont très grands. Je le sais parce que quand j'invoque une méthode comme ceci:

@Query(value = "select id, name from Customer ")
List<Object[]> myFindCustomerIds();

Je n'ai pas de problèmes avec la performance.

Mais quand j'invoque

List<Customer> findAll();

J'ai eu un gros problème avec la performance.

Le problème est que j'ai besoin d'invoquer la méthode findAll avec les Spécifications du Client, c'est pourquoi je ne peux pas utiliser la méthode qui renvoie une liste de tableaux d'objets.

Comment écrire une méthode à la recherche de tous les clients avec les spécifications du Client entité, mais qui ne renvoie qu'un IDs.

comme ceci:

List<Long> findAll(Specification<Customer> spec);
  • Je ne peux pas utiliser dans ce cas la pagination.

S'il vous plaît aider.

source d'informationauteur user6778654

  1. 14

    Pourquoi pas à l'aide de la @Query annotation?

    @Query("select p.id from #{#entityName} p")
    List<Long> getAllIds();

    Le seul inconvénient que je vois est que lorsque l'attribut id changements, mais puisque c'est un nom commun et peu susceptible de changer (id = clé primaire), cela devrait être ok.

  2. 13

    C'est maintenant pris en charge par le Printemps des Données à l'aide Les Projections:

    interface SparseCustomer {  

  String getId(); 

  String getName();  
}

    Que dans votre Customer référentiel 

    List<SparseCustomer> findAll(Specification<Customer> spec);
  3. 7

    J'ai résolu le problème.

    (Comme un résultat, nous aurons une éparses Client de l'objet uniquement avec l'id et le nom)

    Définir leur propre référentiel:

    public interface SparseCustomerRepository {
    List<Customer> findAllWithNameOnly(Specification<Customer> spec);
}

    Et de mise en œuvre (rappelez-vous sur le suffixe - Impl par défaut)

    @Service
public class SparseCustomerRepositoryImpl implements SparseCustomerRepository {
private final EntityManager entityManager;
@Autowired
public SparseCustomerRepositoryImpl(EntityManager entityManager) {
this.entityManager = entityManager;
}
@Override
public List<Customer> findAllWithNameOnly(Specification<Customer> spec) {
CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<Tuple> tupleQuery = criteriaBuilder.createTupleQuery();
Root<Customer> root = tupleQuery.from(Customer.class);
tupleQuery.multiselect(getSelection(root, Customer_.id),
getSelection(root, Customer_.name));
if (spec != null) {
tupleQuery.where(spec.toPredicate(root, tupleQuery, criteriaBuilder));
}
List<Tuple> CustomerNames = entityManager.createQuery(tupleQuery).getResultList();
return createEntitiesFromTuples(CustomerNames);
}
private Selection<?> getSelection(Root<Customer> root,
SingularAttribute<Customer, ?> attribute) {
return root.get(attribute).alias(attribute.getName());
}
private List<Customer> createEntitiesFromTuples(List<Tuple> CustomerNames) {
List<Customer> customers = new ArrayList<>();
for (Tuple customer : CustomerNames) {
Customer c = new Customer();
c.setId(customer.get(Customer_.id.getName(), Long.class));
c.setName(customer.get(Customer_.name.getName(), String.class));
c.add(customer);
}
return customers;
}
}
  4. 0

    Malheureusement Les Projections ne fonctionne pas avec spécifications. JpaSpecificationExecutor retour seulement une Liste de taper avec le agrégées racine géré par le référentiel ( List<T> findAll(Specification<T> var1); )

    Une réelle solution de contournement consiste à utiliser un Tuple. Exemple : 

        @Override
public <D> D findOne(Projections<DOMAIN> projections, Specification<DOMAIN> specification, SingleTupleMapper<D> tupleMapper) {
Tuple tuple = this.getTupleQuery(projections, specification).getSingleResult();
return tupleMapper.map(tuple);
}
@Override
public <D extends Dto<ID>> List<D> findAll(Projections<DOMAIN> projections, Specification<DOMAIN> specification, TupleMapper<D> tupleMapper) {
List<Tuple> tupleList = this.getTupleQuery(projections, specification).getResultList();
return tupleMapper.map(tupleList);
}
private TypedQuery<Tuple> getTupleQuery(Projections<DOMAIN> projections, Specification<DOMAIN> specification) {
CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<Tuple> query = cb.createTupleQuery();
Root<DOMAIN> root = query.from((Class<DOMAIN>) domainClass);
query.multiselect(projections.project(root));
query.where(specification.toPredicate(root, query, cb));
return entityManager.createQuery(query);
}

    où Projections est une interface fonctionnelle pour l'utilisateur root de projection. 

    @FunctionalInterface
public interface Projections<D> {
List<Selection<?>> project(Root<D> root);
}

    SingleTupleMapper et TupleMapper sont utilisés pour mapper le TupleQuery résultat à l'Objet que vous souhaitez retourner.

    @FunctionalInterface
public interface SingleTupleMapper<D> {
D map(Tuple tuple);
}
@FunctionalInterface
public interface TupleMapper<D> {
List<D> map(List<Tuple> tuples);
}

    Exemple d'utilisation :

            Projections<User> userProjections = (root) -> Arrays.asList(
root.get(User_.uid).alias(User_.uid.getName()),
root.get(User_.active).alias(User_.active.getName()),
root.get(User_.userProvider).alias(User_.userProvider.getName()),
root.join(User_.profile).get(Profile_.firstName).alias(Profile_.firstName.getName()),
root.join(User_.profile).get(Profile_.lastName).alias(Profile_.lastName.getName()),
root.join(User_.profile).get(Profile_.picture).alias(Profile_.picture.getName()),
root.join(User_.profile).get(Profile_.gender).alias(Profile_.gender.getName())
);
Specification<User> userSpecification = UserSpecifications.withUid(userUid);
SingleTupleMapper<BasicUserDto> singleMapper = tuple -> {
BasicUserDto basicUserDto = new BasicUserDto();
basicUserDto.setUid(tuple.get(User_.uid.getName(), String.class));
basicUserDto.setActive(tuple.get(User_.active.getName(), Boolean.class));
basicUserDto.setUserProvider(tuple.get(User_.userProvider.getName(), UserProvider.class));
basicUserDto.setFirstName(tuple.get(Profile_.firstName.getName(), String.class));
basicUserDto.setLastName(tuple.get(Profile_.lastName.getName(), String.class));
basicUserDto.setPicture(tuple.get(Profile_.picture.getName(), String.class));
basicUserDto.setGender(tuple.get(Profile_.gender.getName(), Gender.class));
return basicUserDto;
};
BasicUserDto basicUser = findOne(userProjections, userSpecification, singleMapper);

    J'espère que cela aide.