#05장 리포지터리의 조회기능(JPA 중심)

최범균 저「DDD START!, 2016」를 읽고 정리하였습니다.

이 장에서 다룰 내용

• 스펙

• JPA 스펙구현

• 정렬과 페이징

• 동적 인스턴스와 @Subselect

스펙

검색을 위한 스펙

• 애그리거트를 찾을 때 식별자를 이용하는 것 외에 여러 다양한 조건으로 애그리거트를 찾아야 할 때가 있다.

• 스펙을 사용해보자.

public interface Speficiation<T> {
    public boolean isSatisfiedBy(T agg);
}

• 구현 사례

// 특정 고객의 주문인 지 확인하는 스펙 
public class OrdererSpec implements Specification<Order> {
    private String ordererld;
    public OrdererSpec(String ordererld) {
        this.ordererld = ordererld;
    }
    public boolean isSatisfiedBy(Order agg) {
        return agg.getOrdererId().getMemberId().getld().equals(ordererld);
    }
}

리포지터리가 메모리에 모든 애그리거트를 보관하고 있다면 다음과 같이

public class MemoryOrderRepository implements OrderRepository {
    public List<Order> findAll(Specification spec) {
        List<Order> allOrders = findAll();
        return allOrders.stream().filter(order -> spec.isSatisfiedBy(order).collect(toList());
        // 자바 7 이전 코드
        List<Order> result = new ArrayList<>();
        for (Order order : allOrders) {
            if (spec.isSatisfiedBy(order)) {
                result.add(spec);
            }
        }
        return result;

    }
    //...
}
    

원하는 스펙을 생성해서 전달해 주기만하면 된다.

Specification<Order> ordererSpec = new OrdererSpec("madvirus");
List<Order> orders = orderRepository. findAll(ordererSpec);

스펙 조합

• 스펙의 장점 = 조합

  • AND, OR 이용

// AND 예시
// 여러 specs에 따라 걸러낸다.
public class AndSpec<T> implements Specification<T> {
    private List<Specification<T> specs;
    public AndSpecification(Specification<T> ... specs) {
        this.specs = Arrays.asList(specs);
    }
    public boolean isSatisfiedBy(T agg) {
        for (Specification<T> spec : specs) {
            if (!spec.isSatisfiedBy(agg)) return false;
        }
        return true;
    }   
}

전달 예제

Specification<Order> ordererSpec = new OrdererSpec("madvirus");
Specification<Order> orderDateSpec = new OrderDateSpec(fromDate, toDate);
AndSpec<T> spec = new AndSpec(ordererSpec, orderDateSpec);
List<Order> orders = orderRepository.findAll(spec);

JPA를 위한 스펙 구현

• 앞선 예제들은 모든 애그리거트를 조회한 다음에 스펙을 이용해서 걸러내는 방식을 사용했다. -> 성능 문제

• JPA를 위한 스펙은 CriteriaBuilder와 Predicate를 이용해서 검색 조건을 구현할 수 있다.

JPA 스펙 구현

Specification 인터페이스

package com.myshop.common.jpaspec;

import javax.persistence•criteria.CriteriaBuilder;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

public interface Specification<T> {
    Predicate toPredicate(Root<T> root, CriteriaBuilder cb);
}

스펙 구현 예시

// ordererId와 같은지 비교하는 Predicate를 생성해서 리턴
public class OrdererSpec implements Specification<Order> {
    private String ordererld;
    public OrdererSpec(String ordererld) {
        this.ordererld = ordererld;
    }
    @Override
    public Predicate toPredicate(Root<Order> root, CriteriaBuilder cb) {
        // JPA의 정적 메타 모델을 정의한 코드
        // 메타 모델 클래스는 이름 뒤에 _ 를 붙인 이름을 갖는다.
        return cb.equal(root.get(Order_.orderer)
                        .get(Orderer_.memberId).get(MemberId_.id),
                        ordererld);
    }
}

응용 서비스 코드 예시

Specification<Order> OrdererSpec = new OrdererSpec("madvirus");
List<Order> orders = orderRepository.findAll(ordererSpec);

별도 클래스에 스펙 생성 기능을 모을 경우

package com.myshop.order.domain;
import com.myshop.common.jpaspec.Specification;
import com.myshop.member.domain.MemberId_;
import java.util.Date;
// Order와 관련된 스펙 생성 기능을 모았다.
public class OrderSpecs {
    public static Specification<Order> orderer(String ordererld) {
        return (root, cb) -> cb.equal( root.get(Order_.orderer).get(Orderer_.memberld).get(MemberId_.id),
            ordererld);
    }
    public static Specification<Order> between(Date from, Date to) {
        return (root, cb) -> cb.between(root.get(Order_.orderDate)} from, to);
    }
}

