使用装饰器模式优化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++;
    }
}

import java.util.Collection;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.logging.Level; // 示例使用java.util.logging，实际项目中可替换为slf4j等
import java.util.logging.Logger;

/**
 * 一个装饰器Predicate，用于在条件不满足时抛出异常并记录日志。
 *
 * @param <T> Predicate操作的输入类型
 */
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 用于输入对象。
     * @param 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。如果条件不满足，将抛出异常，此方法不会返回 false。
     * @throws RuntimeException 如果条件不满足。
     */
    @Override
    public boolean test(T t) {
        if (!predicate.test(t)) {
            RuntimeException e = exceptionFactory.apply(messageShort);
            String messageVerbose = String.format(format, t != null ? t.toString() : "null"); // 确保t为null时不会抛出NPE
            logger.log(Level.SEVERE, messageVerbose, e); // 使用SEVERE级别表示严重错误
            throw e;
        }
        return true;
    }

    /**
     * 辅助方法：检查集合中所有Predicate是否都满足条件。
     * 如果任何一个Predicate不满足，它将抛出异常。
     *
     * @param predicates 要检查的Predicate集合。
     * @param t          输入参数。
     * @param <T>        输入类型。
     * @return 如果所有Predicate都满足，则为 true。
     * @throws RuntimeException 如果任何Predicate不满足。
     */
    public static <T> boolean allMatch(Collection<Predicate<T>> predicates, T t) {
        // 使用Stream API的allMatch方法，如果任何一个Predicate抛出异常，Stream操作将中断
        return predicates.stream().allMatch(p -> p.test(t));
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;
import java.util.logging.Logger;
import java.util.logging.Level; // 确保导入Level

// 假设有一个User类
class User {
    String name;
    int age;
    String email;

    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    public int getAge() { return age; }
    public String getEmail() { return email; }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + ", email='" + email + "'}";
    }
}

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

public class PredicateValidationExample {
    private static final Logger LOGGER = Logger.getLogger(PredicateValidationExample.class.getName());
    private static final Pattern EMAIL_PATTERN = Pattern.compile("^[A-Za-z0-9+_.-]+@(.+)$");

    public static void main(String[] args) {
        User validUser = new User("Alice", 25, "alice@example.com");
        User invalidAgeUser = new User("Bob", 17, "bob@example.com");
        User invalidEmailUser = new User("Charlie", 30, "charlie@invalid");

        // 定义一组带日志和异常的条件
        List<Predicate<User>> userValidationRules = Arrays.asList(
            new ThrowingLoggPredicate<>(
                user -> user.getAge() >= 18,
                ValidationException::new,
                "年龄不符合要求",
                "用户 %s 年龄小于18岁。",
                LOGGER
            ),
            new ThrowingLoggPredicate<>(
                user -> EMAIL_PATTERN.matcher(user.getEmail()).matches(),
                ValidationException::new,
                "邮箱格式不正确",
                "用户 %s 邮箱格式无效。",
                LOGGER
            )
            // 可以添加更多规则...
        );

        System.out.println("--- 验证有效用户 ---");
        try {
            boolean allPassed = ThrowingLoggPredicate.allMatch(userValidationRules, validUser);
            if (allPassed) {
                System.out.println("用户 " + validUser.getName() + " 所有条件均通过。");
            }
        } catch (ValidationException e) {
            System.err.println("验证失败: " + e.getMessage());
        }

        System.out.println("\n--- 验证年龄不符用户 ---");
        try {
            ThrowingLoggPredicate.allMatch(userValidationRules, invalidAgeUser);
        } catch (ValidationException e) {
            System.err.println("验证失败: " + e.getMessage());
            // 此时日志中会有详细信息
        }

        System.out.println("\n--- 验证邮箱不符用户 ---");
        try {
            ThrowingLoggPredicate.allMatch(userValidationRules, invalidEmailUser);
        } catch (ValidationException e) {
            System.err.println("验证失败: " + e.getMessage());
            // 此时日志中会有详细信息
        }
    }
}