1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 컴파일 에러! — IOException을 반드시 처리해야 함
public String readFile(String path) {
    BufferedReader reader = new BufferedReader(new FileReader(path)); // 컴파일 에러
    return reader.readLine();
}

// 방법 1: try-catch로 직접 처리
public String readFile(String path) {
    try {
        BufferedReader reader = new BufferedReader(new FileReader(path));
        return reader.readLine();
    } catch (IOException e) {
        throw new RuntimeException("파일 읽기 실패: " + path, e);
    }
}

// 방법 2: throws로 호출자에게 위임
public String readFile(String path) throws IOException {
    BufferedReader reader = new BufferedReader(new FileReader(path));
    return reader.readLine();
}

1
2
3
4
5
6
7
8
9
10
11
12
// 컴파일은 되지만 실행 시 예외 발생
public void process(String name) {
    System.out.println(name.length()); // name이 null이면 NullPointerException
}

// 방어적 코드로 예방
public void process(String name) {
    if (name == null) {
        throw new IllegalArgumentException("name은 null일 수 없습니다");
    }
    System.out.println(name.length());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 문제 1: 의미 없는 catch — 잡아놓고 아무것도 안 함
try {
    doSomething();
} catch (SomeCheckedException e) {
    // 뭘 해야 할지 모르겠어서 그냥 무시...
}

// 문제 2: throws 전파 지옥 — 메서드 시그니처 오염
public void a() throws IOException, SQLException { b(); }
public void b() throws IOException, SQLException { c(); }
public void c() throws IOException, SQLException { /* 실제 발생 */ }
// → 모든 호출 체인에 throws가 전파됨

// 문제 3: 캡슐화 위반 — 하위 구현의 예외가 상위로 노출
public interface UserRepository {
    User findById(Long id) throws SQLException; // 구현 기술이 인터페이스에 노출!
}

1
2
3
// Spring의 DataAccessException → RuntimeException의 하위 클래스
// JPA의 PersistenceException → RuntimeException의 하위 클래스
// → 개발자가 "필요한 곳에서만" 선택적으로 catch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public void processFile(String path) {
    FileInputStream fis = null;
    try {
        fis = new FileInputStream(path);
        // 파일 처리 로직
        int data = fis.read();
    } catch (FileNotFoundException e) {
        // 파일이 없을 때 처리
        log.error("파일을 찾을 수 없습니다: {}", path, e);
    } catch (IOException e) {
        // I/O 에러 처리 (더 넓은 범위)
        log.error("파일 읽기 실패", e);
    } finally {
        // 예외 발생 여부와 무관하게 항상 실행
        if (fis != null) {
            try {
                fis.close();
            } catch (IOException e) {
                log.error("파일 닫기 실패", e);
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
// 컴파일 에러! IOException이 FileNotFoundException보다 넓으므로 아래에 와야 함
try { ... }
catch (IOException e) { ... }           // 넓은 범위가 먼저 오면
catch (FileNotFoundException e) { ... } // 여기에 절대 도달 못함 (dead code)

// 올바른 순서
try { ... }
catch (FileNotFoundException e) { ... } // 좁은 범위 먼저
catch (IOException e) { ... }           // 넓은 범위 나중에

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// before: try-finally (장황하고, close()에서도 예외 처리 필요)
BufferedReader reader = null;
try {
    reader = new BufferedReader(new FileReader(path));
    return reader.readLine();
} finally {
    if (reader != null) {
        try { reader.close(); } catch (IOException e) { /* ... */ }
    }
}

// after: try-with-resources (깔끔!)
try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
    return reader.readLine();
} // reader.close()가 자동 호출됨

1
2
3
4
5
6
7
8
9
10
// 여러 리소스도 가능 (세미콜론으로 구분)
try (
    Connection conn = dataSource.getConnection();
    PreparedStatement stmt = conn.prepareStatement(sql);
    ResultSet rs = stmt.executeQuery()
) {
    while (rs.next()) {
        // 결과 처리
    }
} // rs → stmt → conn 순서로 자동 close (선언 역순)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class MyResource implements AutoCloseable {
    public void doWork() {
        System.out.println("작업 수행");
    }

    @Override
    public void close() {
        System.out.println("리소스 정리");
    }
}

try (MyResource resource = new MyResource()) {
    resource.doWork();
} // "리소스 정리" 자동 호출

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// before: 같은 처리를 하는 catch가 여러 개
try {
    doSomething();
} catch (IllegalArgumentException e) {
    log.error("에러 발생", e);
    throw e;
} catch (IllegalStateException e) {
    log.error("에러 발생", e);
    throw e;
}

// after: 파이프(|)로 묶기
try {
    doSomething();
} catch (IllegalArgumentException | IllegalStateException e) {
    log.error("에러 발생", e);
    throw e;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// throw: 예외를 직접 던짐 (메서드 내부)
public void withdraw(long amount) {
    if (amount <= 0) {
        throw new IllegalArgumentException("출금액은 0보다 커야 합니다");
    }
    if (amount > this.balance) {
        throw new InsufficientBalanceException("잔액 부족");
    }
    this.balance -= amount;
}

// throws: 이 메서드가 해당 예외를 던질 수 있음을 선언 (메서드 시그니처)
public byte[] readFile(String path) throws IOException {
    return Files.readAllBytes(Path.of(path));
}

1
2
3
4
5
6
7
8
9
10
11
// 나쁜 예: 범용 예외로 모든 상황을 처리
throw new RuntimeException("사용자를 찾을 수 없습니다");
throw new RuntimeException("잔액이 부족합니다");
throw new RuntimeException("이미 처리된 주문입니다");
// → catch에서 메시지 문자열로 구분해야 함 (취약하고 유지보수 어려움)

// 좋은 예: 상황별 커스텀 예외
throw new UserNotFoundException(userId);
throw new InsufficientBalanceException(balance, amount);
throw new OrderAlreadyProcessedException(orderId);
// → 타입으로 구분 가능, 각 예외에 맞는 정보를 담을 수 있음

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 1. ErrorCode 정의
@Getter
@AllArgsConstructor
public enum ErrorCode {

    // 400 Bad Request
    INVALID_INPUT(HttpStatus.BAD_REQUEST, "잘못된 입력값입니다"),
    DUPLICATE_EMAIL(HttpStatus.BAD_REQUEST, "이미 사용 중인 이메일입니다"),

    // 401 Unauthorized
    UNAUTHORIZED(HttpStatus.UNAUTHORIZED, "인증이 필요합니다"),
    INVALID_TOKEN(HttpStatus.UNAUTHORIZED, "유효하지 않은 토큰입니다"),

    // 403 Forbidden
    ACCESS_DENIED(HttpStatus.FORBIDDEN, "접근 권한이 없습니다"),

    // 404 Not Found
    USER_NOT_FOUND(HttpStatus.NOT_FOUND, "사용자를 찾을 수 없습니다"),
    ORDER_NOT_FOUND(HttpStatus.NOT_FOUND, "주문을 찾을 수 없습니다"),

    // 409 Conflict
    ORDER_ALREADY_PROCESSED(HttpStatus.CONFLICT, "이미 처리된 주문입니다"),

    // 500 Internal Server Error
    INTERNAL_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, "서버 내부 오류가 발생했습니다");

    private final HttpStatus status;
    private final String message;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 2. 공통 비즈니스 예외 (최상위)
@Getter
public class BusinessException extends RuntimeException {

    private final ErrorCode errorCode;

    public BusinessException(ErrorCode errorCode) {
        super(errorCode.getMessage());
        this.errorCode = errorCode;
    }

    public BusinessException(ErrorCode errorCode, String detailMessage) {
        super(detailMessage);
        this.errorCode = errorCode;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 3. 구체적인 예외 클래스
public class EntityNotFoundException extends BusinessException {

    public EntityNotFoundException(ErrorCode errorCode) {
        super(errorCode);
    }
}

public class UserNotFoundException extends EntityNotFoundException {

    public UserNotFoundException(Long userId) {
        super(ErrorCode.USER_NOT_FOUND);
    }
}

public class DuplicateException extends BusinessException {

    public DuplicateException(ErrorCode errorCode) {
        super(errorCode);
    }
}

public class InvalidInputException extends BusinessException {

    public InvalidInputException(ErrorCode errorCode) {
        super(errorCode);
    }

    public InvalidInputException(ErrorCode errorCode, String detail) {
        super(errorCode, detail);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 4. 서비스에서 사용
@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;

    public User findById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new UserNotFoundException(id));
    }

    public User register(RegisterRequest request) {
        if (userRepository.existsByEmail(request.getEmail())) {
            throw new DuplicateException(ErrorCode.DUPLICATE_EMAIL);
        }
        return userRepository.save(request.toEntity());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@RestController
@RequestMapping("/api/users")
public class UserController {

    @GetMapping("/{id}")
    public UserResponse getUser(@PathVariable Long id) {
        return userService.findById(id);
    }

    // 이 컨트롤러 내에서 발생하는 UserNotFoundException만 처리
    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFound(UserNotFoundException e) {
        ErrorResponse response = new ErrorResponse(e.getErrorCode());
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(response);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

    // 1. 비즈니스 예외 처리 (우리가 정의한 예외)
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException e) {
        log.warn("Business exception: {}", e.getMessage());
        ErrorCode code = e.getErrorCode();
        return ResponseEntity
                .status(code.getStatus())
                .body(new ErrorResponse(code.name(), e.getMessage()));
    }

    // 2. 요청 데이터 검증 실패 (@Valid)
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidation(MethodArgumentNotValidException e) {
        String message = e.getBindingResult().getFieldErrors().stream()
                .map(error -> error.getField() + ": " + error.getDefaultMessage())
                .collect(Collectors.joining(", "));

        return ResponseEntity
                .status(HttpStatus.BAD_REQUEST)
                .body(new ErrorResponse("INVALID_INPUT", message));
    }

    // 3. 잘못된 HTTP 메서드
    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    public ResponseEntity<ErrorResponse> handleMethodNotSupported(
            HttpRequestMethodNotSupportedException e) {
        return ResponseEntity
                .status(HttpStatus.METHOD_NOT_ALLOWED)
                .body(new ErrorResponse("METHOD_NOT_ALLOWED", e.getMessage()));
    }

    // 4. 타입 미스매치 (PathVariable, RequestParam)
    @ExceptionHandler(MethodArgumentTypeMismatchException.class)
    public ResponseEntity<ErrorResponse> handleTypeMismatch(
            MethodArgumentTypeMismatchException e) {
        String message = e.getName() + "의 타입이 올바르지 않습니다";
        return ResponseEntity
                .status(HttpStatus.BAD_REQUEST)
                .body(new ErrorResponse("TYPE_MISMATCH", message));
    }

    // 5. 최후의 방어선 — 예상하지 못한 예외
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleUnexpected(Exception e) {
        log.error("Unexpected exception", e);  // 스택 트레이스 전체 로깅
        return ResponseEntity
                .status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(new ErrorResponse("INTERNAL_ERROR", "서버 내부 오류가 발생했습니다"));
        // 클라이언트에게는 내부 정보 노출하지 않음!
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
// ErrorResponse DTO
@Getter
@AllArgsConstructor
public class ErrorResponse {
    private String code;
    private String message;

    public ErrorResponse(ErrorCode errorCode) {
        this.code = errorCode.name();
        this.message = errorCode.getMessage();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Service 계층 예시 — 예외 변환
@Service
@RequiredArgsConstructor
public class OrderService {

    private final OrderRepository orderRepository;
    private final UserRepository userRepository;

    @Transactional
    public OrderResponse createOrder(Long userId, OrderCreateRequest request) {
        // 1. 존재하지 않는 사용자 → 비즈니스 예외
        User user = userRepository.findById(userId)
                .orElseThrow(() -> new UserNotFoundException(userId));

        // 2. 비즈니스 규칙 검증 → 비즈니스 예외
        if (request.getAmount() <= 0) {
            throw new InvalidInputException(
                    ErrorCode.INVALID_INPUT, "주문 금액은 0보다 커야 합니다");
        }

        // 3. 중복 주문 검증
        if (orderRepository.existsByUserIdAndProductId(userId, request.getProductId())) {
            throw new DuplicateException(ErrorCode.ORDER_ALREADY_PROCESSED);
        }

        Order order = Order.create(user, request);
        return OrderResponse.from(orderRepository.save(order));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

    // 비즈니스 예외: WARN 레벨 (예상된 상황)
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusiness(BusinessException e) {
        log.warn("[{}] {}", e.getErrorCode(), e.getMessage());
        // 스택 트레이스 불필요 — 예상된 예외이므로
        return createResponse(e.getErrorCode());
    }

    // 시스템 예외: ERROR 레벨 + 스택 트레이스
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleUnexpected(Exception e) {
        log.error("Unexpected error occurred", e);
        // 스택 트레이스 포함 — 디버깅에 필수
        return createResponse(ErrorCode.INTERNAL_ERROR);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// ❌ 안티패턴 1: 예외 삼키기 (swallowing)
try {
    riskyOperation();
} catch (Exception e) {
    // 아무것도 안 함 → 장애 원인을 절대 찾을 수 없음
}

// ❌ 안티패턴 2: 원인 예외 누락
try {
    parseData(input);
} catch (ParseException e) {
    throw new BusinessException(ErrorCode.INVALID_INPUT);
    // e를 전달하지 않음 → 원래 어디서 터졌는지 알 수 없음
}
// ✅ 올바른 방법
catch (ParseException e) {
    throw new BusinessException(ErrorCode.INVALID_INPUT, e); // cause 전달
}

// ❌ 안티패턴 3: catch 후 무조건 printStackTrace()
catch (Exception e) {
    e.printStackTrace(); // 표준 에러 출력 → 로그 시스템 우회, 운영에서 추적 불가
}
// ✅ 올바른 방법
catch (Exception e) {
    log.error("처리 실패", e); // SLF4J 로거 사용
}

// ❌ 안티패턴 4: 무의미한 re-throw
try {
    doSomething();
} catch (IOException e) {
    throw e; // 잡아놓고 다시 던지기만 함 → try-catch가 의미 없음
}

// ❌ 안티패턴 5: 예외로 비즈니스 로직 제어
public boolean isValidEmail(String email) {
    try {
        new InternetAddress(email).validate();
        return true;
    } catch (AddressException e) {
        return false; // 예외를 if-else처럼 사용 → 성능 저하, 의도 불명확
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
// JDBC: SQLException(Checked)을 직접 처리해야 함
try {
    jdbcTemplate.update(sql);
} catch (SQLException e) {
    // DB마다 에러 코드가 다름 (MySQL: 1062, PostgreSQL: 23505)
}

// Spring: DataAccessException(Unchecked)으로 추상화
try {
    jdbcTemplate.update(sql);
} catch (DuplicateKeyException e) {
    // DB가 뭐든 동일한 예외 타입
}