간결하게 스펙을 생성

Specification<Order> betweenSpec = OrderSpecs.between(fromTime, toTime);

AND/OR 스펙 조합을 위한 구현

생성자로 전달받은 Speicification 목록을 Predicate 목록으로 바꾸고 CriteriaBuilder의 and()와 or()를 사 용해서 새로운 Predicate# 생성

// AND를위한 JPA 스펙 예시
package com.myshop.common.jpaspec;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.Arrays;
import java.util.List;

public class AndSpecification<T> implements Specification<T> {
    private List<Specification<T>> specs;

    public AndSpecification(Specification<T> ... specs) {
        this.specs = Arrays.asList(specs);
    }
    @Override
    public Predicate toPredicate(Root<T> root, CriteriaBuilder cb) {
        Predicate[] predicates = specs.stream()
            .map(spec -> spec.toPredicate(root, cb))
            .toArray(size -> new Predicate[size]);
        return cb.and(predicates);
    }
}
// ---------------------------------------------------
// OR를위한 JPA 스펙 예시
public class OrSpecification<T> implements Specification<T> {
    private List<Specification<T>> specs;
    public OrSpecification(Specification<T>... specs) {
        this.specs = Arrays.asList(specs);
    }
    @Override
    public Predicate toPredicate(Root<T> root, CriteriaBuilder cb){
        Predicate[] predicates = specs.stream()
            .map(spec -> spec.toPredicate(root, cb))
            .toArray(Predicate[]::new);
        return cb.or(predicates);
    }
}

쉬운 생성을 위한 팩토리 클래스

public class Specs {
    public static <T> Specification<T> and(Specification<T> ... specs) {
        return new AndSpecification<>(specs);
    }

    public static <T> Specification<T> or(Specification<T> ... specs) {
        return new OrSpecification<>(specs);
    }
}

조합해서 사용

Specification<Order> specs = Specs.and(
    OrderSpecs.orderer("madvirus"), OrderSpecs.between(fromTime, toTime)
);

스펙을 사용하는 JPA 리포지터리 구현

이제 남은 작업은 스펙을 사용하도록 리포지터리를 구현하는 것이다

// 리포지터리 인터페이스는 스펙을 사용하는 메서드를 제공해야 한다.
public interface OrderRepository {
    public List<Order> findAll(Specification<Order> spec);
    //...
}

스펙을 이용해서 검색을 수행하는 JPA 리포지터리 구현

@Repository
public class JpaOrderRepository implements OrderRepository {
    @PersistenceContext
    private EntityManager entityManager;
    //...
    @Override
    public List<Order> findAll(Specification<Order> spec) {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<Order> criteriaQuery = cb.createQuery(Order.class);
        // 검색 조건 대상이 되는 루트(=Order)를 생성 
        Root<Order> root = criteriaQuery.from(Order.class);
        //  스펙을 이용해 Predicate 생성
        Predicate predicate = spec.toPredicate(rootcb);
        // Predicate를 전달
        criteriaQuery.where(predicate);
        criteriaQuery.orderBy(cb.desc(root. get(Order_.number).get(OrderNo_.number)));
        TypedQuery<Order> query = entityManager.createQuery(criteriaQuery);
        return query.getResultList();
    }
}

