// 受检异常：不处理就编译不过，编译器强制你写契约
public static String readFirstLine(Path path) throws IOException {
    try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.UTF_8)) {
        return reader.readLine();
    }
}

// 非受检异常：编译期完全静默，上线后才炸
public static int divide(int a, int b) {
    return a / b;               // b == 0 时抛 ArithmeticException，没人提醒你
}

// 反例：看似优雅，实则把系统拖进泥潭
try {
    byte[] huge = new byte[Integer.MAX_VALUE];
} catch (OutOfMemoryError e) {
    log.error("内存不足", e);   // 这一行本身就可能再抛 OOM
    return Collections.emptyList(); // 返回空结果，业务被静默污染
}

// 正解：要么不捕获让它崩溃并生成 dump，要么只在极少数可控场景做「优雅退出」
// JVM 参数：-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/data/dump

// 一个粗略的量级测量：不要迷信具体数字，重点看「深栈 vs 浅栈」的相对差距
public class StackTraceCost {
    static final int LOOP = 1_000_000;

    static Exception shallow() { return new Exception("boom"); }

    static Exception deep(int n) {          // 人为制造 200 层调用栈
        return n == 0 ? new Exception("boom") : deep(n - 1);
    }

    public static void main(String[] args) {
        long t0 = System.nanoTime();
        for (int i = 0; i < LOOP; i++) { shallow(); }
        long t1 = System.nanoTime();
        for (int i = 0; i < LOOP; i++) { deep(200); }
        long t2 = System.nanoTime();

        System.out.printf("浅栈构造 100 万次：%d ms%n", (t1 - t0) / 1_000_000);
        System.out.printf("深栈构造 100 万次：%d ms%n", (t2 - t1) / 1_000_000);
    }
}

/**
 * 用于高频、可预期、且不需要栈轨迹的业务异常（如参数校验失败、限流拒绝）。
 * 关键点：writableStackTrace = false，跳过 fillInStackTrace 的栈遍历。
 */
public class FastBusinessException extends RuntimeException {
    private final int code;

    public FastBusinessException(int code, String message) {
        // 第四个参数 false：不填充栈轨迹
        super(message, null, true, false);
        this.code = code;
    }

    public int getCode() { return code; }

    // 双保险：即便被别人用反射/序列化路径构造，也不再填充
    @Override
    public synchronized Throwable fillInStackTrace() {
        return this;                 // 直接返回 this，什么都不做
    }
}

// 错误示范：只打了 message，栈全丢了，等于没法排查
log.error("创建订单失败：" + e.getMessage());

// 错误示范：字符串拼接异常对象，输出的是 e.toString()，栈依然丢失
log.error("创建订单失败：" + e);

// 正确：占位符 + 异常对象作为最后一个实参
log.error("创建订单失败, orderId={}, userId={}", orderId, userId, e);

// 需要把栈转成字符串（例如塞进数据库字段）时这样做
StringWriter sw = new StringWriter();
e.printStackTrace(new PrintWriter(sw));
String stack = sw.toString();

public class FinallyReturnDemo {

    // 1) finally 修改基本类型返回值：无效
    static int primitive() {
        int x = 1;
        try {
            return x;          // 返回值在此刻被"暂存"为 1
        } finally {
            x = 100;           // 改的是变量，不是已暂存的值
        }
    }

    // 2) finally 修改对象字段：有效
    static String objectField() {
        StringBuilder sb = new StringBuilder("a");
        try {
            return sb.toString();   // 已经生成了字符串 "a"，后续修改 sb 无影响
        } finally {
            sb.append("b");
        }
    }

    static List<String> objectRef() {
        List<String> list = new ArrayList<>();
        try {
            return list;            // 返回的是引用
        } finally {
            list.add("finally");    // 同一个对象被修改 → 调用方看得到
        }
    }

    // 3) finally 中 return：吞掉异常（极其危险）
    static int swallow() {
        try {
            int i = 1 / 0;          // ArithmeticException
            return i;
        } finally {
            return -1;              // 异常被丢弃，方法返回 -1，日志里什么都没有
        }
    }

