프로젝트 회고 (25. 06 ~ 25. 08)

@RestControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(DomainException.class) public ResponseEntity<ApiResponse<?>> handleDomainException(DomainException e) { return ResponseEntity.badRequest().body(ApiResponse.fail(e.getMessage())); } @ExceptionHandler(Exception.class) public ResponseEntity<ApiResponse<?>> handleException(Exception e) { return ResponseEntity.internalServerError().body(ApiResponse.fail("예상치 못한 오류 발생")); } }

@Getter @Builder public class ApiResponse<T> { private boolean success; private String message; private T data; public static <T> ApiResponse<T> ok(T data) { return ApiResponse.<T>builder() .success(true) .message("success") .data(data) .build(); } public static <T> ApiResponse<T> fail(String message) { return ApiResponse.<T>builder() .success(false) .message(message) .build(); } }

// ❌ 나쁜 예시 @PostMapping("/books") public ResponseEntity<ApiResponse<BookResponse>> createBook(@RequestBody BookRequest request) { Book book = new Book(request.getTitle(), request.getAuthor()); bookRepository.save(book); return ResponseEntity.ok(ApiResponse.ok(BookResponse.fromEntity(book))); } // ✅ 좋은 예시 @PostMapping("/books") public ResponseEntity<ApiResponse<BookResponse>> createBook(@RequestBody BookRequest request) { return ResponseEntity.ok(ApiResponse.ok(bookService.createBook(request))); }

@Getter @Builder public class BookResponse { private String title; private String author; public static BookResponse fromEntity(Book book) { return BookResponse.builder() .title(book.getTitle()) .author(book.getAuthor()) .build(); } }

@Service @RequiredArgsConstructor public class BookCacheService { private final RedisTemplate<String, Object> redisTemplate; public void cacheBook(String key, BookResponse book) { redisTemplate.opsForValue().set(key, book, 10, TimeUnit.MINUTES); } public BookResponse getBook(String key) { return (BookResponse) redisTemplate.opsForValue().get(key); } }

public AuthResponse login(AuthRequest request) { Member member = memberRepository.findByUsername(request.getUsername()) .orElseThrow(() -> new AuthException("존재하지 않는 회원이다")); // 비밀번호 체크 if (!passwordEncoder.matches(request.getPassword(), member.getPassword())) { throw new AuthException("비밀번호가 일치하지 않는다"); } String accessToken = jwtTokenProvider.createAccessToken(member.getId().toString()); String refreshToken = jwtTokenProvider.createRefreshToken(); redisTemplate.opsForValue().set("RT:" + member.getId(), refreshToken, 7, TimeUnit.DAYS); return new AuthResponse(accessToken, refreshToken); }

@Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); }

CREATE INDEX idx_books_title ON books(title);

@Entity @Getter @NoArgsConstructor(access = AccessLevel.PROTECTED) public class BaseTime { @CreatedDate private Instant createdAt; @LastModifiedDate private Instant updatedAt; }

@Getter @NoArgsConstructor public class BookRequest { @NotBlank(message = "제목은 필수 값이다") private String title; @NotBlank(message = "저자는 필수 값이다") private String author; @Builder public BookRequest(String title, String author) { this.title = title; this.author = author; } }

@Getter @NoArgsConstructor @AllArgsConstructor @Builder public class MemberResponse { private String username; private String nickName; }

