使用装饰器模式增强Java Lambda表达式：实现精确的条件校验与错误日志

import java.util.Collection;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;

public class ThrowingLoggPredicate<T> implements Predicate<T> {
    private Predicate<T> predicate;
    private Function<String, RuntimeException> exceptionFactory;
    private String messageShort;
    private String format;
    private 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;
    }

    @Override
    public boolean test(T t) {
        if (!predicate.test(t)) {
            RuntimeException e = exceptionFactory.apply(messageShort);
            String messageVerbose = String.format(format, t); // Assuming format expects 't' as an argument
            logger.log(Level.SEVERE, messageVerbose, e); // Changed Level.ERROR to Level.SEVERE for java.util.logging
            throw e;
        }
        return true;
    }

    /**
     * 辅助方法：检查集合中所有Predicate是否都通过。
     * 如果任何一个Predicate失败，它将抛出由该Predicate装饰的异常。
     *
     * @param predicates 待检查的Predicate集合
     * @param t          输入对象
     * @param <T>        输入对象的类型
     * @return 如果所有Predicate都通过，则返回true
     */
    public static <T> boolean allMatch(Collection<Predicate<T>> predicates, T t) {
        // 使用forEachOrdered确保在第一个失败时即抛出异常，并保持检查顺序
        for (Predicate<T> p : predicates) {
            if (!p.test(t)) {
                // 如果p.test(t)抛出异常，这里会被捕获并重新抛出，
                // 如果p.test(t)返回false（不抛异常），这里会继续，但ThrowingLoggPredicate会抛异常
                return false; // Actually, ThrowingLoggPredicate.test(t) will throw, so this line is unreachable.
            }
        }
        return true;
        // 更简洁的Stream API版本，但异常处理逻辑需在Predicate内部完成
        // return predicates.stream().allMatch(p -> p.test(t));
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.logging.Logger;

// 示例User类
class User {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

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

    public static void main(String[] args) {
        // 定义校验规则，每个规则都是一个ThrowingLoggPredicate实例
        Predicate<User> nameNotNull = new ThrowingLoggPredicate<>(
                user -> user.getName() != null && !user.getName().trim().isEmpty(), // 实际校验逻辑
                msg -> new IllegalArgumentException(msg), // 异常工厂
                "用户名不能为空", // 简短异常消息
                "用户对象[%s]的姓名为空或空白", // 详细日志格式
                logger
        );

        Predicate<User> ageGreaterThanZero = new ThrowingLoggPredicate<>(
                user -> user.getAge() > 0, // 实际校验逻辑
                msg -> new IllegalArgumentException(msg), // 异常工厂
                "年龄必须大于0", // 简短异常消息
                "用户对象[%s]的年龄[%d]不合法，必须大于0", // 详细日志格式
                logger
        );
        // 注意：ageGreaterThanZero的format字符串现在需要两个参数。
        // 为了与ThrowingLoggPredicate的String.format(format, t)保持一致，
        // 最好让format只接收一个参数（即t.toString()）。
        // 如果需要多个参数，ThrowingLoggPredicate需要修改为接收一个Function<T, Object[]>来生成参数数组。
        // 为了简化，我们假设format只接收一个T对象的字符串表示。
        // 因此，ageGreaterThanZero的format应调整为：
        Predicate<User> ageGreaterThanZeroSimplifiedFormat = new ThrowingLoggPredicate<>(
                user -> user.getAge() > 0,
                msg -> new IllegalArgumentException(msg),
                "年龄必须大于0",
                "用户对象[%s]的年龄不合法，必须大于0", // 简化格式，依赖t.toString()
                logger
        );


        // 将所有校验规则组织成一个列表
        List<Predicate<User>> userValidations = Arrays.asList(nameNotNull, ageGreaterThanZeroSimplifiedFormat);

        // 示例：校验一个有效用户
        User validUser = new User("Alice", 30);
        try {
            ThrowingLoggPredicate.allMatch(userValidations, validUser);
            System.out.println("有效用户校验通过: " + validUser);
        } catch (RuntimeException e) {
            System.err.println("有效用户校验失败 (不应发生): " + e.getMessage());
        }

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

        // 示例：校验