💫 Java

🏁 Movie-Review with JPA and Pageable

🧠 model

🧠 Movie

@Entity
@Table(name="movies")
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class Movie {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String title;

    private Integer releaseYear;

    @OneToMany(mappedBy = "movie", cascade = CascadeType.ALL, orphanRemoval = true) 📌
    @JsonManagedReference 📌
    private List<Review> reviews = new ArrayList<>();
}

포인트	설명
@OneToMany(mappedBy = "movie")	Movie 1개는 여러 Review를 가질 수 있다는 의미. mappedBy는 Review 클래스의 movie 필드를 참조하여 연관 관계의 주인이 아님을 명시. 즉, DB의 외래 키는 Review 테이블에 생성됨.
orphanRemoval = true	reviews 리스트에서 항목을 제거하면 DB에서도 자동 삭제됨. 단, CascadeType.ALL이 함께 있어야 적용됨.
cascade = CascadeType.ALL	Movie 엔티티의 생명주기 변화(저장, 수정, 삭제 등)를 Review에도 전파함. 예: Movie 삭제 시 연결된 Review도 함께 삭제됨.
@JsonManagedReference	직렬화 시 순환 참조를 방지하기 위한 어노테이션. 이 쪽이 직렬화 대상이며, Review의 @JsonBackReference와 짝을 이룸.

🧠 Review

@Entity
@Table(name = "reviews")
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class Review {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String reviewer;

    @Min(1)
    @Max(5)
    private Integer rating;

    @Column(columnDefinition = "TEXT")
    private String comment;

    @ManyToOne(fetch = FetchType.LAZY) 📌
    @JoinColumn(name = "movie_id", nullable = false) 📌
    @JsonBackReference 📌
    private Movie movie;
}

포인트	설명
@ManyToOne(fetch = FetchType.LAZY)	여러 리뷰는 하나의 영화에 속한다는 관계. 외래 키가 Review 테이블에 존재함. LAZY 설정 시 실제 사용할 때만 Movie 엔티티를 DB에서 조회함.
@JoinColumn(name = "movie_id", nullable = false)	Review 테이블에 생성될 외래 키 컬럼 이름을 지정. nullable = false로 필수 관계임을 명시.
@JsonBackReference	직렬화 시 무한 루프 방지를 위해 사용. @JsonManagedReference가 있는 Movie 쪽만 JSON 응답에 포함됨.

---

📌 직렬화(Serialization)란?

• 객체(Object)를 바이트(byte) 형태로 변환하는 과정을 의미.
  즉, 객체를 네트워크 전송이나 파일 저장이 가능한 형태로 만드는 것.
• 반대 개념: 역직렬화(Deserialization)
  바이트나 JSON 등의 데이터를 다시 객체로 변환하는 것

---

📦 dto

📦 MovieDto

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class MovieDto {
    @NotBlank(message = "제목을 입력하세요")
    private String title;

    @NotNull(message = "개봉 연도를 입력하세요")
    private Integer releaseYear;
}

📦 ReviewDto

@Getter
@Setter
public class ReviewDto {
    private String reviewer;

    @NotNull(message = "평점을 입력하세요")
    @Min(value = 1, message = "평점은 1~5 사이여야 합니다")
    @Max(value = 5, message = "평점은 1~5 사이여야 합니다")
    private Integer rating;

    @NotBlank(message = "댓글을 입력하세요")
    private String comment;
}

---

🧩 service

🧩 MovieService

@Service
@RequiredArgsConstructor
@Transactional 📌
public class MovieService {
    private final MovieRepository movieRepository;

    public Page<Movie> getAll(Pageable pageable) {
        return movieRepository.findAll(pageable);
    }

    public Movie getById(Long id) {
        return movieRepository.findById(id)
                .orElseThrow(() -> new NoSuchElementException("영화가 없습니다: " + id));
    }

    public Movie create(Movie movie) {
        return movieRepository.save(movie);
    }

    public Movie update(Long id, Movie movie) {
        Movie existMovie = getById(id); 📌

        existMovie.setTitle(movie.getTitle());
        existMovie.setReleaseYear(movie.getReleaseYear());

        return movieRepository.save(existMovie);
    }

    public void delete(Long id) {
        movieRepository.delete(getById(id)); 📌
    }
}