    public static void main(String[] args) {
        System.out.println(primitive());          // 1
        System.out.println(objectField());        // a
        System.out.println(objectRef());          // [finally]
        System.out.println(swallow());            // -1，没有任何异常抛出！
    }
}

// 源码
static int calc(int a) {
    try {
        return 10 / a;
    } catch (ArithmeticException e) {
        return -1;
    } finally {
        System.out.println("finally");
    }
}

public class FinallyNotRun {
    public static void main(String[] args) {
        try {
            System.out.println("try");
            System.exit(0);            // JVM 立刻退出
        } finally {
            System.out.println("finally");  // 永远打印不出来
        }
    }
}

public static void visibility() {
    Connection conn = null;         // 必须提到外面，finally 才能访问
    try {
        conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test");
        conn.setAutoCommit(false);
    } catch (SQLException e) {
        log.error("获取连接失败", e);
    } finally {
        if (conn != null) {         // 还得判空，因为 try 可能第一行就失败
            try { conn.close(); } catch (SQLException ignored) { }
        }
    }
}

public class MyResource implements AutoCloseable {
    private final String name;
    public MyResource(String name) {
        this.name = name;
        System.out.println("open " + name);
    }
    public void work() { System.out.println("work with " + name); }
    @Override
    public void close() {
        System.out.println("close " + name);
        // 幂等：已关闭则直接返回，不抛异常
    }
}

// 使用方
public static void use() {
    try (MyResource r = new MyResource("A")) {
        r.work();
    }   // 编译器自动插入 close()
}

public static void use() {
    MyResource r = new MyResource("A");
    Throwable primary = null;                 // 主异常
    try {
        r.work();
    } catch (Throwable t) {
        primary = t;
        throw t;
    } finally {
        if (r != null) {
            if (primary != null) {
                try {
                    r.close();
                } catch (Throwable suppressed) {
                    primary.addSuppressed(suppressed);   // 挂到主异常上
                }
            } else {
                r.close();                     // 正常路径：异常直接向外抛
            }
        }
    }
}

public static void copy(Path src, Path dst) throws IOException {
    // 声明顺序：in → out；关闭顺序：out → in
    try (InputStream in  = Files.newInputStream(src);
         OutputStream out = Files.newOutputStream(dst)) {
        in.transferTo(out);
    }
}

public class SuppressedDemo {
    static class Boom implements AutoCloseable {
        private final String id;
        Boom(String id) { this.id = id; }
        @Override public void close() { throw new RuntimeException("close " + id); }
    }

    public static void main(String[] args) {
        try (Boom a = new Boom("A"); Boom b = new Boom("B")) {
            throw new IllegalStateException("业务主异常");
        } catch (IllegalStateException e) {
            System.out.println("主异常: " + e.getMessage());      // 业务主异常
            for (Throwable t : e.getSuppressed()) {
                System.out.println("被抑制: " + t.getMessage());  // close B / close A（逆序）
            }
        }
    }
}

public class Throwable implements Serializable {
    // 哨兵值：区分"还没记录过"与"禁止记录"
    private static final List<Throwable> SUPPRESSED_SENTINEL =
            Collections.emptyList();
    private List<Throwable> suppressedExceptions = SUPPRESSED_SENTINEL;

    public final synchronized void addSuppressed(Throwable exception) {
        if (exception == this)                       // ① 不能把自己加给自己
            throw new IllegalArgumentException("Self-suppression not permitted", this);
        if (exception == null)
            throw new NullPointerException("Cannot suppress a null exception");
        if (suppressedExceptions == null)            // ② 关闭了 suppression 功能，直接忽略
            return;
        if (suppressedExceptions == SUPPRESSED_SENTINEL)  // ③ 首次使用才创建列表（懒分配）
            suppressedExceptions = new ArrayList<>(1);
        suppressedExceptions.add(exception);         // ④ 追加
    }

    public final synchronized Throwable[] getSuppressed() {
        if (suppressedExceptions == null || suppressedExceptions == SUPPRESSED_SENTINEL)
            return EMPTY_THROWABLE_ARRAY;
        return suppressedExceptions.toArray(EMPTY_THROWABLE_ARRAY);
    }
}

