web-dev-qa-db-ja.com

Spring Data JPA。 findAll（）メソッドからIDのリストのみを取得する方法

私は非常に複雑なモデルを持っています。エンティティには多くの関係などがあります。

Spring Data JPAを使用しようとし、リポジトリを準備しました。

しかし、オブジェクトの仕様を指定してfindAll（）メソッドを呼び出すと、オブジェクトが非常に大きいため、パフォーマンスの問題が発生します。私はこのようなメソッドを呼び出すと、それを知っています：

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

パフォーマンスに問題はありませんでした。

しかし、私が呼び出すとき

List<Customer> findAll();

パフォーマンスに大きな問題がありました。

問題は、Customersの仕様でfindAllメソッドを呼び出す必要があることです。そのため、オブジェクトの配列のリストを返すメソッドを使用できません。

Customerエンティティの仕様を持つが、IDのみを返すすべての顧客を検索するメソッドを記述する方法。

このような：

List<Long> findAll(Specification<Customer> spec);
  • この場合、ページネーションは使用できません。

助けてください。

springspring-data-jpaspecificationscriteria-api
24
user6778654

問題を解決しました。

（結果として、IDと名前のみを持つ疎なCustomerオブジェクトが作成されます）

独自のリポジトリを定義します。

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

そして実装（サフィックスについて覚えておいてください-デフォルトとしてImpl）

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

_@Query_注釈を使用しないのはなぜですか？

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

私が見る唯一の欠点は、属性idが変更されるときですが、これは非常に一般的な名前であり、変更される可能性が低いため（id =主キー）、これは大丈夫です。

28
eav

これは、Spring Dataで Projections を使用してサポートされるようになりました。

interface SparseCustomer {  

  String getId(); 

  String getName();  
}

Customerリポジトリ内より

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

編集：
Radouane ROUFIDが指摘したように、Projections with Specificationsは現在、 bug のため機能しません。

ただし、 specification-with-projection libraryを使用して、このSpring Data Jpaの欠陥を回避することができます。

18
Ondrej Bozek

残念なことに Projections は specifications では機能しません。 JpaSpecificationExecutorは、リポジトリによって管理される集約ルートで入力されたリストのみを返します（List<T> findAll(Specification<T> var1);）

実際の回避策は、Tupleを使用することです。例：

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

ここで、Projectionsはルート投影の機能インターフェイスです。

@FunctionalInterface
public interface Projections<D> {

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

}

SingleTupleMapperとTupleMapperを使用して、TupleQueryの結果を返すオブジェクトにマッピングします。

@FunctionalInterface
public interface SingleTupleMapper<D> {

    D map(Tuple tuple);
}

@FunctionalInterface
public interface TupleMapper<D> {

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

}

使用例：

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

役に立てば幸いです。

0
Radouane ROUFID