第261集方法执行异常，使用Arthas，快速定位问题架构实战：Arthas异常诊断、问题排查与企业级故障快速定位设计

/**
 * 空指针异常示例
 */
@Service
public class NullPointerExceptionExample {

    @Autowired
    private UserService userService;

    /**
     * 空指针异常场景1：未检查空值
     */
    public String getUserName(Long userId) {
        User user = userService.getUserById(userId);
        // 直接调用方法，可能抛出NullPointerException
        return user.getName(); // 如果user为null，会抛出NPE
    }

    /**
     * 空指针异常场景2：集合操作
     */
    public List<String> getUserNames(List<Long> userIds) {
        List<String> names = new ArrayList<>();
        for (Long userId : userIds) {
            User user = userService.getUserById(userId);
            // 如果user为null，会抛出NPE
            names.add(user.getName());
        }
        return names;
    }

    /**
     * 空指针异常场景3：链式调用
     */
    public String getUserEmail(Long userId) {
        User user = userService.getUserById(userId);
        // 链式调用，任何一环为null都会抛出NPE
        return user.getProfile().getEmail();
    }

    /**
     * 空指针异常场景4：数组访问
     */
    public String getFirstUserName(Long[] userIds) {
        // 如果userIds为null，会抛出NPE
        User user = userService.getUserById(userIds[0]);
        return user.getName();
    }
}

/**
 * 数组越界异常示例
 */
@Service
public class ArrayIndexOutOfBoundsExceptionExample {

    /**
     * 数组越界异常场景1：数组长度检查
     */
    public String getArrayElement(String[] array, int index) {
        // 未检查数组长度，可能抛出ArrayIndexOutOfBoundsException
        return array[index];
    }

    /**
     * 数组越界异常场景2：循环边界
     */
    public List<String> processArray(String[] array) {
        List<String> result = new ArrayList<>();
        // 循环边界错误，可能越界
        for (int i = 0; i <= array.length; i++) {
            result.add(array[i]);
        }
        return result;
    }

    /**
     * 数组越界异常场景3：动态数组
     */
    public String getDynamicArrayElement(List<String> list, int index) {
        // 转换为数组时可能越界
        String[] array = list.toArray(new String[0]);
        return array[index];
    }
}

/**
 * 类型转换异常示例
 */
@Service
public class ClassCastExceptionExample {

    /**
     * 类型转换异常场景1：强制类型转换
     */
    public String processObject(Object obj) {
        // 强制类型转换，可能抛出ClassCastException
        String str = (String) obj;
        return str.toUpperCase();
    }

    /**
     * 类型转换异常场景2：泛型擦除
     */
    public List<String> processGenericList(List<?> list) {
        List<String> result = new ArrayList<>();
        for (Object obj : list) {
            // 类型转换，可能抛出ClassCastException
            String str = (String) obj;
            result.add(str);
        }
        return result;
    }

    /**
     * 类型转换异常场景3：反射调用
     */
    public Object invokeMethod(Object target, String methodName, Object... args) {
        try {
            Class<?> clazz = target.getClass();
            Method method = clazz.getMethod(methodName, String.class);
            // 反射调用，可能抛出ClassCastException
            return method.invoke(target, args[0]);
        } catch (Exception e) {
            throw new RuntimeException("方法调用失败", e);
        }
    }
}

/**
 * 异常监控服务
 */
@Service
public class ExceptionMonitoringService {

    @Autowired
    private MeterRegistry meterRegistry;

    @Autowired
    private ExceptionRepository exceptionRepository;

    /**
     * 记录异常
     */
    public void recordException(String className, String methodName, Exception exception) {
        // 1. 记录异常指标
        recordExceptionMetrics(className, methodName, exception);

        // 2. 存储异常信息
        storeExceptionInfo(className, methodName, exception);

        // 3. 检查告警条件
        checkAlertConditions(className, methodName, exception);
    }

