Java中动态将Method转换为函数式接口引用：JUnit 5扩展实践

import java.util.function.Supplier;

public class LambdaBasics {

    // 接受一个Supplier<String>函数式接口的方法
    public static void printStringFromSupplier(Supplier<String> sup) {
        System.out.println(sup.get());
    }

    // 接受一个普通String参数的方法
    public static void printStringDirectly(String value) {
        System.out.println(value);
    }

    public static void main(String[] args) {
        System.out.println("--- Lambda表达式示例 ---");
        // 使用Lambda表达式直接实现Supplier接口
        printStringFromSupplier(() -> "Hello, World! (from lambda)");

        System.out.println("\n--- 方法引用示例 ---");
        // 创建一个Supplier实例
        Supplier<String> mySupplier = () -> "Hello, World! (from explicit supplier)";
        // 传递Supplier实例
        printStringFromSupplier(mySupplier);
        // 使用方法引用传递mySupplier的get()方法
        printStringFromSupplier(mySupplier::get);

        System.out.println("\n--- 直接参数传递示例 ---");
        // 直接传递字符串值，与函数式接口无关
        printStringDirectly(mySupplier.get());
    }
}

--- Lambda表达式示例 ---
Hello, World! (from lambda)

--- 方法引用示例 ---
Hello, World! (from explicit supplier)
Hello, World! (from explicit supplier)

--- 直接参数传递示例 ---
Hello, World! (from explicit supplier)

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.function.Function;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.ParameterContext;
import org.junit.jupiter.api.extension.ParameterResolutionException;
// 假设的注解和类定义
@interface MyAnnotation {
    Class<?> converter();
    String jsonFile();
}

@interface JsonConverterMethod {}

class Car {
    private String model;
    public Car(String model) { this.model = model; }
    @Override
    public String toString() { return "Car{" + "model='" + model + '\'' + '}'; }
}

class MyClass {
    @JsonConverterMethod
    public static Car converter(String jsonLine) {
        System.out.println("MyClass::converter - Converting JSON: " + jsonLine);
        // 模拟转换逻辑
        if (jsonLine.contains("model")) {
            return new Car("Model_X_" + jsonLine.hashCode());
        }
        return new Car("Default_Car");
    }
}

class JsonCandleProvider {
    private final String resource;
    private final Function<String, Car> converter;

    public JsonCandleProvider(String resource, Function<String, Car> converter) {
        this.resource = resource;
        this.converter = converter;
        System.out.println("JsonCandleProvider initialized with resource: " + resource);
        // 示例：使用转换器转换一些数据
        Car car1 = converter.apply("{'model':'Tesla'}");
        System.out.println("Converted car from provider: " + car1);
        Car car2 = converter.apply("{'type':'SUV'}");
        System.out.println("Converted car from provider: " + car2);
    }
}

// 简化的JUnit 5扩展实现
public class CustomJunit5Extension implements org.junit.jupiter.api.extension.ParameterResolver {

    // 模拟获取MyAnnotation实例
    private MyAnnotation getAnnotation(ParameterContext pctx, ExtensionContext ectx) {
        // 在实际JUnit 5扩展中，你会从pctx或ectx获取真正的注解
        return new MyAnnotation() {
            @Override
            public Class<?> converter() { return MyClass.class; }
            @Override
            public String jsonFile() { return "data/sample.json"; }
            @Override
            public Class<? extends java.lang.annotation.Annotation> annotationType() {
                return MyAnnotation.class;
            }
        };
    }

    // 模拟根据注解获取带有特定注解的方法
    private Method getMethodByAnnotation(Class<?> targetClass, Class<? extends java.lang.annotation.Annotation> annotationType) throws NoSuchMethodException {
        for (Method method : targetClass.getDeclaredMethods()) {
            if (method.isAnnotationPresent(annotationType)) {
                return method;
            }
        }
        throw new NoSuchMethodException("No method found with @" + annotationType.getSimpleName() + " in " + targetClass.getName());
    }

    @Override
    public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
        // 假设我们只支持JsonCandleProvider类型的参数
        return parameterContext.getParameter().getType() == JsonCandleProvider.class;
    }

    @Override
    public Object resolveParameter(ParameterContext pctx, ExtensionContext ectx) throws ParameterResolutionException {
        try {
            final MyAnnotation annotation = getAnnotation(pctx, ectx);
            final Method converterMethod = getMethodByAnnotation(annotation.converter(), JsonConverterMethod.class);

            // 重要的运行时类型检查：确保反射获取的方法签名与目标函数式接口兼容
            // 对于 Function<String, Car>，方法应是 (String) -> Car
            if (!Modifier.isStatic(converterMethod.getModifiers()) || // 确保是静态方法
                converterMethod.getParameterCount() != 1 || // 确保只有一个参数
                converterMethod.getParameterTypes()[0] != String.class || // 确保参数类型是String
                converterMethod.getReturnType() != Car.class) { // 确保返回类型是Car
                throw new ParameterResolutionException("Converter method signature mismatch for Function<String, Car>. Expected: public static Car methodName(String jsonLine)");
            }

            // 核心实现：将Method对象封装到Function函数式接口中
            Function<String, Car>