// 错误 1：不判空 → try 第一行就失败时，finally 里 NPE，掩盖原始异常
Connection c = null;
try { c = getConn(); ... } finally { c.close(); }          // c 可能为 null

// 错误 2：close() 的异常覆盖了主异常 → 真正的失败原因永远消失
try { doSomething(); } finally { resource.close(); }       // close 抛异常，业务异常被顶掉

// 错误 3：多个资源串行关闭，前一个 close 抛异常导致后一个资源泄漏
try { ... } finally {
    a.close();   // 抛异常 → 下一行根本不执行
    b.close();   // b 泄漏！
}

Connection c = null;
Statement s = null;
try {
    c = getConn();
    s = c.createStatement();
    s.execute("SELECT 1");
} finally {
    // 每个资源独立 try-catch，保证互不影响；异常只记录不抛出，避免覆盖主异常
    if (s != null) { try { s.close(); } catch (SQLException e) { log.warn("关闭 Statement 失败", e); } }
    if (c != null) { try { c.close(); } catch (SQLException e) { log.warn("关闭 Connection 失败", e); } }
}

public static void jdk9Style(Path path) throws IOException {
    BufferedReader reader = Files.newBufferedReader(path);   // 在外面声明
    try (reader) {                       // JDK 9+ 合法：引用已有变量
        System.out.println(reader.readLine());
    }   // 依然是自动 close，且关闭后变量不可再用
}

/**
 * 业务异常基类：所有可预期的业务失败都继承它。
 * 继承 RuntimeException：不污染方法签名，由全局异常处理器统一兜底。
 */
public class BizException extends RuntimeException {
    private final int code;
    private final Map<String, Object> context = new HashMap<>();

    public BizException(ErrorCode errorCode) {
        super(errorCode.getMessage());
        this.code = errorCode.getCode();
    }

    public BizException(ErrorCode errorCode, Throwable cause) {
        super(errorCode.getMessage(), cause);   // 保留 cause，绝不丢
        this.code = errorCode.getCode();
    }

    /** 追加上下文：BizException.of(ORDER_NOT_FOUND).with("orderId", id) */
    public BizException with(String key, Object value) {
        context.put(key, value);
        return this;
    }
    public int getCode() { return code; }
    public Map<String, Object> getContext() { return Collections.unmodifiableMap(context); }
}

// 错误码枚举：集中管理，避免硬编码散落各处
public enum ErrorCode {
    PARAM_INVALID(40001, "参数不合法"),
    ORDER_NOT_FOUND(40401, "订单不存在"),
    STOCK_NOT_ENOUGH(40901, "库存不足"),
    SYSTEM_BUSY(50000, "系统繁忙，请稍后重试");

    private final int code;
    private final String message;
    ErrorCode(int code, String message) { this.code = code; this.message = message; }
    public int getCode() { return code; }
    public String getMessage() { return message; }
}

// 抛出时只带错误码和参数
throw new BizException(ErrorCode.STOCK_NOT_ENOUGH).with("skuId", skuId).with("need", 5);

// 展示层（Spring）再按 Locale 渲染
String msg = messageSource.getMessage("error.40901", new Object[]{skuId}, locale);

// 反例：原始异常彻底丢失，排查时只剩一句"下单失败"
catch (SQLException e) {
    throw new BizException(ErrorCode.SYSTEM_BUSY);
}

// 正解 1：构造器传入 cause
catch (SQLException e) {
    throw new BizException(ErrorCode.SYSTEM_BUSY, e);
}

// 正解 2：没有对应构造器时用 initCause（注意：只能调用一次，且构造时未传 cause）
BizException ex = new BizException(ErrorCode.SYSTEM_BUSY);
ex.initCause(e);          // 若已通过构造器设置了 cause，再调用会抛 IllegalStateException
throw ex;

// 反例：中间层无意义地 catch-log-rethrow，日志被同一异常刷屏
public OrderDTO getOrder(Long id) {
    try {
        return orderMapper.selectById(id);
    } catch (Exception e) {
        log.error("查询订单失败", e);
        throw e;                 // 什么都没做，只是多打一条日志
    }
}

