#12 실습

김영한 저 "자바 ORM 표준 JPA 프로그래밍"을 읽고 정리한 내용입니다.

• 설정 추가

• 리포지토리 리팩토링

• 명세 적용

1. 설정 추가

스프링부트로 할거라서 생략

2. 리포지토리 리팩토링

2.1 MemberRepository 리팩토링

STUDY-JPA/src/main/java/com/larrykim/jpastudy/repository/MemberRepository.java at chap11-4 · hello-yoochul/STUDY-JPAGitHub

// 리팩토링 후 
import com.larrykim.domain.Member;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;


public interface MemberRepository extends JpaRepository<Members, Long> {
    List<Member> findByName(String name);
}

2.2 ItemRepository 리팩토링

STUDY-JPA/src/main/java/com/larrykim/jpastudy/repository/ItemRepository.java at chap11-4 · hello-yoochul/STUDY-JPAGitHub

// 리팩토링 후 
import com.larrykim.domain.item.Item;
import org.springframework.data.jpa.repository.JpaRepository;


public interface ItemRepository extends JpaRepository<Item, Long> {
}

2.3 OrderRepository 리팩토링

STUDY-JPA/src/main/java/com/larrykim/jpastudy/repository/OrderRepository.java at chap11-4 · hello-yoochul/STUDY-JPAGitHub

// 리팩토링 후 
import com.larrykim.repository.custom.CustomOrderRepository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

public interface OrderRepository
    extends JpaRepository<Order, Long>, JpaSpecificationExecutor<Order> {
}

3. 명세 적용 - 어렵다 더 공부

명세로 검색하는 기능을 사용하려면 리포지토리에 JpaSpecificationExecutor를 추가로 상속받아야 한다.

//명세를 작성하기 위한 클래스
package com.larrykim.jpastudy.domain;

import org.springframework.data.jpa.domain.Specification;
import org.springframework.util.StringUtils;
import javax.persistence.criteria.*;

public class OrderSpec {
     public static Specification<Order> memberNameLike(final String memberName) {
         //편의상 익명 클래스 사용
        return new Specification<Order>() {
            public Predicate toPredicate(Root<Order> root, CriteriaQuery<?> query, CriteriaBuilder builder) {

                if (StringUtils.isEmpty(memberName)) return null;

                Join<Order, Member> m = root.join("member", JoinType.INNER); //회원과 조인
                return builder.like(m.<String>get("name"), "%" + memberName + "%");
            }
        };
    }

    public static Specification<Order> orderStatusEq(final OrderStatus orderStatus) {
        return new Specification<Order>() {
            public Predicate toPredicate(Root<Order> root, CriteriaQuery<?> query, CriteriaBuilder builder) {

                if (orderStatus == null) return null;

                return builder.equal(root.get("status"), orderStatus);
            }
        };
    }
}

OrderSearch 객체에 자신이 가진 검색조건으로 Specification을 생성하도록 코드를 추가한다.

import org.springframework.data.jpa.domain.Specifications;
import static com.larrykim.jpastudy.domain.OrderSpec.memberNameLike;
import static com.larrykim.jpastudy.domain.OrderSpec.orderStatusEq;
import static org.springframework.data.jpa.domain.Specifications.where;


public class OrderSearch {
    private String memberName; 
    private Orderstatus orderstatus;
    
    //...Getter, Setter

    //추가
    public Specifications<Order> toSpecification() {
        return where(memberNameLike(memberName))
            .and(orderStatusEq(orderstatus));
    }
    
}

리포지토리의 검색 코드가 명세를 파라미터로 넘기도록 OrderService를 변경한다.

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

}

//후
public List<Order> findOrders(OrderSearch orderSearch) {
    return orderRepository.findAll(orderSearch.toSpecification());

}

4. QueryDsl 사용

4.1 QueryDslPredicateExecutor

리포지토리에서 상속받으면 된다.

public interface ItemRepository
    extends JpaRepository<Item, Long>, QueryDslPredicateExecutor<Item> {
}

//사용 코드
Qltem item = Qltem.item;
Iterable<Item> result = itemRepository.findAll(
            item.name.contains("장난감").and(item.price.between(10000, 20000))
            );

QueryDslPredicateExecutor 인터페이스를 보면 Page<T> findAll(Predicate predicate, Pageable pageable);이 있어 페이징과 정렬 기능도 사용가능

하지만, join, fetch 를 사용할 수 없는 한계가 있다. (묵시적 조인만 가능) 이때는QueryDslRepositorySupport 사용

4.2 QueryDslRepositorySupport

스프링 데이터 JPA가 제공하는 공통 인터페이스는 직접 구현할 수 없기 때문에 사용자 정의 리포지토리 CustomOrderRepository를 만든다.

package com.larrykim.jpastudy.repository.custom;

import com.larrykim.jpastudy.domain.Order;
import com.larrykim.jpastudy.domain.OrderSearch;
import java.util.List;

public interface CustomOrderRepository {
    public List<Order> search(OrderSearch orderSearch);

}

CustomOrderRepository를 implements 한다.

package com.larrykim.jpastudy.repository.custom;

import com.mysema.query.jpa.JPQLQuery;
import com.larrykim.jpastudy.domain.Order;
import com.larrykim.jpastudy.domain.OrderSearch;
import com.larrykim.jpastudy.domain.QMember;
import com.larrykim.jpastudy.domain.QOrder;
import org.springframework.data.jpa.repository.support.QueryDsIRepositorySupport;
import org.springframework.util.StringUtils;
import java.util.List;

public class OrderRepositorylmpl extends QueryDsIRepositorySupport
implements CustomOrderRepository {
    
    //생성자에서 QueryDslRepositorySupport에 엔티티 클래스 정보를 넘겨주어야 한다.
    public OrderRepositorylmpl() {
        super(Order.class);
    }
    
    @Override
    public List<Order> search(OrderSearch orderSearch) {
    
        QOrder order = QOrder.order;
        QMember member = QMember.member;
        JPQLQuery query = from(order);
        
        //검색 조건에 따라 동적으로 쿼리를 생성한다.
        if (StringUtils.hasText(orderSearch.getMemberName())) {
            query.leftJoin(order.member, member)
                .where(member.name.contains(orderSearch.getMemberName()));
        }
        if (orderSearch.getOrderStatus() != null) {
            query.where(order.status.eq(orderSearch.getOrderStatus()));
        }
        
        return query.list(order); 
    }
}

QueryDsIRepositorySupport 코드

package org.springframework.data.jpa.repository.support;
 
@Repository
public abstract class QueryDslRepositorySupport {

    //엔티티 매니저 반환
    protected EntityManager getEntityManager() {
        return entityManager;
    }
    
    //from 절 반환
    protected JPQLQuery from(EntityPath<?>... paths) {
        return querydsl.createQuery(paths);
    }
    
    //QueryDSL delete 절 반환
    protected DeleteClause<JPADeleteClause> delete(EntityPath<?> path)
    {
        return new JPADeleteClause(entityManager, path);
    }
    
    //QueryDSL update 절 반환
    protected UpdateClause<JPAUpdateClause> update(EntityPath<?> path)
    {
        return new JPAUpdateClause(entityManager, path);
    }
    
    //스프링 데이터 JPA가 제공하는 Querydsl을 편하게 사용하도록 돕는
    //핼퍼 객체 반환
    protected Querydsl getQuerydsl() {
        return this.querydsl;
    }

    
}