使用反射查找带有注解的 Lambda 函数-java教程-PHP中文网

使用反射查找带有注解的 Lambda 函数

聖光之護

发布： 2025-11-15 17:17:00

原创

272人浏览过

使用反射查找带有注解的 lambda 函数

本文介绍如何使用 Java 反射机制查找带有特定注解的 Lambda 函数，并将其存储到 Map 中，以便根据 Task 的 ID 动态选择并执行相应的 Lambda 函数。文章将提供代码示例，并讨论潜在的类型转换问题，以及如何避免 unchecked cast 警告。

在某些应用场景中，我们可能需要根据不同的输入动态选择并执行不同的 Lambda 函数。一种实现方式是使用反射机制查找带有特定注解的 Lambda 函数，并将它们存储到一个 Map 中，Key 通常是注解的值，Value 则是对应的 Lambda 函数。

以下代码展示了如何使用 Java 反射实现这个功能。

1. 定义注解

首先，我们需要定义一个注解，用于标记需要被反射查找的 Lambda 函数。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface FooFunction {
    String value();
}

登录后复制

2. 定义 Task 和 Result 类

为了方便演示，我们定义简单的 Task 和 Result 类。

class Task {
    private String id;

    public Task(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
}

class Result {
    private String message;

    public Result(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

登录后复制

3. 定义 Lambda 函数

接下来，我们定义一些带有 @FooFunction 注解的 Lambda 函数。

SpeakingPass-打造你的专属雅思口语语料

使用chatGPT帮你快速备考雅思口语，提升分数

查看详情

import java.util.function.Function;

public class FunctionContainer {

    @FooFunction("abc")
    public static TaskResultFunction myFunc1 = task -> new Result("Result from abc: " + task.getId());

    @FooFunction("def")
    public static TaskResultFunction myFunc2 = task -> new Result("Result from def: " + task.getId());

    @FooFunction("ghi")
    public static TaskResultFunction myFunc3 = task -> new Result("Result from ghi: " + task.getId());

    // 自定义函数式接口
    public interface TaskResultFunction extends Function<Task, Result> {
    }
}

登录后复制

这里引入了一个自定义的函数式接口 TaskResultFunction，它继承自 Function<Task, Result>。这样做可以避免在后续的反射过程中处理泛型类型信息，简化代码。

4. 使用反射查找 Lambda 函数

现在，我们可以使用反射来查找所有带有 @FooFunction 注解的 Lambda 函数，并将它们存储到 Map 中。

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

public class FunctionFinder {

    private static final Map<String, Function<Task, Result>> funcMap = new HashMap<>();

    static {
        try {
            // 获取 FunctionContainer 类中所有声明的字段
            for (Field field : FunctionContainer.class.getDeclaredFields()) {
                // 检查字段是否被 FooFunction 注解
                if (field.isAnnotationPresent(FooFunction.class)) {
                    // 获取注解
                    FooFunction annotation = field.getAnnotation(FooFunction.class);
                    String key = annotation.value();

                    // 检查字段类型是否为 TaskResultFunction
                    if (FunctionContainer.TaskResultFunction.class.isAssignableFrom(field.getType())) {
                        // 获取字段的值 (Lambda 函数)
                        FunctionContainer.TaskResultFunction fn = (FunctionContainer.TaskResultFunction) field.get(null);
                        funcMap.put(key, fn);
                    }
                }
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public static Function<Task, Result> getFunction(String id) {
        return funcMap.get(id);
    }

    public static void main(String[] args) {
        Task task1 = new Task("abc");
        Task task2 = new Task("def");
        Task task3 = new Task("xyz");

        Function<Task, Result> func1 = FunctionFinder.getFunction(task1.getId());
        Function<Task, Result> func2 = FunctionFinder.getFunction(task2.getId());
        Function<Task, Result> func3 = FunctionFinder.getFunction(task3.getId()); // Not found

        if (func1 != null) {
            Result result = func1.apply(task1);
            System.out.println(result.getMessage());
        }

        if (func2 != null) {
            Result result = func2.apply(task2);
            System.out.println(result.getMessage());
        }

        if (func3 == null) {
            System.out.println("Function not found for task id: xyz");
        }
    }
}

登录后复制

代码解释:

FunctionContainer.class.getDeclaredFields(): 获取 FunctionContainer 类中声明的所有字段（包括私有字段）。
field.isAnnotationPresent(FooFunction.class): 检查当前字段是否被 FooFunction 注解。
field.getAnnotation(FooFunction.class): 获取字段上的 FooFunction 注解。
field.get(null): 获取静态字段的值。因为这些 Lambda 函数被声明为 static，所以可以传入 null 作为参数。如果字段不是静态的，则需要传入一个类的实例。
(FunctionContainer.TaskResultFunction) field.get(null): 将 field.get(null) 的返回值 (Object) 强制转换为 FunctionContainer.TaskResultFunction 类型。由于我们事先使用了自定义的函数式接口 TaskResultFunction 并进行了类型检查，因此可以安全地进行类型转换，避免 unchecked cast 警告。
funcMap.put(key, fn): 将注解的值和对应的 Lambda 函数存储到 funcMap 中。