QueryDSL에서 사용되는 문법을 별도의 유틸 클래스에 저장하는건 어떨까요?

[kmw2378]

QueryDSL을 사용하다보면 eq(), between(), like() 관련 코드 중복이 발생합니다. 도메인 Repo마다 메서드 추출을 해서 관리하면 재사용성이 떨어진다 생각합니다.

아래와 같은 유틸 클래스를 도입하는건 어떨까요? 단순히 BooleanExpression을 반환하는 경우 외에 페이징, 슬라이스도 구현가능할 것 같아요!

public final class RepositoryUtils {
    private RepositoryUtils() {

    }

    public static <T> Slice<T> toSlice(final Pageable pageable, final List<T> items) {
        if (items.size() > pageable.getPageSize()) {
            items.remove(items.size() - 1);
            return new SliceImpl<>(items, pageable, true);
        }

        return new SliceImpl<>(items, pageable, false);
    }

    public static <T> BooleanExpression eqExpression(final SimpleExpression<T> simpleExpression, final T target) {
        if (target == null) {
            return null;
        }

        return simpleExpression.eq(target);
    }

    public static <T> BooleanExpression containsExpression(final StringPath stringPath, final String keyword) {
        if (!StringUtils.hasText(keyword)) {
            return null;
        }

        return stringPath.contains(keyword);
    }

    public static <T extends Number & Comparable<?>> BooleanExpression containsExpression(final NumberExpression<T> numberExpression,
                                                                                          final Integer min,
                                                                                          final Integer max) {
        if (min == null && max == null) {
            return null;
        }

        if (min == null) {
            return numberExpression.loe(max);
        }

        if (max ==  null) {
            return numberExpression.goe(min);
        }

        return numberExpression.between(min, max);
    }

    public static <T> BooleanExpression containsExpression(final SimpleExpression<T> simpleExpression, final List<T> items) {
        if (Collections.isEmpty(items)) {
            return null;
        }

        return simpleExpression.in(items);
    }
}

아래는 이를 적용한 예시입니다.

    @Override
    public Slice<SimpleProductDto> findWithSearchConditions(final String keyword,
                                                            final Integer minPrice,
                                                            final Integer maxPrice,
                                                            final List<Category> categories,
                                                            final Pageable pageable) {
        final JPAQuery<SimpleProductDto> jpaQuery = queryFactory.select(getSimpleProductDto())
                .from(product)
                .leftJoin(product.brand, brand)
                .where(
                        containsExpression(product.brand.category, categories),
                        containsExpression(product.name, keyword),
                        containsExpression(product.price, minPrice, maxPrice)
                )
                .offset(pageable.getOffset())
                .limit(pageable.getPageSize() + 1)
                .orderBy(getOrderSpecifiers(pageable));
        return toSlice(pageable, jpaQuery.fetch());
    }

[YeaChan05]

저도 이번에 정렬 유틸 클래스를 작성하면서 적당히 추상화를 잘 해서 만들어두면 용이할것이라고 생각했었습니다!
어떻게 만드냐에 따라 개발 속도에 많은 영향을 끼칠거같네요 ㅎㅎ
공부할겸 한번 유틸클래스 만들어 사용하는것도 좋다고 생각합니다!!