@ExtendWith(MockitoExtension.class) class ChatMessageServiceTest { @Mock ChatMessageRepository chatMessageRepository; @Mock MemberRepository memberRepository; @Mock RedisPublisher redisPublisher; @Mock ObjectMapper objectMapper; @Mock ChatRoomService chatRoomService; @InjectMocks ChatMessageService chatMessageService; @Test @DisplayName("TALK: 저장 후 Redis로 브로드캐스트하고 DTO 반환") void process_TALK_publishAndReturn() throws Exception { // given ChatMessageSendRequestDto dto = talkReq("room-1", "u-1", "hello"); Member sender = mock(Member.class); given(sender.getNickName()).willReturn("Neo"); given(memberRepository.findById("u-1")).willReturn(Optional.of(sender)); // save 호출 시 저장된 엔티티 그대로 반환 given(chatMessageRepository.save(any(ChatMessage.class))) .willAnswer(inv -> inv.getArgument(0)); given(objectMapper.writeValueAsString(any(ChatMessageDto.class))) .willReturn("{json}"); // when ChatMessageDto result = chatMessageService.processMessage(dto); // then assertThat(result).isNotNull(); assertThat(result.getSenderNickname()).isEqualTo("Neo"); then(redisPublisher).should().publish(eq("room-1"), eq("{json}")); then(chatRoomService).should(never()).joinRoom(anyString(), anyString()); then(chatRoomService).should(never()).leaveRoom(anyString(), anyString()); } }

// ✅ Java 기반 DTO @Getter @NoArgsConstructor @AllArgsConstructor @Builder public class ChatRequest { private String roomId; private String message; }

// ❌ 나쁜 예시 public void createBook(Book book) { bookRepository.save(book); } // ✅ 좋은 예시 public void createBook(BookRequest request) { Book book = Book.builder() .title(request.getTitle()) .author(request.getAuthor()) .build(); bookRepository.save(book); }

// Book과 Author를 fetch join @Query("SELECT b FROM Book b JOIN FETCH b.author WHERE b.id = :id") Optional<Book> findBookWithAuthor(@Param("id") Long id); // Projection DTO 활용 @Query(""" SELECT new org.com.moodbook.book.dto.BookResponse( b.id, b.isbn13, b.title, b.author, b.publisher, b.pubDate, b.reputation, b.coverImage, b.description, b.categoryName, b.createdAt, coalesce(bc.viewCount, 0) ) FROM Book b LEFT JOIN BookCount bc ON b.id = bc.book.id ORDER BY b.pubDate DESC """) Page<BookResponse> findAllByCreatedAt(Pageable pageable); /* N + 1 문제 처리 */ @EntityGraph(attributePaths = "bookCount") List<Book> findByIsbn13In(Collection<String> isbn13); /* N + 1 문제 처리 */ @Query("SELECT b FROM Book b LEFT JOIN FETCH b.bookCount") List<Book> findAllBooks();

// HashMap 활용하여 사용자별 도서 추천 캐싱 private final Map<String, List<Book>> userRecommendCache = new HashMap<>(); public List<Book> getUserRecommendations(String userId) { return userRecommendCache.computeIfAbsent(userId, id -> loadRecommendations(id)); }

// ❌ 나쁜 예시 @Service public class CommonService { public void createBook(BookRequest request) { /* ... */ } public void login(AuthRequest request) { /* ... */ } public void sendChat(ChatRequest request) { /* ... */ } } // ✅ 좋은 예시 @Service public class BookService { /* 도서 관련 로직 */ } @Service public class AuthService { /* 인증 관련 로직 */ } @Service public class ChatService { /* 채팅 관련 로직 */ }

@Entity public class Book { @ManyToOne(fetch = FetchType.LAZY) private Author author; } @Query("SELECT b FROM Book b JOIN FETCH b.author WHERE b.id = :id") Optional<Book> findBookWithAuthor(@Param("id") Long id);

@Getter @Builder public class BookResponse { private String title; private String author; public static BookResponse fromEntity(Book book) { return BookResponse.builder() .title(book.getTitle()) .author(book.getAuthor().getName()) .build(); } }

@Service @RequiredArgsConstructor public class BookService { private final BookRepository bookRepository; @Transactional(readOnly = true) public BookResponse getBook(Long id) { Book book = bookRepository.findById(id) .orElseThrow(() -> new NotFoundException("존재하지 않는 책")); return BookResponse.fromEntity(book); } }

@Getter @NoArgsConstructor public class AuthRequest { @NotBlank(message = "아이디는 필수 값이다") private String username; @NotBlank(message = "비밀번호는 필수 값이다") private String password; }

// 무상태 인증 (Spring Security Filter) public class JwtTokenFilter extends OncePerRequestFilter { @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { String token = resolveToken(request); if (token != null && jwtTokenProvider.validateToken(token)) { Authentication auth = jwtTokenProvider.getAuthentication(token); SecurityContextHolder.getContext().setAuthentication(auth); } filterChain.doFilter(request, response); } }

redisTemplate.opsForValue() .set("RT:" + member.getId(), refreshToken, 7, TimeUnit.DAYS);

@ConfigurationProperties(prefix = "jwt") @Getter @Setter public class JwtProperties { private String secret; private long accessTokenValidity; private long refreshTokenValidity; }

jwt: secret: ${JWT_SECRET} access-token-validity: 3600 refresh-token-validity: 604800

@Getter @NoArgsConstructor public class BookRequest { private String title; private String author; public Book toEntity() { return Book.builder() .title(title) .author(author) .build(); } } @Getter @Builder public class BookResponse { private String title; private String author; public static BookResponse fromEntity(Book book) { return BookResponse.builder() .title(book.getTitle()) .author(book.getAuthor()) .build(); } }

@Getter @Builder public class MemberResponse { private String username; private String nickName; public static MemberResponse fromEntity(Member member) { return MemberResponse.builder() .username(member.getUsername()) .nickName(member.getNickName()) .build(); } }

// ❌ 불필요한 인터페이스 public interface BookService { BookResponse getBook(Long id); } @Service public class BookServiceImpl implements BookService { ... } // ✅ 단일 클래스 @Service @RequiredArgsConstructor public class BookService { public BookResponse getBook(Long id) { ... } }

@Entity @Getter @NoArgsConstructor(access = AccessLevel.PROTECTED) public class Member { @Id @GeneratedValue private Long id; private String username; private String password; @Builder private Member(String username, String password) { this.username = username; this.password = password; } }

@Transactional public void updateNickName(Long memberId, String newNickName) { Member member = memberRepository.findById(memberId) .orElseThrow(() -> new NotFoundException("존재하지 않는 회원")); member.changeNickName(newNickName); // 엔티티 내부 메서드 }

@Getter @MappedSuperclass @EntityListeners(AuditingEntityListener.class) public abstract class BaseTime { @CreatedDate private Instant createdAt; @LastModifiedDate private Instant updatedAt; }

@NoArgsConstructor(access = AccessLevel.PROTECTED) // ✅ 필요한 경우만 public class Book { ... }

@GetMapping("/me") public ApiResponse<MemberResponse> getCurrentUser(@AuthenticationPrincipal CustomUserDetail userDetail) { return ApiResponse.ok(MemberResponse.fromEntity(userDetail.getMember())); }

@Getter public class CustomUserDetail implements UserDetails { private final Member member; public CustomUserDetail(Member member) { this.member = member; } @Override public Collection<? extends GrantedAuthority> getAuthorities() { return List.of(new SimpleGrantedAuthority("ROLE_USER")); } @Override public String getPassword() { return member.getPassword(); } @Override public String getUsername() { return member.getUsername(); } }