🎽 인프런 워밍업 클럽 0기 백엔드 일곱 번째 과제

출처
https://inf.run/XKQg

Spring Data JPA를 사용한 데이터베이스 조작에 대해 학습하여 과제를 수행했다.

🌈 Spring Data JPA란?

JPA는 자바 Object와 Realational(관계형 데이터베이스) 간의 매핑을 위한 표준 인터페이스를 제공한다.
Spring Data JPA는 이러한 JPA를 더 쉽게 사용할 수 있도록 도와주며 반복적인 코드를 최소화한다.

⛳️ Fruit Entity

Spring Data JPA에서 사용되는 Entity 클래스이다.
Entity 클래스란 데이터베이스의 테이블과 매핑되는 자바 객체를 의미하며, 이 클래스는 데이터베이스의 fruit 테이블과 상호작용하기 위해 사용된다.

데이터베이스에서는 Snake Case를 사용한다.
Snake Case는 단어 사이를 언더스코어(_)로 구분하는 명명 규칙으로, 데이터베이스 테이블의 컬럼명을 일반적으로 지을 때 사용되는 방식 중 하나이다.

자바는 Camel Case를 사용하므로 @Column(name = "warehousing_date")와 @Column(name = "is_sold")을 통해 테이블의 컬럼명을 직접 지정했다.

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import java.time.LocalDate;
import lombok.Getter;
import lombok.ToString;

@Getter
@ToString
@Entity
public class Fruit {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @Column(name = "warehousing_date")
    private LocalDate warehousingDate;

    private Long price;

    @Column(name = "is_sold")
    private Boolean isSold = false;

    protected Fruit() {
    }

    public Fruit(String name, LocalDate warehousingDate, Long price) {
        this.name = name;
        this.warehousingDate = warehousingDate;
        this.price = price;
    }

    public void changeStatus() {
        this.isSold = true;
    }
}

⛳️ FruitRepository

FruitRepository 인터페이스는 Spring Data JPA에서 제공하는 JpaRepository를 확장하여 과일(Fruit) 엔티티에 대한 데이터 액세스 기능을 정의한다.

import java.util.List;
import java.util.Optional;
import org.springframework.data.jpa.repository.JpaRepository;

public interface FruitRepository extends JpaRepository<Fruit, Long> {
    // 문제1
    Optional<Fruit> findById(Long id);

    List<Fruit> findByNameAndIsSoldIsFalse(String name);

    List<Fruit> findByNameAndIsSoldIsTrue(String name);


    // 문제2
    long countByName(String name);
    

    // 문제3
    List<Fruit> findAllByPriceGreaterThanEqualAndIsSoldIsFalse(Long price);

    List<Fruit> findAllByPriceLessThanEqualAndIsSoldIsFalse(Long price);
}

• findById(Long id): 과일의 ID를 기반으로 과일을 조회한다.
  반환 타입으로 Optional을 사용하여 해당 ID에 대한 과일이 존재하지 않는 경우에도 NPE를 방지한다.

• findByNameAndIsSoldIsFalse(String name): 이름과 판매 여부가 'false'인 과일을 찾는다.
  여러 개의 Fruit이 조회될 수 있으므로 List로 반환한다.

• findByNameAndIsSoldIsTrue(String name): 이름과 판매 여부가 'true'인 과일을 찾고, List로 반환한다.

• countByName(String name): 특정 이름을 가진 과일의 수를 구하여 반환한다.

• findAllByPriceGreaterThanEqualAndIsSoldIsFalse(Long price): 가격이 특정 값 이상이고 판매 여부가 'false'인 과일을 찾고, List로 반환한다.

• findAllByPriceLessThanEqualAndIsSoldIsFalse(Long price): 가격이 특정 값 이하이고 판매 여부가 'false'인 과일을 찾고, List로 반환한다.

간단하게 쿼리 메소드를 정의하면 개발자는 복잡한 쿼리를 작성하지 않아도 되며, 높은 수준의 추상화를 통해 간편하게 데이터베이스와 상호 작용할 수 있게 된다.

⛳️ FruitServiceV2

import java.time.LocalDate;
import java.util.List;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

@Service
@RequiredArgsConstructor
public class FruitServiceV2 {
    private final FruitRepository fruitRepository;