정렬 구현

JPQL 사용시

TypedQuery<Order> query = entityManager.createQuery(
    "select o from Order o " +
    "where o.orderer.memberld.id = :ordererld " +
    "order by o.number.number desc")
    Order.class);

정렬 순서를 지정하는 가장 쉬운 방법은 다음과 같이 문자열을 사용하는 것

List〈Order> orders = orderRepository.findAll(someSpec"number.number descn);

문자열로 전달받은 정렬 값을 Order로 변환하는 코드 구현 예시

@Repository
public class 3paOrderRepository implements OrderRepository {
    @PersistenceContext
    private EntityManager entityManager;
    //...
    @Override
    public List<Order> findAll(Specification<Order> spec, String ... orders) {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<Order> criteriaQuery = cb. createQuery(Order. class);
        Root<Order> root - criteriaQuery.from(Order.class);
        Predicate predicate = spec.toPredicate(rootcb);
        criteriaQuery.where(predicate);
        if (orders.length > 0) {
            // JpaQueryUtils의 구현 코드는 아래 참고
            criteriaQuery.orderBy(JpaQueryUtils.toHpaOrders(root, cb, orders));
        }
        TypedQuery<Order> query = entityManager. createQuery(criteriaQuery);
        return query.getResultList();
    }
}

문자열을 Order로 변경해 주는 보조 클래스

public class JpaQueryUtils {
    public static <T> List<Order> toJpaOrders(
        Root<T> root, CriteriaBuilder cb, String ... orders) {
        if (orders - null || orders.length = 0) return Collections.enptyList();
        return Arrays.stream(orders)
            .map(orderStr -> to그paOrder^root, cb, orderStr))
            .collect(Collectors.toList());
    }
    private static <T> Order toJpaOrder(
        Root<T> root, CriteriaBuilder cb, String orderStr) {
        String[] orderclause = orderStr.split(" ");
        boolean ascending = true;
        if (orderclause.length - 2 && OrderClause[l].equalsIgnoreCase("desc")) {
            ascending = false;
        }
        String[] paths = orderClause[0].split("\\.");
        Path<Object> path = root.get(paths[0]);
        for (int i = 1; i < paths.length; i++) {
            path = path.get(paths[i]);
        }
        return ascending ? cb.asc(path) : cb.desc(path);
    }
}

• toJpaOrder 메서드는 문자열이 다음과 같이 주어지면, 정렬된 JPA Order 객체를 생성할 것이다.

  • name desc -> cb.desc(root.get( "name" ))

  • customer.name asc -> cb.asc(root.get( "customer" ).get( "name" ))

JPQL의 order by 절을 생성하기 위한 JpaQueryUtils 클래스의 메서드

public class JpaQueryUtils {
    // ...

    public static String toJPQLOrderby(String alias. String ... orders) {
        if (orders == null || orders.length == 0) return "";
        String orderParts = Arrays.stream(orders)
            .map(order -> alias + "." + order)
            .collect(joining("， "));
        return "order by " + orderParts;
    }
}

위 메소드 사용 코드

TypedQuery<Order> query = entityManager.createQuery(
    "select o from Order o " +
    "where o.orderer.memberld.id = :ordererld " +
    JpaQueryUtils.toJPQLOrderby("o", "number.number desc"),
                                Order.class);

TIP

정렬 순서를 타입으로 구현하면 오류를 줄인다. 예, ‘des’나 ‘a_ding’과 같이 잘못된 문자열을 사용해도 오름차순으로 정렬한다.

SortOrder sortOrder = new Ascending(ffnamew);
List<Member> members = memberRepository.findAll(specs, asc);
// --------------------------------------------
// SortOrder는 isAscending()과 같은 메서드를 제공하고, JpaQueryUtils 클래스는 이 메서드를 이용해서 알맞게 정렬을 처리하면 된다.
private static <T> Order toJpaOrder(Root<T> root, CriteriaBuilder cbj, SortOrder sortOrder) {
    String[] paths = sortOrder.getPath().split("\\.")；
        Path<Object> path = root.get(paths[0]);
    for (int i = 1; i < paths.length; i++) {
        path = path.get(paths[i]);
    }
    return sortOrder.isAscending() ? cb.asc(path) : cb.desc(path);
}

