[ JPA ] 상품 / 주문 도메인 개발

 

 

[ 상품 도메인 개발 ]

구현 기능 :  상품 등록, 상품 목록 조회, 상품 수정

순서 : 상품 엔티티 개발(비지니스 로직 추가) > 상품 리포지토리 개발 > 상품 서비스 개발

 

 

 

---

 

 

 

 

상품 엔티티 개발 

 

상품 수량을 늘리고, 줄이는 기능을 개발할껀데,

엔티티 자체에 해결할 수 있는것은 엔티티 안에서 비지니스 로직을 만드는것이 응집도가 있다.

/* stock 증가  */
public void addStock(int quantity){
    this.stockQuantity += quantity;
}

/*  stock 감소 */
public void removeStock(int quantity){
    int restStock = this.stockQuantity - quantity;
    if(restStock < 0) {
        throw new NotEnoughStockException("need more stock");
    }
    this.stockQuantity = restStock;
}

 setter를 통해 값을 변경하는게 아니고 add,remove 같은 로직을 설정해서 변경해야 한다. 

 

Exception을 관리하는 패키지를 하나 생성하고 NotEnoughStockException 파일을 만들어준다.

package jpabook.jpashop.exception;

public class NotEnoughStockException extends RuntimeException{

    // 오버라이드 (ctrl+o)
    public NotEnoughStockException() {
        super();
    }

    public NotEnoughStockException(String message) {
        super(message);
    }

    public NotEnoughStockException(String message, Throwable cause) {
        super(message, cause);
    }

    public NotEnoughStockException(Throwable cause) {
        super(cause);
    }

}

 

 

 

 

 

상품 리포지토리 개발

 

package jpabook.jpashop.repository;

import jakarta.persistence.EntityManager;
import jpabook.jpashop.domain.item.Item;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
@RequiredArgsConstructor
public class ItemRepository {

    private final EntityManager em;

	// 상품 저장
    public void save(Item item){
        if(item.getId()==null){
            em.persist(item);
        }else{
            em.merge(item);
        }
    }
	
    public Item findOne(Long id){
        return em.find(Item.class,id);
    }
    public List<Item> findAll(){
        return em.createQuery("select i from Item i",Item.class).getResultList();
    }
}

 

save 메소드에서,

id가 으면 신규로 보고 persist() 실행, id가 있으면 이미 데이터베이스에 저장된 엔티티를 수정한다고 보고 merge() 실행

 

 

 

상품 서비스 개발

 

package jpabook.jpashop.service;

import jpabook.jpashop.domain.item.Item;
import jpabook.jpashop.repository.ItemRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@Transactional(readOnly = true)
@RequiredArgsConstructor
public class ItemService {

    private final ItemRepository itemRepository;

    @Transactional
    public void saveItem(Item item){
        itemRepository.save(item);
    }

    public List<Item> findItem(){
        return itemRepository.findAll();
    }
    public Item findOne(Long itemId){
        return itemRepository.findOne(itemId);
    }
}

 

상품 서비스는 리포지토리에 위임만하는 메소드여서 간단하게 끝이났다

 

---

 

 

 

[ 주문 도메인 개발 ]

 

 

구현 기능 : 상품 주문, 주문 내역 조회, 주문 취소

개발 순서 : 주문 엔티티, 주문상품 엔티티 개발 > 주문 리포지토리 개발 > 주문 서비스 개발 > 주문 검색 기능 개발 > 테스트

 

 

 

 

주문, 주문상품 엔티티 개발

 

 

주문 생성은 복잡하다. 이렇게 복잡한 생성은 별도의 생성 메서드가 있으면 좋다.

 

order.java 파일에 생성메서드 작성

//==생성 메서드==//
public static Order createOrder(Member member, Delivery delivery,
                                OrderItem... orderItems) {
    Order order = new Order();
    order.setMember(member);
    order.setDelivery(delivery);
    for (OrderItem orderItem : orderItems) {
        order.addOrderItem(orderItem);
    }
    order.setStatus(OrderStatus.ORDER);
    order.setOrderDate(LocalDateTime.now());
    return order;
}