    public void saveFruit(String name, LocalDate warehousingDate, long price) {
        fruitRepository.save(new Fruit(name, warehousingDate, price));
    }

    public void updateFruit(Long id) {
        Fruit fruit = fruitRepository.findById(id)
                .orElseThrow(() -> new IllegalArgumentException("해당하는 과일이 존재하지 않습니다."));

        fruit.changeStatus();
        fruitRepository.save(fruit);
    }

    public FruitAmountResponse getAmount(String name) {
        List<Fruit> notSalesFruits = fruitRepository.findByNameAndIsSoldIsFalse(name);
        List<Fruit> salesFruits = fruitRepository.findByNameAndIsSoldIsTrue(name);
        
        long salesAmount = salesFruits.stream().mapToLong(Fruit::getPrice).sum();
        long notSalesAmount = notSalesFruits.stream().mapToLong(Fruit::getPrice).sum();
        return new FruitAmountResponse(salesAmount, notSalesAmount);
    }

    public FruitCountResponse getSoldFruitCount(String name) {
        long count = fruitRepository.countByName(name);
        return new FruitCountResponse(count);
    }

    public FruitsInfoResponse getFruitInfo(FruitsInfoRequest request) {
        if ("GTE".equals(request.option())) {
            return getFruitsInfoByPriceGreaterThanEqual(request.price());
        }

        if ("LTE".equals(request.option())) {
            return getFruitsInfoByPriceLessThanEqual(request.price());
        }

        throw new IllegalArgumentException("과일 목록을 불러올 수 없습니다.");
    }

    private FruitsInfoResponse getFruitsInfoByPriceGreaterThanEqual(Long price) {
        List<Fruit> fruits = fruitRepository.findAllByPriceGreaterThanEqualAndIsSoldIsFalse(price);
        return FruitsInfoResponse.mapTo(fruits);
    }

    private FruitsInfoResponse getFruitsInfoByPriceLessThanEqual(Long price) {
        List<Fruit> fruits = fruitRepository.findAllByPriceLessThanEqualAndIsSoldIsFalse(price);
        return FruitsInfoResponse.mapTo(fruits);
    }
}

⛳️ FruitController

import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequiredArgsConstructor
public class FruitController {

    private final FruitServiceV2 fruitServiceV2;

    @PostMapping("/api/v1/fruit")
    public void saveFruit(@RequestBody FruitInfo request) {
        fruitServiceV2.saveFruit(request.name(), request.warehousingDate(), request.price());
    }

    @PutMapping("/api/v1/fruit")
    public void updateFruit(@RequestBody FruitIdRequest request) {
        fruitServiceV2.updateFruit(request.id());
    }

    @GetMapping("/api/v1/fruit/stat")
    public FruitAmountResponse getAmount(@RequestParam String name) {
        return fruitServiceV2.getAmount(name);
    }

    @GetMapping("/api/v1/fruit/count")
    public FruitCountResponse getSoldFruitCount(@RequestParam String name) {
        return fruitServiceV2.getSoldFruitCount(name);
    }

    @GetMapping("/api/v1/fruit/list")
    public FruitsInfoResponse getFruitInfo(FruitsInfoRequest request) {
        return fruitServiceV2.getFruitInfo(request);
    }
}

▶️ 실행결과

1️⃣ 문제 1

- 과일 정보 저장

- 판매 과일 기록

- 판매된 금액 & 미판매된 금액 조회

2️⃣ 문제 2

- 과일 개수 조회

3️⃣ 문제 3

- 판매되지 않은 특정 금액 이상 과일 목록 조회

- 판매되지 않은 특정 금액 이하 과일 목록 조회

⛳️ 개인 회고

Spring Data JPA는 간편하게 쿼리 메서드를 정의하여 데이터베이스 조작을 할 수 있어 개발 생산성을 향상할 수 있었다.

특히, Repository 인터페이스를 통해 SQL 쿼리 작성에 대한 부담이 줄어든 것 같다. 또한, Optional을 사용함으로써 예외 처리를 간편하게 할 수 있었고, 타입 세이프한 쿼리 메서드를 통해 런타임 에러를 방지할 수 있었다.