예외처리 심화

package com.example.board.exception;

import lombok.Getter;

/**
 * 우리 프로젝트 전용 커스텀 예외
 * RuntimeException을 상속 → throws 선언 없이 어디서든 던질 수 있음
 * message + httpStatus를 함께 담아서 GlobalExceptionHandler가 그대로 응답에 사용
 */
@Getter
public class CustomException extends RuntimeException {

    private final int httpStatus; // HTTP 상태코드 (400, 403, 404, 500...)

    // 메시지 + 상태코드만 받는 생성자
    public CustomException(String message, int httpStatus) {
        super(message); // RuntimeException(message) 호출 → getMessage()로 꺼낼 수 있음
        this.httpStatus = httpStatus;
    }
}

package com.example.board.exception;

import lombok.Getter;
import java.time.LocalDateTime;

/**
 * 에러 응답 DTO — GlobalExceptionHandler가 이 형식으로 JSON 응답을 만든다
 * 프론트(React)에서 error.response.data.status, .message 로 접근
 */
@Getter
public class ErrorResponse {

    private final int status;            // HTTP 상태코드
    private final String message;       // 에러 메시지 (사용자에게 보여줄 텍스트)
    private final LocalDateTime timestamp; // 발생 시각

    public ErrorResponse(int status, String message) {
        this.status = status;
        this.message = message;
        this.timestamp = LocalDateTime.now();
    }
}

package com.example.board.exception;

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

/**
 * @RestControllerAdvice = @ControllerAdvice + @ResponseBody
 * → 모든 Controller에서 발생하는 예외를 자동으로 가로채서 처리
 * → 리턴값을 JSON으로 자동 변환
 */
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

    // 1. 우리가 직접 만든 CustomException 처리
    @ExceptionHandler(CustomException.class)
    public ResponseEntity<ErrorResponse> handleCustomException(CustomException e) {
        log.warn("CustomException: status={}, message={}", e.getHttpStatus(), e.getMessage());
        return ResponseEntity
            .status(e.getHttpStatus())
            .body(new ErrorResponse(e.getHttpStatus(), e.getMessage()));
    }

    // 2. 예상 못한 서버 에러 (NullPointerException 등) 처리
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception e) {
        // error 레벨 — 예상 못한 에러는 스택트레이스 포함해서 로그
        log.error("Unexpected error", e);
        return ResponseEntity
            .status(500)
            .body(new ErrorResponse(500, "서버 오류가 발생했습니다."));
        // 클라이언트에는 내부 에러 메시지 노출 안 함 — 보안상 중요!
    }
}

@Service @RequiredArgsConstructor
public class BoardService {

    public BoardDto getDetail(Long id, User loginUser) {
        Board board = boardRepository.findById(id)
            .orElseThrow(() ->
                new CustomException("없는 게시글입니다.", 404)); // 404 Not Found
        // 조회수 증가 로직...
        return toDto(board);
    }

    @Transactional
    public void update(Long id, BoardDto boardDto, User user) {
        Board board = boardRepository.findById(id)
            .orElseThrow(() ->
                new CustomException("없는 게시글입니다.", 404));
        if (!board.getUser().getId().equals(user.getId()))
            throw new CustomException("수정 권한이 없습니다.", 403); // 403 Forbidden
        board.setTitle(boardDto.getTitle());
        board.setContent(boardDto.getContent());
    }

    @Transactional
    public void delete(Long id, User user) {
        Board board = boardRepository.findById(id)
            .orElseThrow(() ->
                new CustomException("없는 게시글입니다.", 404));
        if (!board.getUser().getId().equals(user.getId()))
            throw new CustomException("삭제 권한이 없습니다.", 403);
        boardRepository.delete(board);
    }

    // write(), getBoardList(), toDto() 는 변경 없음
}

public void register(UserDto userDto) {
    if (userRepository.existsByUsername(userDto.getUsername()))
        throw new CustomException("이미 사용중인 아이디입니다.", 409); // 409 Conflict
    if (userRepository.existsByNickname(userDto.getNickname()))
        throw new CustomException("이미 사용중인 닉네임입니다.", 409);
    // 나머지 로직 동일
}

public Map<String, String> login(String username, String password) {
    User user = userRepository.findByUsername(username)
        .orElseThrow(() ->
            new CustomException("아이디 또는 비밀번호가 틀렸습니다.", 401)); // 401 Unauthorized
    if (!bCryptPasswordEncoder.matches(password, user.getPassword()))
        throw new CustomException("아이디 또는 비밀번호가 틀렸습니다.", 401);
    String token = jwtUtil.createToken(user.getUsername(), user.getNickname(), user.getRole());
    return Map.of("token", token, "role", user.getRole());
}

@Transactional
public void deleteUser(Long userId) {
    User user = userRepository.findById(userId)
        .orElseThrow(() ->
            new CustomException("없는 유저입니다.", 404));
    boardRepository.deleteByUser(user);
    userRepository.delete(user);
}

@Transactional
public void deleteBoard(Long boardId) {
    Board board = boardRepository.findById(boardId)
        .orElseThrow(() ->
            new CustomException("없는 게시글입니다.", 404));
    boardRepository.delete(board);
}

@RestController @RequiredArgsConstructor
@RequestMapping("/api/board")
public class BoardController {
    private final BoardService boardService;

    @GetMapping("/list")
    public ResponseEntity<?> list(@RequestParam(defaultValue="0") int page) {
        return ResponseEntity.ok(boardService.getBoardList(page));
    }

    @GetMapping("/detail/{id}")
    public ResponseEntity<?> detail(
            @PathVariable Long id,
            @AuthenticationPrincipal CustomUserDetails userDetails) {
        return ResponseEntity.ok(boardService.getDetail(id, userDetails.getUser()));
    }

    @PostMapping("/write")
    public ResponseEntity<?> write(
            @RequestBody BoardDto boardDto,
            @AuthenticationPrincipal CustomUserDetails userDetails) {
        boardService.write(boardDto, userDetails.getUser());
        return ResponseEntity.ok(Map.of("message", "글쓰기 성공"));
    }

    @PutMapping("/edit/{id}")
    public ResponseEntity<?> edit(
            @PathVariable Long id,
            @RequestBody BoardDto boardDto,
            @AuthenticationPrincipal CustomUserDetails userDetails) {
        boardService.update(id, boardDto, userDetails.getUser());
        return ResponseEntity.ok(Map.of("message", "수정 성공"));
    }

    @DeleteMapping("/delete/{id}")
    public ResponseEntity<?> delete(
            @PathVariable Long id,
            @AuthenticationPrincipal CustomUserDetails userDetails) {
        boardService.delete(id, userDetails.getUser());
        return ResponseEntity.ok(Map.of("message", "삭제 성공"));
    }
}

@RestController @RequiredArgsConstructor
@RequestMapping("/api/user")
public class UserController {
    private final UserService userService;

    @PostMapping("/register")
    public ResponseEntity<?> register(@RequestBody UserDto userDto) {
        userService.register(userDto);
        return ResponseEntity.ok(Map.of("message", "회원가입 성공"));
    }

    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody UserDto userDto) {
        Map<String, String> result = userService.login(
            userDto.getUsername(), userDto.getPassword()
        );
        return ResponseEntity.ok(result);
    }
}
// AdminController도 동일하게 try/catch 제거