Checked Exception vs Unchecked Exception – 자바 예외 처리 핵심 차이

java.lang.Throwable
├── java.lang.Error                    ← 복구 불가 시스템 오류
│   ├── OutOfMemoryError               (JVM 메모리 고갈)
│   ├── StackOverflowError             (무한 재귀 등)
│   └── VirtualMachineError
│
└── java.lang.Exception                ← 애플리케이션 수준 예외
    │
    ├── [Checked Exception]            ← 컴파일러가 처리 강제
    │   ├── IOException
    │   │   ├── FileNotFoundException
    │   │   └── SocketException
    │   ├── SQLException
    │   ├── ClassNotFoundException
    │   └── InterruptedException
    │
    └── java.lang.RuntimeException     ← [Unchecked Exception]
        ├── NullPointerException       (null 참조 접근)
        ├── ArrayIndexOutOfBoundsException
        ├── IllegalArgumentException
        ├── IllegalStateException
        ├── NumberFormatException
        ├── ClassCastException
        └── ArithmeticException        (0으로 나누기 등)

import java.io.*;

public class FileReaderExample {

    public String readFile(String path) {
        // try-catch 없이 FileReader를 쓰면 컴파일 에러 발생
        // FileNotFoundException은 Checked Exception이기 때문
        try {
            BufferedReader reader = new BufferedReader(new FileReader(path));
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line).append("\n");
            }
            reader.close();
            return sb.toString();
        } catch (FileNotFoundException e) {
            System.err.println("파일을 찾을 수 없습니다: " + path);
            return "";           // 기본값 반환으로 복구 시도
        } catch (IOException e) {
            System.err.println("파일 읽기 오류: " + e.getMessage());
            return "";
        }
    }
}

import java.io.*;

public class FileReaderExample {

    // throws로 선언하면 이 메서드를 호출하는 쪽에서 처리해야 함
    public String readFile(String path) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader(path));
        StringBuilder sb = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            sb.append(line).append("\n");
        }
        reader.close();
        return sb.toString();
    }

    // 호출자가 처리를 담당
    public void run() {
        try {
            String content = readFile("/etc/config.txt");
            System.out.println(content);
        } catch (IOException e) {
            System.err.println("처리 실패: " + e.getMessage());
        }
    }
}

import java.io.*;
import java.nio.file.*;

public class ModernFileReader {

    // try-with-resources: 블록 종료 시 reader.close() 자동 호출
    public String readFile(String path) throws IOException {
        try (BufferedReader reader = Files.newBufferedReader(Path.of(path))) {
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line).append("\n");
            }
            return sb.toString();
        }
        // catch 없이도 IOException은 throws로 위임됨
        // finally 없어도 reader가 자동 close됨
    }
}

public class UncheckedExceptionDemo {

    public static void main(String[] args) {

        // 1. NullPointerException: null 참조 접근
        String str = null;
        // str.length(); // NullPointerException 발생 → 코드 버그

        // Java 14+ NPE 개선: 어떤 변수가 null인지 메시지로 알려줌
        // "Cannot invoke String.length() because 'str' is null"

        // 2. ArrayIndexOutOfBoundsException: 배열 범위 초과
        int[] arr = new int[3];
        // arr[5] = 10; // ArrayIndexOutOfBoundsException → 코드 버그

        // 3. NumberFormatException: 숫자로 변환 불가능한 문자열
        String input = "abc";
        // int num = Integer.parseInt(input); // NumberFormatException

        // 올바른 처리: 변환 전 검증으로 예방
        if (input.matches("\\d+")) {
            int num = Integer.parseInt(input);
            System.out.println(num);
        }

        // 4. IllegalArgumentException: 잘못된 인자 전달
        validateAge(-5); // IllegalArgumentException 발생

        // 5. ClassCastException: 잘못된 타입 캐스팅
        Object obj = "hello";
        // Integer num2 = (Integer) obj; // ClassCastException

        // instanceof로 사전 확인 (Java 16+ pattern matching)
        if (obj instanceof String s) {
            System.out.println(s.toUpperCase());
        }
    }

    public static void validateAge(int age) {
        if (age < 0 || age > 150) {
            // IllegalArgumentException은 Unchecked → throws 선언 불필요
            throw new IllegalArgumentException("나이는 0~150 사이여야 합니다: " + age);
        }
    }
}

public class DivisionExample {

    // 방어적 프로그래밍으로 예외 예방
    public int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("제수(b)는 0이 될 수 없습니다.");
        }
        return a / b; // b가 0이면 ArithmeticException 발생
    }
}

import java.io.*;

public class ExceptionComparison {

    // ① Checked Exception: throws 없으면 컴파일 에러
    // public void readFile() {                  // ← 컴파일 에러!
    public void readFile() throws IOException {  // ← 반드시 선언
        FileReader fr = new FileReader("test.txt"); // IOException 가능
    }

    // ② Unchecked Exception: throws 없어도 컴파일 정상
    public void riskyMethod() {                  // ← 컴파일 통과
        String s = null;
        s.length(); // NullPointerException → 런타임에 터짐
    }

    // ③ 호출 시 강제 처리 여부 차이
    public void caller() {
        // Checked: 반드시 처리해야 컴파일 통과
        try {
            readFile();
        } catch (IOException e) {
            System.err.println("IO 오류: " + e.getMessage());
        }

        // Unchecked: try-catch 없어도 컴파일 통과
        riskyMethod(); // 런타임에 NullPointerException 발생
    }
}

public class UserRepository {