    /**
     * 记录异常指标
     */
    private void recordExceptionMetrics(String className, String methodName, Exception exception) {
        // 异常计数
        Counter.builder("exception.count")
                .description("异常计数")
                .tag("class", className)
                .tag("method", methodName)
                .tag("type", exception.getClass().getSimpleName())
                .register(meterRegistry)
                .increment();

        // 异常频率
        Timer.builder("exception.frequency")
                .description("异常频率")
                .tag("class", className)
                .tag("method", methodName)
                .tag("type", exception.getClass().getSimpleName())
                .register(meterRegistry)
                .record(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    /**
     * 存储异常信息
     */
    private void storeExceptionInfo(String className, String methodName, Exception exception) {
        ExceptionInfo exceptionInfo = new ExceptionInfo();
        exceptionInfo.setClassName(className);
        exceptionInfo.setMethodName(methodName);
        exceptionInfo.setExceptionType(exception.getClass().getName());
        exceptionInfo.setExceptionMessage(exception.getMessage());
        exceptionInfo.setStackTrace(getStackTrace(exception));
        exceptionInfo.setTimestamp(System.currentTimeMillis());

        exceptionRepository.save(exceptionInfo);
    }

    /**
     * 检查告警条件
     */
    private void checkAlertConditions(String className, String methodName, Exception exception) {
        // 检查异常频率
        checkExceptionFrequency(className, methodName, exception);

        // 检查异常类型
        checkExceptionType(className, methodName, exception);

        // 检查异常影响
        checkExceptionImpact(className, methodName, exception);
    }

    /**
     * 获取异常堆栈
     */
    private String getStackTrace(Exception exception) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        exception.printStackTrace(pw);
        return sw.toString();
    }
}

/**
 * 智能异常告警处理
 */
@Service
public class IntelligentExceptionAlertHandler {

    @Autowired
    private AlertService alertService;

    @Autowired
    private ExceptionAnalysisService exceptionAnalysisService;

    /**
     * 处理异常告警
     */
    @EventListener
    public void handleExceptionAlert(ExceptionAlertEvent event) {
        log.warn("收到异常告警: {}", event);

        // 1. 分析异常严重程度
        ExceptionSeverity severity = analyzeExceptionSeverity(event);

        // 2. 执行相应的处理措施
        switch (severity) {
            case CRITICAL:
                handleCriticalException(event);
                break;
            case WARNING:
                handleWarningException(event);
                break;
            case INFO:
                handleInfoException(event);
                break;
        }

        // 3. 记录告警处理结果
        recordAlertHandling(event, severity);
    }

    /**
     * 分析异常严重程度
     */
    private ExceptionSeverity analyzeExceptionSeverity(ExceptionAlertEvent event) {
        // 基于异常类型和历史数据分析严重程度
        ExceptionAnalysisResult analysis = exceptionAnalysisService.analyzeException(event);

        if (analysis.getExceptionType() == ExceptionType.NULL_POINTER_EXCEPTION) {
            return ExceptionSeverity.CRITICAL;
        } else if (analysis.getExceptionType() == ExceptionType.ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION) {
            return ExceptionSeverity.WARNING;
        } else {
            return ExceptionSeverity.INFO;
        }
    }

    /**
     * 处理严重异常
     */
    private void handleCriticalException(ExceptionAlertEvent event) {
        // 1. 立即通知相关人员
        alertService.sendCriticalAlert(event);

        // 2. 启动应急响应
        emergencyResponseService.activateEmergencyMode();

        // 3. 执行应急措施
        emergencyResponseService.executeEmergencyMeasures();

        // 4. 生成异常报告
        generateExceptionReport(event);
    }

    /**
     * 处理警告异常
     */
    private void handleWarningException(ExceptionAlertEvent event) {
        // 1. 发送警告通知
        alertService.sendWarningAlert(event);

        // 2. 执行预防措施
        executePreventiveMeasures(event);

        // 3. 增加监控频率
        increaseMonitoringFrequency();
    }

    /**
     * 生成异常报告
     */
    private void generateExceptionReport(ExceptionAlertEvent event) {
        try {
            ExceptionReport report = new ExceptionReport();
            report.setEvent(event);
            report.setAnalysisResult(exceptionAnalysisService.analyzeException(event));
            report.setRecommendations(generateRecommendations(event));
            report.setTimestamp(System.currentTimeMillis());

            // 保存报告
            exceptionReportRepository.save(report);

            log.info("异常报告已生成: {}", report.getId());

        } catch (Exception e) {
            log.error("生成异常报告失败", e);
        }
    }
}

/**
 * 异常预防策略
 */
@Service
public class ExceptionPreventionService {

    /**
     * 空值检查
     */
    public String safeGetUserName(Long userId) {
        User user = userService.getUserById(userId);
        if (user == null) {
            log.warn("用户不存在: {}", userId);
            return "未知用户";
        }
        return user.getName();
    }

