Spring Data JPA. Wie man nur eine Liste von IDs von findAll () - Methode

Ich habe ein sehr kompliziertes Modell. Entity hat eine Menge Beziehungen und so weiter.

Ich versuche es mal mit Spring Data JPA aus und ich bereitete ein repository.

aber wenn ich auf eine metod findAll() mit Angabe der für das Objekt einen haben ein performance-Problem, weil Objekte sind sehr groß. Ich weiß, dass, weil, wenn ich eine Methode aufzurufen, wie diese:

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

Ich habe keine Probleme mit der performance.

Aber wenn ich rufe

List<Customer> findAll();

Hatte ich ein großes problem mit der Leistung.

Das problem ist, dass ich machen zu müssen findAll-Methode, mit der Spezifikationen für Kunden, dass ist der Grund, warum ich nicht verwenden Methode gibt eine Liste von arrays von Objekten.

Wie Sie schreiben, eine Methode zu finden, die alle Kunden-Spezifikationen für Customer-Entität, sondern gibt nur ein IDs.

wie diese:

List<Long> findAll(Specification<Customer> spec);

Ich nicht verwenden können, in diesem Fall die Paginierung.

Bitte helfen.

InformationsquelleAutor der Frage user6778654 | 2015-05-19

16

Warum nicht mit der @Query annotation?

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

Der einzige Nachteil, den ich sehe, ist, wenn das Attribut id verpasst, aber da dies ist eine sehr häufige Namen und kaum zu ändern (id = Primärschlüssel), diese sollte in Ordnung sein.

InformationsquelleAutor der Antwort eav

Ist dies nun, unterstützt durch die Feder von Daten mit Projektionen:

interface SparseCustomer {  

  String getId(); 

  String getName();  
}

Als in Ihrem Customer repository

List<SparseCustomer> findAll(Specification<Customer> spec);

InformationsquelleAutor der Antwort Ondrej Bozek

Habe ich das problem gelöst.

(Als Ergebnis haben wir eine spärliche Kunde-Objekt nur mit id und name)

Definieren Sie Ihre eigenen repository:

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

Und eine Implementierung (denken Sie daran, über suffix - Impl als Standard)

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

InformationsquelleAutor der Antwort user6778654

Leider Projektionen funktioniert nicht mit Spezifikationen. JpaSpecificationExecutor Gegenzug nur eine Liste eingegeben mit den aggregierten root verwaltet das repository ( List<T> findAll(Specification<T> var1); )

Einer tatsächlichen Lösung ist die Verwendung Tupel. Beispiel :

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

wo Projections ist eine funktionale Schnittstelle für root-Projektion.

@FunctionalInterface
public interface Projections<D> {

    List<Selection<?>> project(Root<D> root);

}

SingleTupleMapper und TupleMapper werden verwendet, um die anzeigen der TupleQuery Ergebnis an das Objekt, das Sie wollen, um zurückzukehren.

@FunctionalInterface
public interface SingleTupleMapper<D> {

    D map(Tuple tuple);
}

@FunctionalInterface
public interface TupleMapper<D> {

    List<D> map(List<Tuple> tuples);

}

Anwendungsbeispiel :

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

Ich hoffe, es hilft.

InformationsquelleAutor der Antwort Radouane ROUFID

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.