포인트	설명
@Transactional 클래스 단위 적용	전체 메서드에서 트랜잭션이 자동 적용되어, 예외 발생 시 롤백 처리됨.
getById() 내부 재사용	update나 delete에서 중복 코드를 방지하고 예외 처리 일관성을 유지.

🧩 ReviewService

@Service
@RequiredArgsConstructor
@Transactional
public class ReviewService {
    private final ReviewRepository reviewRepository;
    private final MovieRepository movieRepository;

    public Page<Review> getByMovie(Long movieId, Pageable pageable) {
        return reviewRepository.findByMovieId(movieId, pageable);
    }

    public Review getById(Long id) {
        return reviewRepository.findById(id)
                .orElseThrow(() -> new NoSuchElementException("리뷰가 없습니다: " + id));
    }

    public Review create(Long movieId, Review review) {
        Movie movie = movieRepository.findById(movieId)
                .orElseThrow(() -> new NoSuchElementException("리뷰가 없습니다: " + movieId));

        review.setMovie(movie); 📌

        return reviewRepository.save(review);
    }

    public Review update(Long id, Review review) { 📌
        Review existReview = getById(id);

        existReview.setReviewer(review.getReviewer());
        existReview.setRating(review.getRating());
        existReview.setComment(review.getComment());

        return reviewRepository.save(existReview);
    }

    public void delete(Long id) {
        reviewRepository.delete(getById(id));
    }
}

포인트	설명
review.setMovie(movie)	리뷰 등록 시 반드시 부모 엔티티(Movie)를 설정해야 외래 키가 제대로 저장됨.
Review update(...) 방식	부분 수정이 아닌 전체 필드 교체 방식이므로, null 필드가 입력되면 기존 값이 지워질 수 있음.

---

📡 controller

📡 MovieController

@RestController
@RequestMapping("/api/movies")
@RequiredArgsConstructor
public class MovieController {
    private final MovieService movieService;

    @GetMapping
    public Page<Movie> list(
           @RequestParam(defaultValue = "0") int page,
           @RequestParam(defaultValue = "10") int size
    ) {
        Pageable pageable = PageRequest.of(page, size, Sort.by("id").descending());
        return movieService.getAll(pageable);
    }

    @GetMapping("/{id}")
    public Movie get(@PathVariable Long id) {
        return movieService.getById(id);
    }

    @PostMapping
    public Movie create(@Valid @RequestBody MovieDto movieDto) {
        Movie movie = new Movie();

        movie.setTitle(movieDto.getTitle());
        movie.setReleaseYear(movieDto.getReleaseYear());

        return movieService.create(movie);
    }

    @PutMapping("/{id}")
    public Movie update(@PathVariable Long id, @Valid @RequestBody MovieDto movieDto) {
        Movie movie = new Movie();

        movie.setTitle(movieDto.getTitle());
        movie.setReleaseYear(movieDto.getReleaseYear());

        return movieService.update(id, movie);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> delete(@PathVariable Long id) {
        movieService.delete(id);

        return ResponseEntity.noContent().build();
    }
}

📡 ReviewController

@RestController
@RequiredArgsConstructor
public class ReviewController {
    private final ReviewService reviewService;

    @GetMapping("/api/movies/{movieId}/reviews")
    public Page<Review> listByMovie(
            @PathVariable Long movieId,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size
    ) {
        Pageable pageable = PageRequest.of(page, size, Sort.by("id").descending());
        return reviewService.getByMovie(movieId, pageable);
    }

    @PostMapping("/api/movies/{movieId}/reviews")
    public Review add(
            @PathVariable Long movieId,
            @Valid @RequestBody ReviewDto reviewDto
    ) {
        Review review = new Review();
        review.setReviewer(reviewDto.getReviewer());
        review.setRating(reviewDto.getRating());
        review.setComment(reviewDto.getComment());

        return reviewService.create(movieId, review);
    }

    @PutMapping("/api/reviews/{id}")
    public Review update(@PathVariable Long id, @Valid @RequestBody ReviewDto ReviewDto) {
        Review review = new Review();

        review.setReviewer(ReviewDto.getReviewer());
        review.setRating(ReviewDto.getRating());
        review.setComment(ReviewDto.getComment());

        return reviewService.update(id, review);
    }

    @DeleteMapping("/api/reviews/{id}")
    public ResponseEntity<Void> delete(@PathVariable Long id) {
        reviewService.delete(id);

        return ResponseEntity.noContent().build();
    }
}