위의 order가 연관관계를 쫙 걸면서 셋팅이 되고, 주문 상태랑 시간까지 정리해준다.

나중에 뭔가 변경해야할게 있으면 createOrder만 변경해주면 되니까 간단!

 

비지니스 로직을 추가해주자

//==비즈니스 로직==//
/** 주문 취소 */
public void cancel() {
    if (delivery.getStatus() == DeliveryStatus.COMP) {
        throw new IllegalStateException("이미 배송완료된 상품은 취소가 불가능합니다.");
    }
    this.setStatus(OrderStatus.CANCEL);
    for (OrderItem orderItem : orderItems) {
    	// 재고 원복
        orderItem.cancel();
    }
}

 

그럼 orderItem.java에도 취소에 대한 비지니스 로직이 필요하기 때문에 코드를 작성해줘야한다.

여기도 생성메서드 먼저 만들어주고, 

// == 생성 메서드 ==
public static OrderItem createOrderItem(Item item, int orderPrice, int count){
    OrderItem orderItem = new OrderItem();
    orderItem.setItem(item);
    orderItem.setOrderPrice(orderPrice);
    orderItem.setCount(count);

    item.removeStock(count);
    return orderItem;
}

 

//    == 비지니스 로직 ==
    public void cancel(){
        getItem().addStock(count);
    }

 

다시 order.java로 돌아와서 

전체 주문 가격을 조회하는 로직을 만들어준다.

public int getTotalPrice() {
    int totalPrice = 0;
    for (OrderItem orderItem : orderItems) {
        totalPrice += orderItem.getTotalPrice();
    }
    return totalPrice;
}

 

 

 

 

주문 리포지토리 개발

 

package jpabook.jpashop.repository;

import jakarta.persistence.EntityManager;
import jpabook.jpashop.domain.Order;
import lombok.RequiredArgsConstructor;
import lombok.extern.java.Log;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
@RequiredArgsConstructor
public class OrderRepository {

    private final EntityManager em;

    public void save(Order order){
        em.persist(order);
    }
	
    // 주문 단건 조회
    public Order findOne(Long id){
        return em.find(Order.class,id);
    }
    
    // 검색기능
 // public List<Order> findAll(OrderSearch orderSearch) { ... }
}

검색기능은 동적쿼리 내용을 담고있기때문에 나중에 내용을 추가해주겠다

 

 

 

주문 서비스 개발

 

주문, 취소, 검색 기능을 중심으로 만들어보자

여러개의 리포지토리를 가져와야 한다.

private final OrderRepository orderRepository;
private final MemberRepository memberRepository;
private final ItemRepository itemRepository;

/* 주문*/
@Transactional
public Long order(Long memberId,Long itemId, int count){

    //엔티티 조회
    Member member = memberRepository.findOne(memberId);
    Item item = itemRepository.findOne(itemId);

    //배송 정보 생성
    Delivery delivery = new Delivery();
    delivery.setAddress(member.getAddress());

    //주문 상품 생성(static 생성 메서드로 생성함)
    OrderItem orderItem = OrderItem.createOrderItem(item, item.getPrice(), count);

    //주문 생성(static 생성 메서드로 생성함)
    Order order = Order.createOrder(member, delivery, orderItem);

    //주문 저장
    orderRepository.save(order);

    /* cascade 해야하는 범위 ? 참조할때 주인이 private일 경우에만 */

    return order.getId();

}

 

/* 취소 */
@Transactional
public void cancelOrder(Long orderId){
    // 주문 엔티티 조회
    Order order = orderRepository.findOne(orderId);
    // 주문 취소
    order.cancel();

}

 

마이바티스같은걸 썼다면, 취소후 변경되는 상태를 update를 쿼리를 작성해서 날려서 변경해줘야하는데,

JPA는 데이터가 바뀌면 변경내역감지가 이루어져서 알아서 update쿼리가 날라가서 변경해준다.