페이징과 개수 구하기 구현

JPA 쿼리는 페이징 처리를 위해 setFirstResult()와 setMaxResults() 메서드 제공한다.

@Override
public List<Order> findByOrdererld(String ordererld, int startRow, int fetchsize) {
    TypedQuery<Order> query = entityManager.createQuery(
        "select o from Order o " +
        "where o.orderer.memberld.id = :ordererld " +
        "order by o.number.number desc").
        Order.class);
    query.setParameter(uordererId"ordererld");
    // 첫 번째 행 번호를 지정
    query.setFirstResult(startRow); 
    // 읽어올 행 개수 지정
    query.setMaxResults(fetchsize);
    return query.getResultList();
}

한 페이지에 보여줄 행 개수가 15개이고 보여줄 페이지 번호가 4라면 (46번째 행부터 보여줘야함)

List<Order> orders = findByOrdererld("madvirus", 45, 15);

함께 자주 사용되는 기능 = 전체 개수 구하기

// JPQL 이용 예시
@Repository
public class JpaOrderRepository implements OrderRepository {
    //...
    @Override
    public Long countsAll() {
        TypedQuery<Long> query = entityManager.createQuery(
            "select count(o) from Order o", Long.class);
        return query.getSingleResult();
    }
    //...
}

Specification과 Criteria를 이용해서 특정 조건을 충족하는 애그리거트 개수 구하기

@Repository
public class JpaOrderRepository implements OrderRepository {
    //...
    @Override
    public Long counts(Specification<Order> spec) {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<Long> criteriaQuery = cb.createQuery(Long.class);
        Root<Order> root = criteriaQuery.from(Order.class);
        criteriaQuery. select(cb.count(root)).where(spec.toPredicate(root, cb));
        TypedQuery<Long> query = entityManager.createQuery(criteriaQuery);
        return query.getSingleResult();
    }
    //...
}

TIP

스프링 데이터 JPA 모듈을 이용하면 스팩, 정렬 순서, 페이징 을 자동으로 해준다. (인터페이스 작성만으로 끝남)

조회 전용 기능 구현

리포지터리 사용 부적합 예시

• 여러 애그리거트를 조합해서 한 화면에 보여주는 데이터 제공

• 각종 통계 데이터 제공

이런 기능은 조회 전용 쿼리로 처리해야 하는 것들이다.

JPA와 Hibernate를 사용하면 동적 인스턴스 생성, (Hibernate의) @Subselect 확장 기능, 네이티브 쿼리를 이용해서 조회 전용 기능을 구현할 수 있다.\

동적 인스턴스생성

JPA는 쿼리 결과에서 임의의 객체를 동적으로 생성할 수 있는 기능을 제공한다.

// 3장에서 나온 코드
@Repository
public class JpaOrderViewDao implements OrderViewDao {
    @PersistenceContext
    private EntityManager em;

    @Override
    public List<OrderView> selectByOrderer(String ordererld) {
        // new 키워드 사용
        // Order, Member, Product를 전달하고 필요한값 받아온다
        String selectQuery =
            "select new com.myshop.order.application. dto.OrderView(o, m, p) "+
            "from Order o join o.orderLines ol, Member m, Product p " +
            "where o.orderer.memberld.id = :ordererld "+
            "and o.orderer.memberld = m.id "+
            "and index(ol) = 0 " +
            "and ol.productld = p.id "+
            "order by o.number.number desc";
        TypedQuery<OrderView> query =
            em.createQuery(selectQueryOrderView.class);
        query.setParameter("ordererld", ordererld);
        return query.getResultList();
    }
}

아래와 같은 조회 전용 모델을 만드는 이유는 표현 영역을 통해 사용자에게 데이터를 보여주기 위함이다.

