使用装饰器模式增强Java Lambda表达式的条件检查与错误处理

public static void matchOrThrow(BooleanSupplier... conditions) {
    int i = 1;
    for (BooleanSupplier condition : conditions) {
        if (Boolean.FALSE.equals(condition.getAsBoolean())) {
            throw new CustomException("Condition check n_" + i + " failed");
        }
        i++;
    }
}

// 调用示例
matchOrThrow(
        () -> 1 == 2,
        () -> 1 == 1,
        () -> a > b,
        () -> c == null
);

import java.util.Collection;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.logging.Level; // 或者使用 org.slf4j.Logger, org.slf4j.LoggerFactory
import java.util.logging.Logger; // 示例使用java.util.logging

public class ThrowingLoggPredicate<T> implements Predicate<T> {
    private final Predicate<T> predicate;
    private final Function<String, RuntimeException> exceptionFactory;
    private final String messageShort;
    private final String format;
    private final Logger logger;

    /**
     * 构造一个具有错误日志和异常抛出功能的谓词。
     *
     * @param predicate        被装饰的原始条件判断逻辑。
     * @param exceptionFactory 用于创建运行时异常的工厂函数。
     * @param messageShort     简短的错误消息，用于异常构造。
     * @param format           详细的日志格式字符串，可包含占位符（如 %s, %d）来插入输入参数T。
     * @param logger           用于记录错误日志的Logger实例。
     */
    public ThrowingLoggPredicate(Predicate<T> predicate,
                                 Function<String, RuntimeException> exceptionFactory,
                                 String messageShort, String format,
                                 Logger logger) {
        this.predicate = predicate;
        this.exceptionFactory = exceptionFactory;
        this.messageShort = messageShort;
        this.format = format;
        this.logger = logger;
    }

    /**
     * 测试输入参数是否满足条件。如果条件不满足，则记录错误并抛出异常。
     *
     * @param t 要测试的输入参数。
     * @return 如果条件满足则返回 true。如果条件不满足，则抛出运行时异常。
     * @throws RuntimeException 如果条件不满足。
     */
    @Override
    public boolean test(T t) {
        if (!predicate.test(t)) {
            // 条件不满足，创建并抛出异常
            RuntimeException e = exceptionFactory.apply(messageShort);
            // 生成详细日志消息
            String messageVerbose = String.format(format, t);
            // 记录错误日志，包含详细消息和异常堆栈
            logger.log(Level.SEVERE, messageVerbose, e); // 使用SEVERE表示严重错误
            throw e;
        }
        return true;
    }

    /**
     * 检查集合中所有的谓词是否都对给定的输入参数返回 true。
     * 如果任何一个谓词返回 false，它将记录错误并抛出异常。
     *
     * @param predicates 谓词的集合。
     * @param t          要测试的输入参数。
     * @return 如果所有谓词都返回 true，则返回 true。
     * @throws RuntimeException 如果任何一个谓词返回 false。
     */
    public static <T> boolean allMatch(Collection<Predicate<T>> predicates, T t) {
        return predicates.stream().allMatch(p -> p.test(t));
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.logging.Logger;
import java.util.logging.Level; // 确保导入正确的Level

// 假设我们有一个自定义异常
class CustomValidationException extends RuntimeException {
    public CustomValidationException(String message) {
        super(message);
    }
}

public class ValidationExample {
    private static final Logger logger = Logger.getLogger(ValidationExample.class.getName());

    public static void main(String[] args) {
        // 定义一个检查整数是否为正数的谓词
        Predicate<Integer> isPositive = new ThrowingLoggPredicate<>(
            i -> i > 0,
            msg -> new IllegalArgumentException(msg), // 使用IllegalArgumentException
            "输入值必须为正数",
            "验证失败：值 %d 不是正数。",
            logger
        );

        // 定义一个检查整数是否为偶数的谓词
        Predicate<Integer> isEven = new ThrowingLoggPredicate<>(
            i -> i % 2 == 0,
            msg -> new CustomValidationException(msg), // 使用自定义异常
            "输入值必须为偶数",
            "验证失败：值 %d 不是偶数。",
            logger
        );

        List<Predicate<Integer>> conditions = Arrays.asList(isPositive, isEven);

        // 示例1: 所有条件都满足
        try {
            System.out.println("测试值 4:");
            boolean result = ThrowingLoggPredicate.allMatch(conditions, 4);
            System.out.println("所有条件都满足: " + result); // 输出 true
        } catch (RuntimeException e) {
            System.err.println("发生错误: " + e.getMessage());
        }

        System.out.println("---");

        // 示例2: isPositive 条件失败
        try {
            System.out.println("测试值 -5:");
            ThrowingLoggPredicate.allMatch(conditions, -5);
        } catch (RuntimeException e) {
            System.err.println("发生错误: " + e.getMessage());
            // 此时日志中会记录 "验证失败：值 -5 不是正数。" 以及异常堆栈
        }

        System.out.println("---");

        // 示例3: isEven 条件失败 (如果-5通过了isPositive，才会检查到isEven)
        // 为了演示isEven失败，我们传入一个正奇数
        try {
            System.out.println("测试值 7:");
            ThrowingLoggPredicate.allMatch(conditions, 7);
        } catch (RuntimeException e) {
            System.err.println("发生错误: " + e.getMessage());
            // 此时日志中会记录 "验证失败：值 7 不是偶数。" 以及异常堆栈
        }
    }
}