Java 异常处理：从原理到实战最佳实践

捕获多个异常

当一段代码可能抛出多种异常时，可以使用多个 catch 块。注意异常类型要从小到大排列（子类在前，父类在后），否则编译器会报错，因为父类捕获后子类永远无法到达。

public class TryCatchMultiDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        try {
            System.out.println(arr[5]); // 可能抛出数组下标越界异常
            String str = null;
            System.out.println(str.length()); // 可能抛出空指针异常
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组下标越界：" + e.getMessage());
        } catch (NullPointerException e) {
            System.out.println("空指针异常：" + e.getMessage());
        } catch (Exception e) {
            System.out.println("发生未知异常：" + e.getMessage());
        }
    }
}

finally：资源释放的最后一道防线

finally 块无论是否发生异常都会执行，常用于关闭流、释放数据库连接等资源。

import java.io.FileInputStream;
import java.io.IOException;

public class FinallyDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("test.txt");
            int data = fis.read();
            System.out.println("读取到数据：" + data);
        } catch (IOException e) {
            System.out.println("文件读取异常：" + e.getMessage());
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                    System.out.println("流资源已关闭");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

注意：如果调用了 System.exit(0)，JVM 直接终止，finally 不会执行。

throws vs throw

• throws：方法签名上的声明，表示该方法可能抛出异常，责任交给调用者。
• throw：方法内部主动抛出一个异常对象，用于业务逻辑校验。

实战：登录场景中的主动抛出

public class ThrowDemo {
    public static void login(String username, String password) {
        if (!"admin".equals(username)) {
            throw new RuntimeException("用户名错误");
        }
        if (!"123456".equals(password)) {
            throw new RuntimeException("密码错误");
        }
        System.out.println("登录成功！");
    }

    public static void main(String[] args) {
        try {
            login("admin", "123");
        } catch (RuntimeException e) {
            System.out.println("登录失败：" + e.getMessage());
        }
    }
}

进阶特性与自定义异常

try-with-resources：自动管理资源

JDK 7 引入的特性，自动关闭实现了 AutoCloseable 接口的资源，无需手动写 finally。

try (FileInputStream fis = new FileInputStream("test.txt")) {
    System.out.println("读取数据：" + fis.read());
} catch (IOException e) {
    e.printStackTrace();
}

这种方式更简洁，也是推荐的做法。

异常链：保留完整调用信息

在捕获底层异常后，包装成上层业务异常抛出，保留 cause 信息，便于排查根因。

public class ExceptionChainDemo {
    public static void queryData() throws SQLException {
        throw new SQLException("数据库连接失败");
    }

    public static void processBusiness() {
        try {
            queryData();
        } catch (SQLException e) {
            RuntimeException businessException = new RuntimeException("业务处理失败");
            businessException.initCause(e);
            throw businessException;
        }
    }

    public static void main(String[] args) {
        try {
            processBusiness();
        } catch (RuntimeException e) {
            System.out.println("异常信息：" + e.getMessage());
            System.out.println("根因异常：" + e.getCause().getMessage());
            e.printStackTrace();
        }
    }
}

自定义异常

内置异常往往不够贴合业务。定义自定义异常可以让错误信息更明确。

// 自定义受检异常
public class UsernameExistException extends Exception {
    public UsernameExistException(String message) {
        super(message);
    }
}

// 自定义非受检异常
public class PasswordLengthException extends RuntimeException {
    public PasswordLengthException(String message) {
        super(message);
    }
}

使用场景示例：

public class CustomExceptionDemo {
    private static final Set<String> EXIST_USERNAMES = new HashSet<>();
    static {
        EXIST_USERNAMES.add("admin");
    }

    public static void register(String username, String password) throws UsernameExistException {
        if (EXIST_USERNAMES.contains(username)) {
            throw new UsernameExistException("用户名 [" + username + "] 已存在");
        }
        if (password.length() < 6) {
            throw new PasswordLengthException("密码长度不能小于 6 位");
        }
        EXIST_USERNAMES.add(username);
        System.out.println("用户注册成功！");
    }

    public static void main(String[] args) {
        try {
            register("admin", "123456");
        } catch (UsernameExistException e) {
            System.out.println("注册失败：" + e.getMessage());
        } catch (PasswordLengthException e) {
            System.out.println("注册失败：" + e.getMessage());
        }
    }
}

最佳实践与误区

在实际工程中，异常处理的质量直接影响系统的健壮性。

1. 只捕获能处理的异常：无法处理就向上抛出，不要强行吞掉。
2. 捕获具体异常：避免使用 catch (Exception e) 这种万能捕获，除非你确实想兜底。
3. 禁止空 catch 块：至少记录日志或打印堆栈，否则问题会被隐藏。
4. 优先使用 try-with-resources：减少资源泄露风险。
5. 提供有意义的异常信息：包含上下文，如'用户 [admin] 已存在'，而不仅仅是'错误'。

常见误区对比

❌ 忽略异常

try {
    // 操作
} catch (Exception e) {
    // 什么都不做
}

✅ 正确做法

try {
    // 操作
} catch (Exception e) {
    e.printStackTrace();
}

❌ 用异常代替逻辑判断

public static int getLength(String str) {
    try {
        return str.length();
    } catch (NullPointerException e) {
        return 0;
    }
}

✅ 提前判断

public static int getLength(String str) {
    if (str == null) return 0;
    return str.length();
}

统一异常处理框架实战

大型项目中，我们通常需要统一的异常处理机制，将系统异常和业务异常封装成标准返回格式。

1. 定义错误码枚举

public enum ErrorCode {
    SUCCESS(200, "操作成功"),
    USERNAME_EXIST(1001, "用户名已存在"),
    SYSTEM_ERROR(500, "系统内部异常");

    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; }
}