// 검색
public List<Order> findOrders(OrderSearch orderSearch){
    return orderRepository.findAll(orderSearch);
}

검색은 나중에 사용할거여서 일단 만들어만 놨다

 

 

참고: 주문 서비스의 주문과 주문 취소 메서드를 보면 비즈니스 로직 대부분이 엔티티에 있다. 서비스 계층은 단순 히 엔티티에 필요한 요청을 위임하는 역할을 한다. 이처럼 엔티티가 비즈니스 로직을 가지고 객체 지향의 특성을 적극 활용하는 것을 도메인 모델 패턴(http://martinfowler.com/eaaCatalog/domainModel.html)이라 한 다. 반대로 엔티티에는 비즈니스 로직이 거의 없고 서비스 계층에서 대부분의 비즈니스 로직을 처리하는 것을 트 랜잭션 스크립트 패턴(http://martinfowler.com/eaaCatalog/transactionScript.html)이라 한다

 

 

 

 

 

주문 검색 기능 개발

 

JPA에서 동적쿼리를 사용하는방법을 알아보자

 

리포지토리 패키지에 orderSearch.java 파일을 만들어준다.

package jpabook.jpashop.repository;

import jpabook.jpashop.domain.OrderStatus;
import lombok.Getter;
import lombok.Setter;

@Getter @Setter
public class OrderSearch {
    private String memberName; //회원 이름
    private OrderStatus orderStatus; // 주문 상태(ORDER, CANCEL)

}

 

이제 orderRepository에서 구현해보자

위에 주석처리한 findAll 메서드에서 내용을 추가한다.

public List<Order> findAll(OrderSearch orderSearch){
	em.createQuery("select o from Order o join o.member m", +
    	"where o.status = :status" +
        "and m.name like :name",Order.class)
        .setParameter("status",orderSearch.getOrderStatus())
        .setParameter("name",orderSearch.getMemberName())
        .setMaxResults(1000) // 최대 1000건
        .getResultList();
}

이렇게 작성해주면 간단하게 join된 테이블에서 값을 가져올 수 있다. 하지만 위의 코드는 값이 존재한다는 전제가 있다.

어떤 값이있다면 이렇게 처리해, 저렇게 처리해 > 이런 동적쿼리를 해결하는것이 복잡하고 까다롭다.

 

여러개의 방법이 있는데, JPQL로 처리하는 방법 혹은 JPA Criteria로 처리하는 방법이 있다.

 

우선 JPQL방법은 쿼리를 문자로 생성하기 번거롭고, 실수로 인한 버그가 충분히 발생할 수 있다.

JPA Criteria는 JPA 표준 스펙이지만 실무에서 사용하기엔 너무 복잡하다..

 

해결책은 Querydsl ! 이후에 심화과정에서 배우고 일단은 JPA Criteria로 작성해서 진행해보자..

public List<Order> findAllByCriteria(OrderSearch orderSearch) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Order> cq = cb.createQuery(Order.class);
    Root<Order> o = cq.from(Order.class);
    Join<Order, Member> m = o.join("member", JoinType.INNER); //회원과 조인
    List<Predicate> criteria = new ArrayList<>();
    //주문 상태 검색
    if (orderSearch.getOrderStatus() != null) {
        Predicate status = cb.equal(o.get("status"),
                orderSearch.getOrderStatus());
        criteria.add(status);
    }
    //회원 이름 검색
    if (StringUtils.hasText(orderSearch.getMemberName())) {
        Predicate name =
                cb.like(m.<String>get("name"), "%" + orderSearch.getMemberName()
                        + "%");
        criteria.add(name);
    }
    cq.where(cb.and(criteria.toArray(new Predicate[criteria.size()])));
    TypedQuery<Order> query = em.createQuery(cq).setMaxResults(1000); //최대 1000건
    
    return query.getResultList();
}

정말 코드만 보고서는 어떤 쿼리문이 생길지 가늠이 안간다 ㅜ