[WarmingUp 07] JPA 적용

문제1 Fruits에 JPA 적용하기

Entity

@Entity
public class Fruits {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id = null;

    @Column(nullable = false)
    private String name;
    private LocalDate warehousingDate;
    private Long price;
    private boolean isSold;

    protected Fruits() {}

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

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

    public Long getPrice() {
        return price;
    }
}

Controller

@RestController
@RequestMapping("/api/v1/fruit")
public class FruitController {
    private final FruitService fruitService;

    public FruitController(FruitService fruitService) {
        this.fruitService = fruitService;
    }

    @PostMapping
    public void saveFruit(@RequestBody FruitRequestDTO request){
        fruitService.saveFruit(request);
    }

    @PutMapping
    public void updateFruit(@RequestBody FruitRequestDTO request) {
        fruitService.updateFruit(request);
    }

    @GetMapping("/stat")
    public FruitSalesResponseDTO salesStat(@RequestParam("name") String name){
        return fruitService.salesStat(name);
    }

}

Service

@Service
public class FruitService {
    // private final FruitRepository fruitRepository;
    private final FruitJpaRepository fruitRepository;

    public FruitService(FruitJpaRepository fruitRepository) {
        this.fruitRepository = fruitRepository;
    }

    @Transactional
    public void saveFruit(FruitRequestDTO request){
        fruitRepository.save(new Fruits(request.getName(), request.getWarehousingDate(), request.getPrice()));
    }

    @Transactional
    public void updateFruit(FruitRequestDTO request){
        Fruits fruits = fruitRepository.findById(request.getId()).orElseThrow(IllegalAccessError::new);
        fruits.updateIsSold();
    }

    @Transactional
    public FruitSalesResponseDTO salesStat(String name){
        long salesAmount = fruitRepository.findAllByNameAndIsSold(name, true).stream()
                .mapToLong(Fruits::getPrice).sum();
        long notSalesAmount = fruitRepository.findAllByNameAndIsSold(name, false).stream()
                .mapToLong(Fruits::getPrice).sum();
        return new FruitSalesResponseDTO(salesAmount, notSalesAmount);
    }


}

Repository

public interface FruitJpaRepository extends JpaRepository<Fruits, Long> {
    List<Fruits> findAllByNameAndIsSold(String name, boolean isSold);
}

---

문제 2 과일 개수 세기

현재 사과 3개

Controller
    @GetMapping("/count")
    public FruitCountResponseDTO countFruits(@RequestParam("name") String name){
        return fruitService.countFruits(name);
    }

Service
    @Transactional
    public FruitCountResponseDTO countFruits(String name){
        return new FruitCountResponseDTO(fruitRepository.countByName(name));
    }
    
Repository
    long countByName(String name);

성공~

---

문제 3 특정 조건의 과일 목록 가져오기

현재 과일 목록

Controller
    @GetMapping("/list")
    public List<FruitListResponseDTO> fruitsList(@RequestParam("option") String option, @RequestParam("price") long price){
        return fruitService.fruitsList(option, price);
    }

Service
    @Transactional
    public List<FruitListResponseDTO> fruitsList(String option, long price){
        List<Fruits> fruits = null;

        if (option.equals("GTE")) {
            fruits = fruitRepository.findByPriceGreaterThanEqual(price);
        } else if (option.equals("LTE")) {
            fruits = fruitRepository.findByPriceLessThanEqual(price);
        }

        if(fruits == null) {
            throw new IllegalArgumentException("과일 없음");
        }

        return fruits.stream().filter(fruit -> !fruit.isSold())
                .map(fruit -> new FruitListResponseDTO(fruit.getName(), fruit.getPrice(), fruit.getWarehousingDate()))
                .collect(Collectors.toList());
    }
    
Repository
    List<Fruits> findByPriceGreaterThanEqual(long price);
    List<Fruits> findByPriceLessThanEqual(long price);

parameter: option=GTE&price=3000

parameter: option=LTE&price=3000