利用Function接口告别冗余代码：构建高效、可维护的Java应用

import java.util.function.Function;
import java.util.Optional;

public class UserInputProcessor {

    // 验证输入字符串是否为有效的用户名
    private static Function<String, Optional<String>> validateUsername = input -> {
        // 验证逻辑...
        if (isValidUsername(input)) {
            return Optional.of(input);
        } else {
            return Optional.empty();
        }
    };

    // 将输入字符串转换为小写形式
    private static Function<String, String> toLowerCase = String::toLowerCase;

    // 格式化用户名（例如，添加前缀或后缀）
    private static Function<String, String> formatUsername = username -> "User_" + username;

    // 通用处理方法，接受一个Function链作为参数
    public static <T, R> R processInput(String input, Function<T, R>... functions) {
        // 由于我们的输入是String类型，并且我们想要保持类型的一致性，
        // 我们需要将第一个Function的输入类型强制转换为String，并返回R类型的结果。
        // 为了简化示例，我们假设所有函数都接受String输入并返回String输出（在实际应用中可能需要更复杂的类型处理）。
        // 注意：这个实现是简化的，并且假设了所有函数都可以安全地链接在一起。
        // 在真实场景中，你可能需要添加更多的错误处理和类型检查。

        Function<String, String> combinedFunction = functions[0];
        for (int i = 1; i < functions.length; i++) {
            combinedFunction = combinedFunction.andThen(functions[i]);
        }

        // 由于我们的输入是String，我们可以直接调用apply方法。
        // 但请注意，这里的类型安全是基于我们的假设和简化的实现。
        return (R) combinedFunction.apply(input);
    }

    // 示例：处理用户输入
    public static void main(String[] args) {
        String input = "JohnDoe";
        String processedUsername = processInput(input, validateUsername::apply.andThen(Optional::get).andThen(toLowerCase).andThen(formatUsername));
        // 注意：上面的链式调用需要一些调整才能正确工作，因为validateUsername返回一个Optional<String>。
        // 在实际应用中，你可能需要编写一个辅助方法来处理Optional的链式调用，或者重新设计你的Function链。
        // 为了简化示例，我们假设validateUsername总是返回一个有效的Optional<String>。

        // 正确的处理方式可能是这样的：
        String processedUsernameCorrected = processInputCorrected(input,
                input -> Optional.ofNullable(validateUsernameOriginal(input)).orElseThrow(() -> new IllegalArgumentException("Invalid username")),
                toLowerCase,
                formatUsername
        );

        System.out.println(processedUsernameCorrected); // 输出: User_johndoe（假设validateUsernameOriginal验证通过）
    }

    // 辅助方法，用于处理Optional并抛出异常（如果需要）
    private static <T> T validateUsernameOriginal(T input) {
        // 实际的验证逻辑（这里应该返回T类型或抛出异常，但为了简化我们假设它总是返回input）
        return input instanceof String && isValidUsername((String) input) ? (T) input : null;
    }

    // 正确的处理输入方法，考虑了Optional的处理和异常抛出
    private static <T, R> R processInputCorrected(T input, Function<T, ?>... functions) {
        // 由于我们的函数链可能包含返回Optional或抛出异常的情况，
        // 我们需要一种方法来安全地处理这些情况。这里我们简化处理，只演示了如何链接函数并处理异常。
        // 在实际应用中，你可能需要更复杂的逻辑来处理不同类型的返回值和异常。

        Function<T, R> combinedFunction = input1 -> {
            Object result = functions[0].apply(input1);
            for (int i = 1; i < functions.length; i++) {
                if (result instanceof Optional) {
                    Optional<?> optionalResult = (Optional<?>) result;
                    if (!optionalResult.isPresent()) {
                        throw new RuntimeException("Validation failed at step " + i);
                    }
                    result = functions[i].apply(optionalResult.get());
                } else {
                    result = functions[i].apply(result);
                }
            }
            return (R) result;
        };

        // 注意：上面的实现有很多假设和简化，只是为了演示目的。
        // 在实际应用中，你需要根据具体的业务逻辑和错误处理需求来调整这个实现。

        return combinedFunction.apply(input);
    }

    // 辅助方法，用于验证用户名（示例逻辑）
    private static boolean isValidUsername(String username) {
        // 实际的验证逻辑（例如，检查用户名是否只包含字母和数字）
        return username != null && username.matches("[a-zA-Z0-9]+");
    }
}