2. 统一返回结果类

public class Result<T> {
    private int code;
    private String message;
    private T data;

    private Result() {}

    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>();
        result.code = ErrorCode.SUCCESS.getCode();
        result.message = ErrorCode.SUCCESS.getMessage();
        result.data = data;
        return result;
    }

    public static <T> Result<T> fail(ErrorCode errorCode) {
        Result<T> result = new Result<>();
        result.code = errorCode.getCode();
        result.message = errorCode.getMessage();
        return result;
    }

    // Getter and Setter omitted for brevity
    public int getCode() { return code; }
    public void setCode(int code) { this.code = code; }
    public String getMessage() { return message; }
    public void setMessage(String message) { this.message = message; }
    public T getData() { return data; }
    public void setData(T data) { this.data = data; }
}

3. 全局异常处理器

public class GlobalExceptionHandler {
    public static Result<?> handleBusinessException(BusinessException e) {
        return Result.fail(e.getCode(), e.getMessage());
    }

    public static Result<?> handleSystemException(Exception e) {
        e.printStackTrace();
        return Result.fail(ErrorCode.SYSTEM_ERROR);
    }

    public static Result<?> handleException(Throwable e) {
        if (e instanceof BusinessException) {
            return handleBusinessException((BusinessException) e);
        } else {
            return handleSystemException((Exception) e);
        }
    }
}

4. 测试效果

public class GlobalExceptionDemo {
    public static void register(String username, String password) {
        if ("admin".equals(username)) {
            throw new BusinessException(ErrorCode.USERNAME_EXIST);
        }
        if (password.length() < 6) {
            throw new BusinessException(ErrorCode.PASSWORD_LENGTH_ERROR);
        }
    }

    public static void main(String[] args) {
        try {
            register("admin", "123456");
        } catch (Throwable e) {
            Result<?> result = GlobalExceptionHandler.handleException(e);
            System.out.println(result);
        }
    }
}

小结

异常处理是构建健壮系统的关键一环。理解 Throwable 体系，熟练运用 try-catch-finally 和 try-with-resources，并在业务层合理设计自定义异常，能让你的代码更加可靠。记住，最好的异常处理不是捕获一切，而是让错误清晰可见，让系统能够优雅应对。