[DDD Start]5장. 리포지터리의 조회 기능

public interface Specification<T> {
  // 검사 대상 객체가 조건을 충족하면 true, 아니면 false
  public boolean isSatisfiedBy(T aggregate);
}

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

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

public class OrdererSpec implements Specification<Order> {
  private String ordererId;
  
  public OrdererSpec(String ordererId) {
    this.ordererId = ordererId;
  }
  
  // Order의 orderer.memberId.id 프로퍼티가 생성자로 전달받은 ordererId와 비교하는 Predicate를 리턴한다.
  @Override
  public Predicate toPredicate(Root<Order> root, CriteriaBuilder cb) {
    return cb.equal(root.get(Order_.orderer)
                    .get(Orderer_.memberId).get(MemberId_.id),
                    ordererId);
  }
}

public class OrderSpecs {
  public static Specification<Order> orderer(String ordererId) {
    return (root, cb) -> cb.equal(
      root.get(Order_.orderer).get(Order_.memberId).get(MemberId_.id),
    	ordererId);
  }
  
  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);

public class AndSpecification<T> implements Specification<T> {
  // 대략 spec들을 인자로 받아, List<Predicate>를 만든후 cb.and(predcates)를 리턴하는 코드
  // 실무에서 직접 구현할 일이 없어 생략한다. (스프링 데이터 JPA가 자동으로 해줌)
  ...
}

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

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

public interface OrderRepository {
  public List<Order> findAll(Specification<Order> spec);
  ...
}

@Repository
public class JpaOrderRepository implements OrderRepository {
  ...
  @Override
  public List<Order> findAll(Specification<Order> spec) {
    CriteriaBuidler cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<Order> criteriaQuery = cb.createQueury(Order.class);
    // 검새 조건 대상이 되는 루트 생성
    Root<Order> root = criteriaQuery.from(Order.class);
    // 파라미터로 전달받은 스펙을 이용해 Predicate 생성
    Predicate predicate = spec.toPredicate(root, cb);
    // 쿼리의 조건으로 생성한 Predicate 전달
    criteriaQuery.where(predicate);
    criteriaQuery.orderBy(
      cb.desc(root.get(Order_.number).get(OrderNo_.number)));
    TypedQuery<Order> query = entityManager.createQuery(criteriaQuery);
    return query.getResultList();
  }
}

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

List<Order> orders = orderRepository.findAll(someSpec, "number.number desc");

@Override
public List<Order> findByOrdererId(String ordererId, int startRow, int fetchSize) {
  TypedQuery<Order> query = entityManager.createQuery(...);
  query.setParameter(...);
  query.setFirstResult(startRow);
  query.setMaxResults(fetchSize);
  return qeury.getResultList();
}

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

@Repository
public class JpaOrderViewDao implements OrderViewDao {
  ...
  @Override
  public List<OrderView> selectByOrderer(String ordererId) {
    String selectQuery = 
      // new 키워드 뒤에 생성할 인스턴스의 완전한 클래스 이름 지정후 인자로 전달할 값을 지정한다.
      "select new OrderView(o, m, p) " +
      "from Order o join o.orderLines ol, Member m, Product p " +
      "...";
    TypedQuery<OrderView> query =
      em.createQuery(selectQuery, OrderView.class);
    query.setParameter("ordererId", ordererId);
    return query.getResultList();
  }
}

// 조회 전용 모델을 따로 만들어 표현 영역을 통해 사용자에게 데이터를 보여준다.
// 대부분 웹 프레임워크는 새로 추가한 밸류 타입을 알맞은 형식으로 출력하지 못하므로 아래와 같이 기본 타입으로 변환하면 편리하다.
public class OrderView {
  private String number;
  private long totalAmounts;
  ...
  public class OrderView(Order order, Member member, Product product) {
    this.number = order.getNumber().getNumber();
    this.totalAmounts = order.getTotalAmounts().getValue();
    ...
  }
  ... // get 메서드
}

---- JPQL
select new OrderView(o.number.number, o.totalAmounts, o.orderDate, m.id.id, m.name, p.name)
...(생략)

  
---- Java Constructor
public class OrderView {
  ...
  public OrderView(String number, long totalAmounts, Date orderDate, String memberId, String memberName, String productName) {
    this.number = number;
    ...
  }
}

@Entity
// @Subselect를 이용한 @Entity의 매핑 필드를 수정하면 하이버네이트는 변경 내역을 반영하는 update 쿼리를 실행한다.
// 그러나, 매핑한 ㅌ테이블이 
@Immutable
@Subselect("select o.order_number as number, " +
          "o.orderer_id, o.orderer_name, o.total_amounts, " +
          "...")
@Synchronize({"puchase_order", "order_line", "product"})
public class OrderSummaray {
  @Id
  private String number;
  private String ordererId;
  ...
  @Temporal(TemporalType.TIMESTAMP)
  @Column(name = "orderDate")
  ...
}

// purchase_order 테이블에서 조회
Order order = orderRepository.findById(orderNumber);
order.changeShippingInfo(newInfo); // 상태 변경

// 변경 내역이 DB 반영 안되었는데 purchase_order 테이블에서 조회
List<OrderSummary> summaries = orderSummaryRepository.findByOrdererId(userId);

select osm.number, osm.orderer_id,...
  ...생략
from (
  // 위의 @Subselect
  select o.order_number as number,
  o.orderer_id, o.orderer_name, o.total_amounts,
  ...
) osm
where osm.number = ?