Java案例如何全局捕获异常？

wen java案例 2026-06-10 214

本文目录导读：

Java案例如何全局捕获异常？

Web应用全局异常处理（Spring Boot）
Java桌面应用全局异常捕获
多线程环境下的全局异常捕获
Filter方式全局异常捕获（Web应用）
最佳实践建议

在Java中全局捕获异常主要有以下几种方式,下面按常见场景详细介绍：

Web应用全局异常处理（Spring Boot）

使用@ControllerAdvice + @ExceptionHandler

@RestControllerAdvice
public class GlobalExceptionHandler {
    // 处理所有未捕获的异常
    @ExceptionHandler(Exception.class)
    public Result<String> handleException(Exception e) {
        // 记录日志
        log.error("系统异常", e);
        return Result.error(500, "系统繁忙，请稍后重试");
    }
    // 处理特定异常
    @ExceptionHandler(IllegalArgumentException.class)
    public Result<String> handleIllegalArgument(IllegalArgumentException e) {
        return Result.error(400, e.getMessage());
    }
    // 处理业务异常
    @ExceptionHandler(BusinessException.class)
    public Result<String> handleBusinessException(BusinessException e) {
        return Result.error(e.getCode(), e.getMessage());
    }
}

自定义业务异常

public class BusinessException extends RuntimeException {
    private Integer code;
    public BusinessException(Integer code, String message) {
        super(message);
        this.code = code;
    }
    public Integer getCode() {
        return code;
    }
}

Java桌面应用全局异常捕获

使用UncaughtExceptionHandler

public class GlobalExceptionCatcher {
    public static void main(String[] args) {
        // 设置全局异常处理器
        Thread.setDefaultUncaughtExceptionHandler(
            new Thread.UncaughtExceptionHandler() {
                @Override
                public void uncaughtException(Thread t, Throwable e) {
                    // 记录日志
                    System.err.println("线程 " + t.getName() + " 发生未捕获异常:");
                    e.printStackTrace();
                    // 显示友好提示
                    JOptionPane.showMessageDialog(null,
                        "程序发生异常，请检查日志文件",
                        "系统异常",
                        JOptionPane.ERROR_MESSAGE);
                }
            }
        );
        // 启动应用程序
        SwingUtilities.invokeLater(() -> {
            new MyApplication().start();
        });
    }
}

完整的Swing应用示例

public class SwingExceptionHandler {
    public static void main(String[] args) {
        // 1. 设置线程异常处理器
        Thread.setDefaultUncaughtExceptionHandler(
            (thread, throwable) -> handleException(throwable)
        );
        // 2. 设置AWT事件异常处理器
        System.setProperty("sun.awt.exception.handler", 
            AWTExceptionHandler.class.getName());
        // 3. 启动应用
        EventQueue.invokeLater(() -> {
            try {
                new MyFrame().setVisible(true);
            } catch (Exception e) {
                handleException(e);
            }
        });
    }
    private static void handleException(Throwable e) {
        // 记录异常到文件
        try (FileWriter fw = new FileWriter("error.log", true);
             PrintWriter pw = new PrintWriter(fw)) {
            e.printStackTrace(pw);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        // 显示友好提示
        JOptionPane.showMessageDialog(null,
            "系统出现异常，请查看error.log文件了解详情",
            "错误",
            JOptionPane.ERROR_MESSAGE);
    }
}
// AWT异常处理器
public class AWTExceptionHandler {
    public void handle(Throwable throwable) {
        SwingExceptionHandler.handleException(throwable);
    }
}

多线程环境下的全局异常捕获

线程池异常处理

public class ThreadPoolExceptionHandler {
    public static void main(String[] args) {
        // 创建自定义线程工厂
        ThreadFactory threadFactory = new ThreadFactoryBuilder()
            .setUncaughtExceptionHandler((thread, throwable) -> {
                System.err.println("线程 " + thread.getName() + 
                    " 发生异常: " + throwable.getMessage());
            }).build();
        // 创建线程池
        ExecutorService executor = Executors.newFixedThreadPool(5, threadFactory);
        // 或者直接设置
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
            5, 10, 60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100),
            new ThreadFactory() {
                @Override
                public Thread newThread(Runnable r) {
                    Thread t = new Thread(r);
                    t.setUncaughtExceptionHandler(
                        (thread, throwable) -> {
                            System.err.println("异常处理: " + 
                                throwable.getMessage());
                        }
                    );
                    return t;
                }
            }
        );
    }
}

CompletableFuture异常处理

public class CompletableFutureExceptionHandler {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture
            .supplyAsync(() -> {
                if (Math.random() > 0.5) {
                    throw new RuntimeException("异步任务异常");
                }
                return "成功";
            })
            .exceptionally(throwable -> {
                System.err.println("捕获异常: " + throwable.getMessage());
                return "默认值";
            })
            .handle((result, throwable) -> {
                if (throwable != null) {
                    System.err.println("异常处理: " + throwable.getMessage());
                    return "处理异常";
                }
                return result;
            });
    }
}

Filter方式全局异常捕获（Web应用）

@WebFilter("/*")
public class ExceptionFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                         FilterChain chain) throws IOException, ServletException {
        try {
            chain.doFilter(request, response);
        } catch (Exception e) {
            // 全局异常处理
            HttpServletRequest req = (HttpServletRequest) request;
            HttpServletResponse resp = (HttpServletResponse) response;
            // 记录日志
            log.error("请求 {} 发生异常", req.getRequestURI(), e);
            // 返回统一错误响应
            resp.setContentType("application/json;charset=UTF-8");
            resp.getWriter().write(JSON.toJSONString(
                Result.error(500, "系统异常")
            ));
        }
    }
}

最佳实践建议

组合使用多种捕获方式

@Configuration
public class ExceptionConfig {
    // 1. 全局异常处理
    @Bean
    public GlobalExceptionHandler globalExceptionHandler() {
        return new GlobalExceptionHandler();
    }
    // 2. 线程异常处理器
    @PostConstruct
    public void initThreadExceptionHandler() {
        Thread.setDefaultUncaughtExceptionHandler(
            (thread, throwable) -> {
                log.error("线程 [{}] 发生未捕获异常", 
                    thread.getName(), throwable);
                // 发送告警通知
                alertService.sendAlert(throwable);
            }
        );
    }
    // 3. 自定义异常处理策略
    @Bean
    public ExceptionHandler exceptionHandler() {
        return new SimpleMappingExceptionResolver() {{
            setDefaultErrorView("error");
            setExceptionAttribute("exception");
            setDefaultStatusCode(500);
            // 特定异常映射
            setExceptionMappings(new Properties() {{
                put("java.lang.IllegalArgumentException", "error-400");
                put("com.example.BusinessException", "error-biz");
            }});
        }};
    }
}