예외 처리

public class Main {
    static int normalReturn() {
        int x = 1;
        try {
            System.out.println("try");
            return x;                       // 반환값 1이 여기서 확정
        } finally {
            x = 99;                         // 반환값에 영향 없음
            System.out.println("finally (x=" + x + ")");
        }
    }

    @SuppressWarnings("finally")
    static int finallyReturn() {
        try {
            throw new IllegalStateException("사라질 예외");
        } finally {
            return -1;                      // 예외를 삼키고 -1 반환 — 절대 하지 말 것
        }
    }

    public static void main(String[] args) {
        System.out.println("결과: " + normalReturn());
        System.out.println("결과: " + finallyReturn());
        // 출력:
        // try
        // finally (x=99)
        // 결과: 1
        // 결과: -1
    }
}

class Resource implements AutoCloseable {
    private final String name;
    private final boolean failOnClose;

    Resource(String name, boolean failOnClose) {
        this.name = name;
        this.failOnClose = failOnClose;
        System.out.println(name + " 열림");
    }

    @Override
    public void close() {
        System.out.println(name + " 닫힘");
        if (failOnClose) throw new IllegalStateException(name + " close 실패");
    }
}

public class Main {
    public static void main(String[] args) {
        try (Resource db = new Resource("DB", true);
             Resource file = new Resource("FILE", false)) {
            System.out.println("작업 중...");
            throw new RuntimeException("본문 예외");
        } catch (RuntimeException e) {
            System.out.println("잡힘: " + e.getMessage());
            for (Throwable s : e.getSuppressed()) {
                System.out.println("  suppressed: " + s.getMessage());
            }
        }
        // 출력:
        // DB 열림
        // FILE 열림
        // 작업 중...
        // FILE 닫힘
        // DB 닫힘
        // 잡힘: 본문 예외
        //   suppressed: DB close 실패
    }
}

enum ErrorCode {
    ORDER_NOT_FOUND(404, "주문을 찾을 수 없습니다"),
    INSUFFICIENT_STOCK(400, "재고가 부족합니다"),
    PAYMENT_DECLINED(502, "결제가 거절되었습니다");

    final int status;
    final String defaultMessage;
    ErrorCode(int status, String defaultMessage) { this.status = status; this.defaultMessage = defaultMessage; }
}

abstract class BusinessException extends RuntimeException {
    private final ErrorCode code;

    protected BusinessException(ErrorCode code, String detail) {
        super(code.defaultMessage + " (" + detail + ")");
        this.code = code;
    }

    protected BusinessException(ErrorCode code, String detail, Throwable cause) {
        super(code.defaultMessage + " (" + detail + ")", cause);
        this.code = code;
    }

    public ErrorCode getCode() { return code; }
}

class OrderNotFoundException extends BusinessException {
    OrderNotFoundException(String orderId) {
        super(ErrorCode.ORDER_NOT_FOUND, "orderId=" + orderId);
    }
}

class InsufficientStockException extends BusinessException {
    InsufficientStockException(String sku, int requested, int available) {
        super(ErrorCode.INSUFFICIENT_STOCK, "sku=" + sku + " 요청=" + requested + " 재고=" + available);
    }
}

class PaymentDeclinedException extends BusinessException {
    PaymentDeclinedException(long amount, Throwable cause) {
        super(ErrorCode.PAYMENT_DECLINED, "amount=" + amount, cause);
    }
}

public class Main {
    static void handle(Runnable action) {
        try {
            action.run();
        } catch (BusinessException e) {    // 글로벌 핸들러: 부모 하나로 전부 잡음
            System.out.println("[" + e.getCode().status + "] " + e.getCode() + ": " + e.getMessage()
                + (e.getCause() != null ? " / cause=" + e.getCause().getMessage() : ""));
        }
    }

    public static void main(String[] args) {
        handle(() -> { throw new OrderNotFoundException("O-404"); });
        handle(() -> { throw new InsufficientStockException("SKU-1", 5, 2); });
        handle(() -> { throw new PaymentDeclinedException(30_000, new java.io.IOException("PG timeout")); });
        // 출력:
        // [404] ORDER_NOT_FOUND: 주문을 찾을 수 없습니다 (orderId=O-404)
        // [400] INSUFFICIENT_STOCK: 재고가 부족합니다 (sku=SKU-1 요청=5 재고=2)
        // [502] PAYMENT_DECLINED: 결제가 거절되었습니다 (amount=30000) / cause=PG timeout
    }
}

import java.sql.SQLException;

class DataAccessException extends RuntimeException {
    DataAccessException(String message, Throwable cause) { super(message, cause); }
}

class OrderRepository {
    String findById(String id) throws SQLException {          // 하위 계층: checked
        throw new SQLException("Connection refused: db-primary:5432");
    }
}

class OrderService {
    private final OrderRepository repo = new OrderRepository();

    String getOrder(String id) {
        try {
            return repo.findById(id);
        } catch (SQLException e) {
            throw new DataAccessException("주문 조회 실패: orderId=" + id, e);   // 전환 + 체이닝
        }
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            new OrderService().getOrder("O-1");
        } catch (DataAccessException e) {
            System.out.println(e.getMessage());
            System.out.println("원인: " + e.getCause().getClass().getSimpleName() + " - " + e.getCause().getMessage());
        }
        // 출력:
        // 주문 조회 실패: orderId=O-1
        // 원인: SQLException - Connection refused: db-primary:5432
        //
        // (e.printStackTrace()를 하면 아래처럼 Caused by: 가 붙어 나온다)
        // DataAccessException: 주문 조회 실패: orderId=O-1
        //     at OrderService.getOrder(Main.java:...)
        // Caused by: java.sql.SQLException: Connection refused: db-primary:5432
        //     at OrderRepository.findById(Main.java:...)
    }
}

public class Main {
    static class EndOfArray extends RuntimeException {
        EndOfArray() { super("end"); }               // 매번 새 객체 + 스택트레이스 캡처
    }

    static long withException(int[] arr) {
        long sum = 0;
        try {
            for (int i = 0; ; i++) {
                if (i == arr.length) throw new EndOfArray();   // 끝을 예외로 알림
                sum += arr[i];
            }
        } catch (EndOfArray e) {
            return sum;
        }
    }

    static long withBranch(int[] arr) {
        long sum = 0;
        for (int i = 0; i < arr.length; i++) sum += arr[i];
        return sum;
    }

    public static void main(String[] args) {
        int[] arr = new int[10];
        int loops = 200_000;

        long t0 = System.nanoTime();
        for (int i = 0; i < loops; i++) withException(arr);
        long exceptionMs = (System.nanoTime() - t0) / 1_000_000;

        t0 = System.nanoTime();
        for (int i = 0; i < loops; i++) withBranch(arr);
        long branchMs = (System.nanoTime() - t0) / 1_000_000;

        System.out.println("예외 방식: " + exceptionMs + "ms");
        System.out.println("분기 방식: " + branchMs + "ms");
        // 출력 (환경마다 다름, 수십 배 차이가 일반적):
        // 예외 방식: 180ms
        // 분기 방식: 2ms
    }
}