[Spring] Spring Data JPA 데이터 액세스 계층 구현
스프링 복습 및 정리 12.3P
Spring Data JPA
Spring Data JDBC와 Spring Data JPA는 Spring Data라는 패밀리 그룹에 포함되어 있다.
Spring Data라는 추상화된 데이터 액세스 접근 방식으로 구성이 되어 있기 때문에
Spring Data JDBC와 Spring Data JPA라는 기술은 사용하는 방식이 거의 유사하다.
그렇기 때문에 Spring Data JDBC랑 사용 방법이 거의 비슷하다고 느낄 것이다.
정리하자면, Spring Data JPA는 Spring Data 패킬리 기술 중 하나로써,
JPA 기반의 데이터 액세스 기술을 좀 더 쉽게 사용할 수 있게 해주기 때문에
데이터 액세스 계층 구현에 있어 개발 시간을 단축시켜준다.
JPA, Hibernate ORM, Spring Data JPA를 헷갈려할 수 있어 세 가지 용어를 간단히 정리해 보겠다.
JPAJPA의 경우 이름 자체는 Jakarta Persistence API(또는 Java Persistence API)라서
마치 API를 가져다 쓸 수 있는 건가 라는 생각이 들 수 있지만
JPA는 엔터프라이즈 Java 애플리케이션에서 관계형 데이터베이스를 사용하기 위해
정해 놓은 표준 스펙(사양 또는 명세)이다.
’이 기술은 무엇이고, 이 기술은 이렇게 구현해서 사용하면 돼’라고 적어 놓은 기술 명세라고 생각하면 쉽다.
Hibernate ORMJPA라는 표준 스펙을 구현한 구현체이다. 실제 우리가 사용할 수 있는 API라고 보면 된다.
Spring Data JPAJPA 스펙을 구현한 구현체의 API(일반적으로 Hibernate ORM)를 조금 더 쉽게 사용할 수 있도록
해주는 모듈이다. 이 Spring Data JPA를 사용하여 데이터 액세스 계층을 구현하면 된다.
아래에서 이전 포스트 [더보기]에서 작성했던 커피 주문 샘플 애플리케이션을 Spring Data JPA로 변경해 보겠다.
엔티티 클래스 정의
Member
@NoArgsConstructor
@Getter
@Setter
@Entity
public class Member {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long memberId;
@Column(nullable = false, updatable = false, unique = true)
private String email;
@Column(length = 100, nullable = false)
private String name;
@Column(length = 13, nullable = false, unique = true)
private String phone;
// (1) 추가된 부분
@Enumerated(value = EnumType.STRING)
@Column(length = 20, nullable = false)
private MemberStatus memberStatus = MemberStatus.MEMBER_ACTIVE;
@Column(nullable = false)
private LocalDateTime createdAt = LocalDateTime.now();
@Column(nullable = false, name = "LAST_MODIFIED_AT")
private LocalDateTime modifiedAt = LocalDateTime.now();
@OneToMany(mappedBy = "member")
private List<Order> orders = new ArrayList<>();
public Member(String email) {
this.email = email;
}
public Member(String email, String name, String phone) {
this.email = email;
this.name = name;
this.phone = phone;
}
public void addOrder(Order order) {
orders.add(order);
}
// (2) 추가 된 부분
public enum MemberStatus {
MEMBER_ACTIVE("활동중"),
MEMBER_SLEEP("휴면 상태"),
MEMBER_QUIT("탈퇴 상태");
@Getter
private String status;
MemberStatus(String status) {
this.status = status;
}
}
}
위 코드는 Member 엔티티 클래스에 JPA 어노테이션을 적용한 코드이다.
(1)과 (2)를 제외하고는 12.2P [더보기] 포스트의 Member 클래스의 엔티티 매핑 때 적용한 코드들이다.
Coffee
@NoArgsConstructor
@Getter
@Setter
@Entity
public class Coffee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long coffeeId;
@Column(length = 100, nullable = false)
private String korName;
@Column(length = 100, nullable = false)
private String engName;
@Column(nullable = false)
private Integer price;
@Column(length = 3, nullable = false, unique = true)
private String coffeeCode;
// (1) 추가된 부분
@Enumerated(value = EnumType.STRING)
@Column(length = 20, nullable = false)
private CoffeeStatus coffeeStatus = CoffeeStatus.COFFEE_FOR_SALE;
@Column(nullable = false)
private LocalDateTime createdAt = LocalDateTime.now();
@Column(nullable = false, name = "LAST_MODIFIED_AT")
private LocalDateTime modifiedAt = LocalDateTime.now();
// (2) 추가 된 부분
public enum CoffeeStatus {
COFFEE_FOR_SALE("판매중"),
COFFEE_SOLD_OUT("판매중지");
@Getter
private String status;
CoffeeStatus(String status) {
this.status = status;
}
}
}
이것 역시 (1)과 (2)를 제외하고는 이전 포스트와 동일한 코드이다.
Order
@NoArgsConstructor
@Getter
@Setter
@Entity(name = "ORDERS")
public class Order {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long orderId;
@Enumerated(EnumType.STRING)
private OrderStatus orderStatus = OrderStatus.ORDER_REQUEST;
@Column(nullable = false)
private LocalDateTime createdAt = LocalDateTime.now();
@Column(nullable = false, name = "LAST_MODIFIED_AT")
private LocalDateTime modifiedAt = LocalDateTime.now();
@ManyToOne
@JoinColumn(name = "MEMBER_ID")
private Member member;
@OneToMany(mappedBy = "order")
private List<OrderCoffee> orderCoffees = new ArrayList<>();
public void addMember(Member member) {
this.member = member;
}
public void addOrderCoffee(OrderCoffee orderCoffee) {
orderCoffees.add(orderCoffee);
}
public enum OrderStatus {
ORDER_REQUEST(1, "주문 요청"),
ORDER_CONFIRM(2, "주문 확정"),
ORDER_COMPLETE(3, "주문 처리 완료"),
ORDER_CANCEL(4, "주문 취소");
@Getter
private int stepNumber;
@Getter
private String stepDescription;
OrderStatus(int stepNumber, String stepDescription) {
this.stepNumber = stepNumber;
this.stepDescription = stepDescription;
}
}
}
Repository 인터페이스 구현
MemberRepository
public interface MemberRepository extends JpaRepository<Member, Long> { // 수정된 부분
Optional<Member> findByEmail(String email);
}
Spring Data JDBC에서의 MemberRepository와 비교했을 때 CrudRepository를 상속하는 대신
JpaRepository를 상속하도록 변경되었다.
JpaRepository를 상속하지 않고, CrudRepository를 상속해도 되지만 JpaRepository가 JPA에 특화된
더 많은 기능들을 포함하고 있기 때문에 JpaRepository를 상속했다.
CoffeeRepository
public interface CoffeeRepository extends JpaRepository<Coffee, Long> {//(1) 수정된 부분
Optional<Coffee> findByCoffeeCode(String coffeeCode);
// (2) 수정된 부분
// @Query(value = "FROM Coffee c WHERE c.coffeeId = :coffeeId") // (2-1)
// @Query(value = "SELECT * FROM COFFEE WHERE coffee_Id = :coffeeId", nativeQuery = true) // (2-2)
@Query(value = "SELECT c FROM Coffee c WHERE c.coffeeId = :coffeeId") // (2-3)
Optional<Coffee> findByCoffee(long coffeeId);
}
JPA에서는 복잡한 검색 조건을 지정하기 위한 몇 가지 방법을 제공한다.
JPQL을 통한 객체 지향 쿼리 사용
JPA에서는 JPQL이라는 객체 지향 쿼리를 통해 데이터베이스 내의 테이블을 조회할 수 있다.
JPQL은 데이터베이스의 테이블을 대상으로 조회 작업을 진행하는 것이 아니라
엔티티 클래스의 객체를 대상으로 객체를 조회하는 방법이다.
JPQL의 문법을 사용해서 객체를 조회하면 JPA가 내부적으로 JPQL을 분석해서 적절한 SQL을 만든 후에
데이터베이스를 조회하고, 조회한 결과를 엔티티 객체로 매핑한 뒤에 반환한다.
(2-3)은 JPQL을 사용해서 coffeeId에 해당하는 커피 정보를 조회하고 있다.
JPQL의 쿼리문을 보면 SQL과 유사하지만 차이점이 있다.
JPQL은 객체를 대상으로 한 조회이기 때문에 COFFEE 테이블이 아니라 Coffee 클래스라는 객체를 지정해야 하고,
coffee_id라는 열이 아닌 coffeeId 필드를 지정해야 한다.
따라서 (2-3)의 SELECT c FROM Coffee c WHERE c.coffeeId = :coffeeId에서 Cofffee는 클래스명이고,
coffeeId는 Coffee 클래스의 필드명이다.
c는 Coffee 클래스의 별칭이기 때문에 SELECT c FROM~ 와 같이 SQL에서 사용하는 *이 아니라
c로 모든 필드를 조회하는 것이다.
(2-3)은 (2-1)과 같이 SELECT c를 생략한 형태로 사용이 가능하다.
네이티브 SQL을 통한 조회
Spring Data JDBC에서와 마찬가지로 JPA 역시 네이티브 SQL 쿼리를 작성해서 사용할 수 있다.
(2-2)의 nativeQuery 애트리뷰트의 값을 true로 설정하면 value 애트리뷰트에 작성한 SQL 쿼리가 적용된다.
Spring Data JDBC에서 사용하는 @Query 어노테이션과
Spring Data JPA에서 사용하는 @Query 어노테이션은 이름은 같지만 패키지 자체가
다르기 때문에 만약에 Starter 모듈이 둘 다 의존 라이브러리에 포함이 되어 있는 경우에는
패키지 경로를 혼동하지 않도록 주의해야 한다.
Spring Data JDBC의 @Query 어노테이션org.springframework.data.jdbc.repository.query.Query
org.springframework.data.jpa.repository.Query
OrderRepository
public interface OrderRepository extends JpaRepository<Order, Long> {}
Service 클래스 구현
MemberService
@Service
public class MemberService {
private final MemberRepository memberRepository;
public MemberService(MemberRepository memberRepository) {
this.memberRepository = memberRepository;
}
public Member createMember(Member member) {
verifyExistsEmail(member.getEmail());
return memberRepository.save(member);
}
public Member updateMember(Member member) {
Member findMember = findVerifiedMember(member.getMemberId());
Optional.ofNullable(member.getName())
.ifPresent(name -> findMember.setName(name));
Optional.ofNullable(member.getPhone())
.ifPresent(phone -> findMember.setPhone(phone));
// 추가된 부분
Optional.ofNullable(member.getMemberStatus())
.ifPresent(memberStatus -> findMember.setMemberStatus(memberStatus));
// 추가된 부분
findMember.setModifiedAt(LocalDateTime.now());
return memberRepository.save(findMember);
}
public Member findMember(long memberId) {
return findVerifiedMember(memberId);
}
public Page<Member> findMembers(int page, int size) {
return memberRepository.findAll(PageRequest.of(page, size,
Sort.by("memberId").descending()));
}
public void deleteMember(long memberId) {
Member findMember = findVerifiedMember(memberId);
memberRepository.delete(findMember);
}
public Member findVerifiedMember(long memberId) {
Optional<Member> optionalMember =
memberRepository.findById(memberId);
Member findMember =
optionalMember.orElseThrow(() ->
new BusinessLogicException(ExceptionCode.MEMBER_NOT_FOUND));
return findMember;
}
private void verifyExistsEmail(String email) {
Optional<Member> member = memberRepository.findByEmail(email);
if (member.isPresent())
throw new BusinessLogicException(ExceptionCode.MEMBER_EXISTS);
}
}
CoffeeService
@Service
public class CoffeeService {
private final CoffeeRepository coffeeRepository;
public CoffeeService(CoffeeRepository coffeeRepository) {
this.coffeeRepository = coffeeRepository;
}
public Coffee createCoffee(Coffee coffee) {
String coffeeCode = coffee.getCoffeeCode().toUpperCase();
verifyExistCoffee(coffeeCode);
coffee.setCoffeeCode(coffeeCode);
return coffeeRepository.save(coffee);
}
public Coffee updateCoffee(Coffee coffee) {
Coffee findCoffee = findVerifiedCoffee(coffee.getCoffeeId());
Optional.ofNullable(coffee.getKorName())
.ifPresent(korName -> findCoffee.setKorName(korName));
Optional.ofNullable(coffee.getEngName())
.ifPresent(engName -> findCoffee.setEngName(engName));
Optional.ofNullable(coffee.getPrice())
.ifPresent(price -> findCoffee.setPrice(price));
// 추가된 부분
Optional.ofNullable(coffee.getCoffeeStatus())
.ifPresent(coffeeStatus -> findCoffee.setCoffeeStatus(coffeeStatus));
return coffeeRepository.save(findCoffee);
}
public Coffee findCoffee(long coffeeId) {
return findVerifiedCoffeeByQuery(coffeeId);
}
public Page<Coffee> findCoffees(int page, int size) {
return coffeeRepository.findAll(PageRequest.of(page, size,
Sort.by("coffeeId").descending()));
}
public void deleteCoffee(long coffeeId) {
Coffee coffee = findVerifiedCoffee(coffeeId);
coffeeRepository.delete(coffee);
}
public Coffee findVerifiedCoffee(long coffeeId) {
Optional<Coffee> optionalCoffee = coffeeRepository.findById(coffeeId);
Coffee findCoffee =
optionalCoffee.orElseThrow(() ->
new BusinessLogicException(ExceptionCode.COFFEE_NOT_FOUND));
return findCoffee;
}
private void verifyExistCoffee(String coffeeCode) {
Optional<Coffee> coffee = coffeeRepository.findByCoffeeCode(coffeeCode);
if(coffee.isPresent())
throw new BusinessLogicException(ExceptionCode.COFFEE_CODE_EXISTS);
}
private Coffee findVerifiedCoffeeByQuery(long coffeeId) {
Optional<Coffee> optionalCoffee = coffeeRepository.findByCoffee(coffeeId);
Coffee findCoffee =
optionalCoffee.orElseThrow(() ->
new BusinessLogicException(ExceptionCode.COFFEE_NOT_FOUND));
return findCoffee;
}
}
OrderService
@Service
public class OrderService {
private final MemberService memberService;
private final OrderRepository orderRepository;
public OrderService(MemberService memberService,
OrderRepository orderRepository) {
this.memberService = memberService;
this.orderRepository = orderRepository;
}
public Order createOrder(Order order) {
// 회원 존재 확인
verifyOrder(order);
// 커피 존재 확인 스탬프 업데이트
updateStamp(order);
return orderRepository.save(order);
}
// 주문 상태 처리를 위한 updateOrder() 메서드 추가
public Order updateOrder(Order order) {
Order findOrder = findVerifiedOrder(order.getOrderId());
Optional.ofNullable(order.getOrderStatus())
.ifPresent(orderStatus -> findOrder.setOrderStatus(orderStatus));
findOrder.setModifiedAt(LocalDateTime.now());
return orderRepository.save(findOrder);
}
public Order findOrder(long orderId) {
return findVerifiedOrder(orderId);
}
public Page<Order> findOrders(int page, int size) {
return orderRepository.findAll(PageRequest.of(page, size,
Sort.by("orderId").descending()));
}
public void cancelOrder(long orderId) {
Order findOrder = findVerifiedOrder(orderId);
int step = findOrder.getOrderStatus().getStepNumber();
if (step >= 2) {
throw new BusinessLogicException(ExceptionCode.CANNOT_CHANGE_ORDER);
}
findOrder.setOrderStatus(Order.OrderStatus.ORDER_CANCEL);
findOrder.setModifiedAt(LocalDateTime.now());
orderRepository.save(findOrder);
}
private Order findVerifiedOrder(long orderId) {
Optional<Order> optionalOrder = orderRepository.findById(orderId);
Order findOrder =
optionalOrder.orElseThrow(() ->
new BusinessLogicException(ExceptionCode.ORDER_NOT_FOUND));
return findOrder;
}
private void verifyOrder(Order order) {
// 회원이 존재하는지 확인
memberService.findVerifiedMember(order.getMember().getMemberId());
// 커피가 존재하는지 확인
order.getOrderCoffees().stream()
.forEach(orderCoffee ->
coffeeService.findVerifiedCoffee(
orderCoffee.getCoffee().getCoffeeId()));
}
private void updateStamp(Order order) {
Member member = order.getMember();
int stampCount = order.getOrderCoffees().stream()
.map(orderCoffee -> orderCoffee.getQuantity())
.mapToInt(el -> el)
.sum();
member.getStamp().setStampCount(member.getStamp().getStampCount() + stampCount);
}
}
지금까지의 코드를 확인해 보면 Spring Data JDBC에서 Spring Data JPA로 바꿨다고 해서
실제로 코드 자체가 대폭 변경된 부분은 없다.
이 말의 의미는 애플리케이션이 특정 기술에 강하게 결합되지 않도록
Spring이 추구하는 PSA(일관된 서비스 추상화)를 통해 개발자는 일관된 코드 구현 방식을 유지하도록 하고,
기술의 변경이 필요할 때 최소한의 변경만을 하도록 지원한다.
기타 수정 코드
OrderController
@RestController
@RequestMapping("/v11/orders")
@Validated
public class OrderController {
private final static String ORDER_DEFAULT_URL = "/v11/orders";
private final OrderService orderService;
private final OrderMapper mapper;
private final CoffeeService coffeeService;
public OrderController(OrderService orderService,
OrderMapper mapper,
CoffeeService coffeeService) {
this.orderService = orderService;
this.mapper = mapper;
this.coffeeService = coffeeService;
}
@PostMapping
public ResponseEntity postOrder(@Valid @RequestBody OrderPostDto orderPostDto) {
Order order = orderService.createOrder(mapper.orderPostDtoToOrder(orderPostDto));
URI location = UriCreator.createUri(ORDER_DEFAULT_URL, order.getOrderId());
return ResponseEntity.created(location).build();
}
@PatchMapping("/{order-id}")
public ResponseEntity patchOrder(@PathVariable("order-id") @Positive long orderId,
@Valid @RequestBody OrderPatchDto orderPatchDto) {
orderPatchDto.setOrderId(orderId);
Order order = orderService.updateOrder(mapper.orderPatchDtoToOrder(orderPatchDto));
return new ResponseEntity<>(null);
}
@GetMapping("/{order-id}")
public ResponseEntity getOrder(@PathVariable("order-id") @Positive long orderId) {
Order order = orderService.findOrder(orderId);
return new ResponseEntity<>(new SingleResponseDto<>(order), HttpStatus.OK);
}
@GetMapping
public ResponseEntity getOrders(@Positive @RequestParam int page,
@Positive @RequestParam int size) {
Page<Order> pageOrders = orderService.findOrders(page - 1, size);
List<Order> orders = pageOrders.getContent();
return new ResponseEntity<>(new MultiResponseDto<>(orders, pageOrders), HttpStatus.OK);
}
@DeleteMapping("/{order-id}")
public ResponseEntity cancelOrder(@PathVariable("order-id") @Positive long orderId) {
orderService.cancelOrder(orderId);
return new ResponseEntity<>(HttpStatus.NO_CONTENT);
}
}
Spring Boot 핵심 정리 모음
1P - POJO, IoC, DI, AOP, PSA >
3P - 컴포넌트 스캔과 의존성 자동 주입, @Autowired >
5P - Spring MVC / MVC의 동작 방식과 구성 요소 >
7P - HTTP Header, Rest Client >
9P - Service / Entity 클래스, Mapper / MapStruct >
10P - 예외 처리 (@ExceptionHandler, @RestControllerAdvice) >
11.1P - DDD, 도메인 엔티티 및 테이블 설계 >
11.2P - 데이터 액세스 계층 구현 (도메인 엔티티 클래스 정의) >
11.3P - 데이터 액세스 계층 구현 (서비스, 리포지토리 구현) >
12P - JPA(Java Persistence API) >
12.3P - Spring Data JPA 데이터 액세스 계층 구현 >
14P - Spring MVC Testing 단위 테스트 >
14.3P - 슬라이스 테스트 (API, 데이터 액세스 계층) >
14.5P - TDD (Test Driven Development) >
15P - API 문서화 (Documentation) >
댓글남기기