public class OrderView {
    private String number;
    private long totalAmounts;
    private String productName;
    public class OrderView(Order order, Member member, Product product) {
        this.number = order.getNumber().getNumber();
        this.totalAmounts = order.getTotalAmounts().getValue();
        this.productName = product.getName();
    }
    // get 메서드
}

동적 인스턴스의 장점으로 JPQL을 그대로 사용하므로 객체 기준으로 쿼리를 작성하 면서도 동시에 지연/즉시 로딩과 같은 고민 없이 원하는 모습으로 데이터를 조회할 수 있다.

하이버네이트 @Subselect 사용

하이버네이트는 JPA 확장 기능으로 @Subselect를 제공한다. 이것은 쿼리 결과를 @Entity로 매핑할 수 있게 해준다.

• @Immutable, @Subselect, ©Synchronize 이용하면 된다.

// @Subselect를 이용해서 @Entity를 매핑한 예
import org，hibernate.annotations.Immutable;
import org.hibernate.annotations.Subselect;
import org.hibernate.annotations.Synchronize;

import javax.persistence.*;
import java.util.Date;

@Entity
@Immutable
@Subselect("select o.order_number as number, " +
           "o.orderer_id, o.orderer name, o.total_amounts, " +
           "o.receiver_name, o.state, o.order_date, " +
           "p.product_id, p.name as product_name " +
           "from purchase_order o inner join order_line ol " +
           " on o.order_number : ol.order_number " +
           " cross join product p " +
           "where ol.line_idx = 0 and ol.product_id = p.product
          )
@Synchronize({"purchase__order", "order_line", "product"})
public class OrderSummary {
    @Id
    private String number;
    private String ordererld;
    private String ordererName;
    private int totalAmounts;
    private String receiverName;
    private String state;
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "orderDate")
    private Date orderDate;
    private String productld;
    private String productName;

    protected OrderSummaryO {
    }
    // ... get 메서드
}

• @Immutable 사용 이유: 뷰를 수정할 수 없듯이 @Subselect로 조회한 @Entity 역시 수정할 수 없다.

  • 어기면, 매핑한 테이블이 없으므로 에러가 난다.

• @Synchronize 사용 이유

  • 대게, 트랜잭션을 커밋하는 시점에 변경사항을 DB에 반영한다. Order의 변경 내역을 아직 purchase_order 테 이블에 반영하지 않은 상태 에서 purchase_order 테 이블을 사용하는 OrderSummary를 조회하게 된다. 즉, OrderSummary에는 최신 값이 아닌 이전 값이 담기게 된다.

  • 이런 문제를 해소한다.

  • 아래 코드 참고

Order의 상태를 변경한 뒤에 OrderSummary를 조회

// purchase_order 테이블에서 조회
Order order = orderRepository.findByld(orderNumber);
order.changeShippinglnfo(newInfo); // 상태 변경
// 변경 내역이 DB에 반영되지 않았는데 purchase_order 테이블에서 조회
List<OrderSummary> summaries = ororderSummaryRepository. findByOrdererld(userid);

@Subselect를 사용해도 일반 @Entity와 같기 때문에 EntityManager#find(), JPQL, Criteria를 사용해서 조회할 수 있다는 것이 @Subselect의 장점이다.

// @Subselect를 적용한 @Entity는 일반 @Entity와 동일한 방법으로 조회할 수 있다.
OrderSummary summary = entityManager.find(OrderSummary.class, orderNumber);
TypedQuery<OrderSunrnary> query = em.createQuery("select os from OrderSumnary " +
"os where os.ordererld = :ordererld " +
"order by os.orderDate desc", OrderSummary.class);
query.setParameter("ordererId', ordererld);
List<OrderSummary> result = query.getResultList();

서브쿼리를 사용하고 싶지 않다면 Native SQL 쿼리를 사용하거나 MyBatis와 같은 별도 매퍼를 사용해서 조회 기능을 구현해야 한다.