    /**
     * 集合安全检查
     */
    public List<String> safeGetUserNames(List<Long> userIds) {
        if (userIds == null || userIds.isEmpty()) {
            return Collections.emptyList();
        }

        List<String> names = new ArrayList<>();
        for (Long userId : userIds) {
            User user = userService.getUserById(userId);
            if (user != null && user.getName() != null) {
                names.add(user.getName());
            }
        }
        return names;
    }

    /**
     * 数组边界检查
     */
    public String safeGetArrayElement(String[] array, int index) {
        if (array == null || index < 0 || index >= array.length) {
            log.warn("数组访问越界: array={}, index={}", array, index);
            return null;
        }
        return array[index];
    }

    /**
     * 类型安全转换
     */
    public String safeProcessObject(Object obj) {
        if (obj == null) {
            return null;
        }

        if (obj instanceof String) {
            return ((String) obj).toUpperCase();
        } else {
            log.warn("类型转换失败: {}", obj.getClass().getName());
            return obj.toString();
        }
    }

    /**
     * 异常处理包装
     */
    public <T> Optional<T> safeExecute(Supplier<T> supplier) {
        try {
            return Optional.ofNullable(supplier.get());
        } catch (Exception e) {
            log.error("执行失败", e);
            return Optional.empty();
        }
    }
}

/**
 * 全局异常处理器
 */
@RestControllerAdvice
public class GlobalExceptionHandler {

    private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    /**
     * 处理空指针异常
     */
    @ExceptionHandler(NullPointerException.class)
    public ResponseEntity<ErrorResponse> handleNullPointerException(NullPointerException e) {
        log.error("空指针异常", e);

        ErrorResponse error = new ErrorResponse();
        error.setCode("NULL_POINTER_EXCEPTION");
        error.setMessage("空指针异常");
        error.setTimestamp(System.currentTimeMillis());

        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
    }

    /**
     * 处理数组越界异常
     */
    @ExceptionHandler(ArrayIndexOutOfBoundsException.class)
    public ResponseEntity<ErrorResponse> handleArrayIndexOutOfBoundsException(ArrayIndexOutOfBoundsException e) {
        log.error("数组越界异常", e);

        ErrorResponse error = new ErrorResponse();
        error.setCode("ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION");
        error.setMessage("数组越界异常");
        error.setTimestamp(System.currentTimeMillis());

        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
    }

    /**
     * 处理类型转换异常
     */
    @ExceptionHandler(ClassCastException.class)
    public ResponseEntity<ErrorResponse> handleClassCastException(ClassCastException e) {
        log.error("类型转换异常", e);

        ErrorResponse error = new ErrorResponse();
        error.setCode("CLASS_CAST_EXCEPTION");
        error.setMessage("类型转换异常");
        error.setTimestamp(System.currentTimeMillis());

        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
    }

    /**
     * 处理通用异常
     */
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGenericException(Exception e) {
        log.error("未知异常", e);

        ErrorResponse error = new ErrorResponse();
        error.setCode("UNKNOWN_EXCEPTION");
        error.setMessage("未知异常");
        error.setTimestamp(System.currentTimeMillis());

        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
    }
}

/**
 * 异常恢复服务
 */
@Service
public class ExceptionRecoveryService {

    @Autowired
    private RetryTemplate retryTemplate;

    @Autowired
    private CircuitBreakerService circuitBreakerService;

    /**
     * 重试机制
     */
    public String retryableGetUserName(Long userId) {
        return retryTemplate.execute(context -> {
            try {
                User user = userService.getUserById(userId);
                return user.getName();
            } catch (Exception e) {
                log.warn("获取用户名失败，重试次数: {}", context.getRetryCount(), e);
                throw e;
            }
        });
    }

    /**
     * 熔断机制
     */
    public String circuitBreakerGetUserName(Long userId) {
        return circuitBreakerService.execute("getUserName", () -> {
            User user = userService.getUserById(userId);
            return user.getName();
        });
    }

    /**
     * 降级机制
     */
    public String fallbackGetUserName(Long userId) {
        try {
            User user = userService.getUserById(userId);
            return user.getName();
        } catch (Exception e) {
            log.warn("获取用户名失败，使用降级方案", e);
            return "用户" + userId;
        }
    }

    /**
     * 异步恢复
     */
    public CompletableFuture<String> asyncRecoveryGetUserName(Long userId) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                User user = userService.getUserById(userId);
                return user.getName();
            } catch (Exception e) {
                log.warn("异步获取用户名失败", e);
                return "异步用户" + userId;
            }
        });
    }
}