// 正解：要么不 catch（让全局处理器兜底），要么转译成业务语义
public OrderDTO getOrder(Long id) {
    return Optional.ofNullable(orderMapper.selectById(id))
                   .orElseThrow(() -> new BizException(ErrorCode.ORDER_NOT_FOUND)
                                            .with("orderId", id));
}

// 恶劣：完全的沉默
try { doSomething(); } catch (Exception e) { }

// 可接受的「有理由的忽略」
try {
    lock.unlock();
} catch (IllegalMonitorStateException ignored) {
    // 当前线程本就不持有该锁，解锁失败是预期的，无需处理
    log.debug("重复解锁被忽略", ignored);
}

// 反例：1 万条数据里 1000 条格式错误 → 1000 次栈填充
for (String s : list) {
    try {
        result.add(Integer.parseInt(s));
    } catch (NumberFormatException e) {
        log.warn("格式错误: {}", s);
    }
}

// 正解：先过滤，再批量转换；异常留给真正的意外
for (String s : list) {
    if (s != null && s.matches("-?\\d+")) {     // 预判替代抛出
        result.add(Integer.parseInt(s));
    } else {
        log.warn("格式错误: {}", s);
    }
}

// 兜底：捕获所有未处理异常，保证至少留下一条带 traceId 的日志
public class GlobalExceptionHandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        log.error("线程[{}]发生未捕获异常, traceId={}", t.getName(), MDC.get("traceId"), e);
        // 可选：上报监控 / 触发告警
    }
}
// 安装：Thread.setDefaultUncaughtExceptionHandler(new GlobalExceptionHandler());
// 线程池场景：ThreadFactory 里为每个线程 setUncaughtExceptionHandler

/** 统一响应结构：所有接口返回同一形状，前端只认 code 字段 */
@Data
public class ApiResult<T> {
    private int code;          // 0 表示成功，非 0 为业务错误码
    private String message;    // 可直接展示给用户的文案
    private String traceId;    // 链路追踪 ID，排障唯一钥匙
    private T data;

    public static <T> ApiResult<T> ok(T data) {
        ApiResult<T> r = new ApiResult<>();
        r.code = 0; r.message = "ok"; r.data = data;
        r.traceId = MDC.get("traceId");
        return r;
    }
    public static <T> ApiResult<T> fail(int code, String message) {
        ApiResult<T> r = new ApiResult<>();
        r.code = code; r.message = message;
        r.traceId = MDC.get("traceId");
        return r;
    }
}

@RestControllerAdvice          // = @ControllerAdvice + @ResponseBody
@Slf4j
public class GlobalExceptionAdvice {

    /** 1) 业务异常：可预期，warn 级别，不打完整栈（或只打简栈） */
    @ExceptionHandler(BizException.class)
    public ApiResult<Void> handleBiz(BizException e) {
        log.warn("业务异常, code={}, context={}", e.getCode(), e.getContext());
        return ApiResult.fail(e.getCode(), e.getMessage());
    }

    /** 2) 参数校验异常：MethodArgumentNotValidException，提取字段级错误 */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ApiResult<Void> handleValid(MethodArgumentNotValidException e) {
        String msg = e.getBindingResult().getFieldErrors().stream()
                .map(f -> f.getField() + ":" + f.getDefaultMessage())
                .collect(Collectors.joining(", "));
        return ApiResult.fail(ErrorCode.PARAM_INVALID.getCode(), msg);
    }

    /** 3) 兜底：未知异常，error 级别 + 完整栈，对外只暴露通用文案 */
    @ExceptionHandler(Exception.class)
    public ApiResult<Void> handleUnknown(Exception e) {
        log.error("未处理异常", e);              // 完整栈必须留下
        return ApiResult.fail(ErrorCode.SYSTEM_BUSY.getCode(),
                              ErrorCode.SYSTEM_BUSY.getMessage());
    }
}

// 反例：吞掉中断，线程池 shutdownNow 永远无法真正停止该任务
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    // 什么都不做
}

// 正解：恢复中断标志，或把异常继续抛出
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();   // 恢复中断状态
    throw new BizException(ErrorCode.SYSTEM_BUSY, e);
}