    public User findById(long id) {
        try {
            // DB 접근: Checked Exception 발생 가능
            return jdbcTemplate.queryForObject(...);
        } catch (SQLException e) {
            // Checked → Unchecked로 전환 (cause 체이닝 필수)
            throw new DataAccessException("사용자 조회 실패: id=" + id, e);
            //                                                          ↑
            //                              원인 예외를 반드시 cause로 전달
        }
    }
}

// 좋은 Checked Exception 설계 예시
public class PaymentGateway {

    // 외부 결제 API 호출 → 네트워크·서버 오류는 사전 예측 가능
    // 호출자가 재시도·알림·롤백 등 복구 로직을 작성해야 함
    public PaymentResult charge(PaymentRequest request)
            throws PaymentException {        // Checked
        // 결제 게이트웨이 HTTP 호출
    }
}

// 커스텀 Checked Exception
public class PaymentException extends Exception {
    private final String errorCode;

    public PaymentException(String message, String errorCode, Throwable cause) {
        super(message, cause);
        this.errorCode = errorCode;
    }

    public String getErrorCode() {
        return errorCode;
    }
}

// 좋은 Unchecked Exception 설계 예시
public class OrderService {

    public void createOrder(OrderRequest request) {
        // 인자 검증: 프로그래밍 오류 → Unchecked
        if (request == null) {
            throw new IllegalArgumentException("OrderRequest는 null이 될 수 없습니다.");
        }
        if (request.getQuantity() <= 0) {
            throw new IllegalArgumentException("수량은 1 이상이어야 합니다: " + request.getQuantity());
        }

        // 비즈니스 규칙 위반: 도메인 수준 Unchecked 예외
        if (request.getQuantity() > stockService.getStock(request.getItemId())) {
            throw new InsufficientStockException("재고 부족: " + request.getItemId());
        }
    }
}

// 커스텀 Unchecked Exception (RuntimeException 상속)
public class InsufficientStockException extends RuntimeException {
    private final String itemId;

    public InsufficientStockException(String message) {
        super(message);
        this.itemId = null;
    }

    public InsufficientStockException(String message, String itemId) {
        super(message);
        this.itemId = itemId;
    }

    public String getItemId() {
        return itemId;
    }
}

// 절대 안 되는 패턴 (예외 삼키기)
try {
    doSomething();
} catch (Exception e) {
    // ← 아무것도 안 함. 예외가 사라짐. 디버깅 불가
}

// 최소한 이렇게는 해야 함
try {
    doSomething();
} catch (Exception e) {
    log.error("doSomething 실패: {}", e.getMessage(), e); // 로그 필수
    throw e; // 또는 상위로 전파
}

// 스프링 JPA 방식: throws 선언 없음 (Unchecked 기반)
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email); // DataAccessException(Unchecked) 가능
}

// 서비스 계층: throws 전파 없이 깔끔한 비즈니스 로직
@Service
public class UserService {

    private final UserRepository userRepository;

    public UserDto getUser(Long id) {
        return userRepository.findById(id)
                .map(UserDto::from)
                .orElseThrow(() -> new UserNotFoundException("사용자 없음: " + id));
                //                   ↑ Unchecked 커스텀 예외
    }
}

@RestControllerAdvice
public class GlobalExceptionHandler {

    // 비즈니스 예외 처리 (Unchecked)
    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFound(UserNotFoundException e) {
        log.warn("사용자 조회 실패: {}", e.getMessage());
        return ResponseEntity
                .status(HttpStatus.NOT_FOUND)
                .body(new ErrorResponse("USER_NOT_FOUND", e.getMessage()));
    }

    // 잘못된 입력값 처리 (Unchecked)
    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<ErrorResponse> handleIllegalArgument(IllegalArgumentException e) {
        log.warn("잘못된 요청: {}", e.getMessage());
        return ResponseEntity
                .status(HttpStatus.BAD_REQUEST)
                .body(new ErrorResponse("INVALID_INPUT", e.getMessage()));
    }

    // 예상치 못한 모든 예외 처리 (최후 보루)
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleAll(Exception e) {
        log.error("예상치 못한 오류 발생", e); // 전체 스택 트레이스 로깅
        return ResponseEntity
                .status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(new ErrorResponse("INTERNAL_ERROR", "서버 오류가 발생했습니다."));
    }
}

@Service
public class OrderService {

    @Transactional
    public void placeOrder(OrderRequest request) throws PaymentException {
        orderRepository.save(new Order(request));

        // Unchecked Exception → 자동 롤백 (기본 동작)
        // Checked Exception   → 롤백 안 됨! (기본 동작)
    }

    // Checked Exception도 롤백하려면 명시적 설정 필요
    @Transactional(rollbackFor = PaymentException.class)
    public void placeOrderWithRollback(OrderRequest request) throws PaymentException {
        orderRepository.save(new Order(request));
        paymentGateway.charge(request.getPayment()); // PaymentException (Checked)
        // rollbackFor 설정 시 Checked도 롤백 처리됨
    }
}

[Controller 계층]
  - @ExceptionHandler로 HTTP 응답 코드·메시지 변환
  - 비즈니스 로직 예외를 클라이언트 친화적 응답으로 변환

[Service 계층]
  - 비즈니스 규칙 위반 → 도메인 커스텀 예외 발생
  - 하위 계층 예외를 비즈니스 의미 있는 예외로 래핑

[Repository 계층]
  - 인프라 예외(SQLException 등)를 도메인 예외로 변환
  - Spring Data 사용 시 대부분 자동 처리

[공통 원칙]
  - 예외는 발생한 곳과 가장 가까운 적절한 계층에서 처리
  - 처리할 수 없는 예외는 삼키지 말고 위로 전파
  - 모든 예외는 반드시 로그를 남긴다