/**
 * 异常监控与处理服务
 */
@Service
public class ExceptionMonitoringAndHandlingService {

    @Autowired
    private ExceptionMonitoringService monitoringService;

    @Autowired
    private ExceptionRecoveryService recoveryService;

    /**
     * 异常监控与处理
     */
    @Around("@annotation(ExceptionHandling)")
    public Object handleException(ProceedingJoinPoint joinPoint) throws Throwable {
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();

        try {
            return joinPoint.proceed();
        } catch (Exception e) {
            // 记录异常
            monitoringService.recordException(className, methodName, e);

            // 尝试恢复
            return attemptRecovery(joinPoint, e);
        }
    }

    /**
     * 尝试恢复
     */
    private Object attemptRecovery(ProceedingJoinPoint joinPoint, Exception e) {
        try {
            // 根据异常类型选择恢复策略
            if (e instanceof NullPointerException) {
                return handleNullPointerException(joinPoint, e);
            } else if (e instanceof ArrayIndexOutOfBoundsException) {
                return handleArrayIndexOutOfBoundsException(joinPoint, e);
            } else if (e instanceof ClassCastException) {
                return handleClassCastException(joinPoint, e);
            } else {
                return handleGenericException(joinPoint, e);
            }
        } catch (Exception recoveryException) {
            log.error("异常恢复失败", recoveryException);
            throw e; // 重新抛出原始异常
        }
    }

    /**
     * 处理空指针异常
     */
    private Object handleNullPointerException(ProceedingJoinPoint joinPoint, Exception e) {
        // 实现空指针异常恢复逻辑
        return null;
    }

    /**
     * 处理数组越界异常
     */
    private Object handleArrayIndexOutOfBoundsException(ProceedingJoinPoint joinPoint, Exception e) {
        // 实现数组越界异常恢复逻辑
        return null;
    }

    /**
     * 处理类型转换异常
     */
    private Object handleClassCastException(ProceedingJoinPoint joinPoint, Exception e) {
        // 实现类型转换异常恢复逻辑
        return null;
    }

    /**
     * 处理通用异常
     */
    private Object handleGenericException(ProceedingJoinPoint joinPoint, Exception e) {
        // 实现通用异常恢复逻辑
        return null;
    }
}

/**
 * 异常分类管理
 */
@Service
public class ExceptionClassificationService {

    /**
     * 异常分类
     */
    public ExceptionCategory classifyException(Exception exception) {
        if (exception instanceof NullPointerException) {
            return ExceptionCategory.NULL_POINTER;
        } else if (exception instanceof ArrayIndexOutOfBoundsException) {
            return ExceptionCategory.ARRAY_INDEX_OUT_OF_BOUNDS;
        } else if (exception instanceof ClassCastException) {
            return ExceptionCategory.CLASS_CAST;
        } else if (exception instanceof IllegalArgumentException) {
            return ExceptionCategory.ILLEGAL_ARGUMENT;
        } else if (exception instanceof IllegalStateException) {
            return ExceptionCategory.ILLEGAL_STATE;
        } else if (exception instanceof RuntimeException) {
            return ExceptionCategory.RUNTIME_EXCEPTION;
        } else {
            return ExceptionCategory.UNKNOWN;
        }
    }

    /**
     * 异常优先级
     */
    public ExceptionPriority getExceptionPriority(Exception exception) {
        ExceptionCategory category = classifyException(exception);

        switch (category) {
            case NULL_POINTER:
            case ARRAY_INDEX_OUT_OF_BOUNDS:
                return ExceptionPriority.HIGH;
            case CLASS_CAST:
            case ILLEGAL_ARGUMENT:
                return ExceptionPriority.MEDIUM;
            case ILLEGAL_STATE:
            case RUNTIME_EXCEPTION:
                return ExceptionPriority.LOW;
            default:
                return ExceptionPriority.UNKNOWN;
        }
    }

    /**
     * 异常处理策略
     */
    public ExceptionHandlingStrategy getHandlingStrategy(Exception exception) {
        ExceptionCategory category = classifyException(exception);

        switch (category) {
            case NULL_POINTER:
                return ExceptionHandlingStrategy.RETRY_WITH_DEFAULT;
            case ARRAY_INDEX_OUT_OF_BOUNDS:
                return ExceptionHandlingStrategy.BOUNDARY_CHECK;
            case CLASS_CAST:
                return ExceptionHandlingStrategy.TYPE_CHECK;
            case ILLEGAL_ARGUMENT:
                return ExceptionHandlingStrategy.VALIDATION;
            case ILLEGAL_STATE:
                return ExceptionHandlingStrategy.STATE_RESET;
            default:
                return ExceptionHandlingStrategy.LOG_AND_CONTINUE;
        }
    }
}

/**
 * 异常知识库
 */
@Service
public class ExceptionKnowledgeBase {

    @Autowired
    private ExceptionRepository exceptionRepository;

    /**
     * 构建异常知识库
     */
    public void buildKnowledgeBase() {
        // 获取历史异常数据
        List<ExceptionInfo> exceptions = exceptionRepository.findAll();

        // 分析异常模式
        Map<String, ExceptionPattern> patterns = analyzeExceptionPatterns(exceptions);

        // 生成异常解决方案
        Map<String, ExceptionSolution> solutions = generateExceptionSolutions(patterns);

        // 存储知识库
        storeKnowledgeBase(patterns, solutions);
    }

    /**
     * 分析异常模式
     */
    private Map<String, ExceptionPattern> analyzeExceptionPatterns(List<ExceptionInfo> exceptions) {
        Map<String, ExceptionPattern> patterns = new HashMap<>();

        // 按异常类型分组
        Map<String, List<ExceptionInfo>> groupedExceptions = exceptions.stream()
                .collect(Collectors.groupingBy(ExceptionInfo::getExceptionType));

        // 分析每种异常的模式
        for (Map.Entry<String, List<ExceptionInfo>> entry : groupedExceptions.entrySet()) {
            String exceptionType = entry.getKey();
            List<ExceptionInfo> exceptionList = entry.getValue();

            ExceptionPattern pattern = new ExceptionPattern();
            pattern.setExceptionType(exceptionType);
            pattern.setFrequency(exceptionList.size());
            pattern.setCommonMethods(findCommonMethods(exceptionList));
            pattern.setCommonClasses(findCommonClasses(exceptionList));
            pattern.setCommonCauses(findCommonCauses(exceptionList));

            patterns.put(exceptionType, pattern);
        }

        return patterns;
    }

    /**
     * 生成异常解决方案
     */
    private Map<String, ExceptionSolution> generateExceptionSolutions(Map<String, ExceptionPattern> patterns) {
        Map<String, ExceptionSolution> solutions = new HashMap<>();

        for (Map.Entry<String, ExceptionPattern> entry : patterns.entrySet()) {
            String exceptionType = entry.getKey();
            ExceptionPattern pattern = entry.getValue();

            ExceptionSolution solution = new ExceptionSolution();
            solution.setExceptionType(exceptionType);
            solution.setPreventionMeasures(generatePreventionMeasures(pattern));
            solution.setRecoveryStrategies(generateRecoveryStrategies(pattern));
            solution.setMonitoringSuggestions(generateMonitoringSuggestions(pattern));

            solutions.put(exceptionType, solution);
        }

        return solutions;
    }

    /**
     * 查找常见方法
     */
    private List<String> findCommonMethods(List<ExceptionInfo> exceptions) {
        return exceptions.stream()
                .map(ExceptionInfo::getMethodName)
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
                .entrySet()
                .stream()
                .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
                .limit(5)
                .map(Map.Entry::getKey)
                .collect(Collectors.toList());
    }

    /**
     * 查找常见类
     */
    private List<String> findCommonClasses(List<ExceptionInfo> exceptions) {
        return exceptions.stream()
                .map(ExceptionInfo::getClassName)
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
                .entrySet()
                .stream()
                .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
                .limit(5)
                .map(Map.Entry::getKey)
                .collect(Collectors.toList());
    }

    /**
     * 查找常见原因
     */
    private List<String> findCommonCauses(List<ExceptionInfo> exceptions) {
        // 实现常见原因分析逻辑
        return Arrays.asList("空值检查", "边界检查", "类型检查");
    }

    /**
     * 生成预防措施
     */
    private List<String> generatePreventionMeasures(ExceptionPattern pattern) {
        List<String> measures = new ArrayList<>();

        if (pattern.getExceptionType().contains("NullPointer")) {
            measures.add("添加空值检查");
            measures.add("使用Optional");
            measures.add("使用@NonNull注解");
        } else if (pattern.getExceptionType().contains("ArrayIndexOutOfBounds")) {
            measures.add("添加边界检查");
            measures.add("使用集合替代数组");
            measures.add("使用安全访问方法");
        }

        return measures;
    }

    /**
     * 生成恢复策略
     */
    private List<String> generateRecoveryStrategies(ExceptionPattern pattern) {
        List<String> strategies = new ArrayList<>();

        if (pattern.getExceptionType().contains("NullPointer")) {
            strategies.add("使用默认值");
            strategies.add("重试机制");
            strategies.add("降级处理");
        } else if (pattern.getExceptionType().contains("ArrayIndexOutOfBounds")) {
            strategies.add("边界修正");
            strategies.add("数据验证");
            strategies.add("异常处理");
        }

        return strategies;
    }

    /**
     * 生成监控建议
     */
    private List<String> generateMonitoringSuggestions(ExceptionPattern pattern) {
        List<String> suggestions = new ArrayList<>();

        suggestions.add("增加异常监控");
        suggestions.add("设置告警阈值");
        suggestions.add("定期分析异常趋势");

        return suggestions;
    }
}

/**
 * 异常处理原则
 */
public class ExceptionHandlingPrinciples {

    /**
     * 原则1：快速失败
     */
    public void failFast(String input) {
        if (input == null) {
            throw new IllegalArgumentException("输入不能为空");
        }
        if (input.isEmpty()) {
            throw new IllegalArgumentException("输入不能为空字符串");
        }
        // 继续处理
    }

    /**
     * 原则2：异常透明
     */
    public String processData(String data) throws DataProcessingException {
        try {
            return doProcess(data);
        } catch (Exception e) {
            throw new DataProcessingException("数据处理失败", e);
        }
    }

    /**
     * 原则3：异常恢复
     */
    public String processWithRecovery(String data) {
        try {
            return doProcess(data);
        } catch (Exception e) {
            log.warn("处理失败，使用默认值", e);
            return "默认值";
        }
    }

    /**
     * 原则4：异常记录
     */
    public String processWithLogging(String data) {
        try {
            return doProcess(data);
        } catch (Exception e) {
            log.error("处理失败: data={}", data, e);
            throw e;
        }
    }

    /**
     * 原则5：异常分类
     */
    public String processWithClassification(String data) {
        try {
            return doProcess(data);
        } catch (IllegalArgumentException e) {
            // 参数异常，不重试
            throw e;
        } catch (RuntimeException e) {
            // 运行时异常，可以重试
            return retryProcess(data);
        } catch (Exception e) {
            // 其他异常，记录并继续
            log.error("未知异常", e);
            return "默认值";
        }
    }

    private String doProcess(String data) {
        // 模拟处理逻辑
        return data.toUpperCase();
    }

    private String retryProcess(String data) {
        // 模拟重试逻辑
        return data.toUpperCase();
    }
}

/**
 * 异常处理模式
 */
public class ExceptionHandlingPatterns {

    /**
     * 模式1：Try-Catch-Finally
     */
    public String tryCatchFinally(String data) {
        String result = null;
        try {
            result = processData(data);
        } catch (Exception e) {
            log.error("处理失败", e);
            result = "默认值";
        } finally {
            cleanup();
        }
        return result;
    }

    /**
     * 模式2：Try-With-Resources
     */
    public String tryWithResources(String data) {
        try (InputStream is = new ByteArrayInputStream(data.getBytes())) {
            return processStream(is);
        } catch (Exception e) {
            log.error("流处理失败", e);
            return "默认值";
        }
    }

    /**
     * 模式3：Optional处理
     */
    public Optional<String> optionalProcessing(String data) {
        return Optional.ofNullable(data)
                .filter(s -> !s.isEmpty())
                .map(this::processData)
                .map(String::toUpperCase);
    }

    /**
     * 模式4：函数式处理
     */
    public String functionalProcessing(String data) {
        return Optional.ofNullable(data)
                .map(s -> {
                    try {
                        return processData(s);
                    } catch (Exception e) {
                        log.error("处理失败", e);
                        return "默认值";
                    }
                })
                .orElse("空值默认");
    }

    /**
     * 模式5：装饰器模式
     */
    public String decoratorPattern(String data) {
        return new ExceptionHandlingDecorator(
                new LoggingDecorator(
                        new ValidationDecorator(
                                new DataProcessor()
                        )
                )
        ).process(data);
    }

    private String processData(String data) {
        return data.toUpperCase();
    }

    private String processStream(InputStream is) {
        return "流处理结果";
    }

    private void cleanup() {
        // 清理资源
    }
}