Java常用注解--@FunctionalInterface 函数式接口

1 定义要求

• 必须是一个接口（interface）。
• 有且仅有一个抽象方法（允许包含默认方法或静态方法）。
• 使用 @FunctionalInterface 注解标记，编译器会强制校验是否符合条件。

@FunctionalInterface
public interface StringProcessor {// 唯一抽象方法String process(String input);	// 什么也不干，谁实现的就干什么// 默认方法不计入抽象方法数量default void log(String message) {System.out.println("Log: " + message);}
}

2 实现方式

1. Lambda 表达式

直接通过 Lambda 实现函数式接口

StringProcessor upperCaseProcessor = (input) -> input.toUpperCase();	// 函数式接口的功能被实现为转大写
System.out.println(upperCaseProcessor.process("hello")); // 输出 "HELLO"

2. 方法引用

引用现有方法作为实现：

StringProcessor trimProcessor = String::trim;	// 函数式接口的功能被实现trim
System.out.println(trimProcessor.process("  hello  ")); // 输出 "hello"

3. 内置函数式接口

Java 内置自带的接口（如 Predicate, Function, Consumer）：

// 使用 Predicate 过滤数据
Predicate<String> isEmpty = s -> s == null || s.isEmpty();
List<String> nonEmptyList = list.stream().filter(isEmpty.negate()).collect(Collectors.toList());

3 自定义函数式接口的典型用途

1 简化回调逻辑

@FunctionalInterface
public interface OnSuccessCallback {void execute(String result);
}public void fetchData(OnSuccessCallback callback) {// 模拟异步操作new Thread(() -> {String data = "Data loaded";callback.execute(data);}).start();
}// 调用
fetchData(result -> System.out.println("Received: " + result));

如何简化？
对比Java 8之前，回调通常通过匿名内部类实现，代码冗余且不够直观：

// 定义回调接口
public interface Callback {void onSuccess(String data);void onFailure(String error);
}// 使用回调
public void fetchData(Callback callback) {try {String data = "Data loaded";callback.onSuccess(data);} catch (Exception e) {callback.onFailure("Error: " + e.getMessage());}
}// 调用时需实现所有方法（即使不关心某些情况）
fetchData(new Callback() {@Overridepublic void onSuccess(String data) {System.out.println("Received: " + data);}@Overridepublic void onFailure(String error) {// 即使不需要处理失败，也必须实现空方法}
});

问题：必须实现接口所有方法，即使某些场景下不需要全部逻辑。

1.1 使用函数式接口简化，

定义单一职责的接口，通过 @FunctionalInterface 拆分接口，每个接口只关注一个操作：

@FunctionalInterface
public interface SuccessCallback {void handleSuccess(String data);
}@FunctionalInterface
public interface FailureCallback {void handleFailure(String error);
}

然后按需传递回调即可：

public void fetchData(SuccessCallback success, FailureCallback failure) {try {String data = "Data loaded";success.handleSuccess(data);} catch (Exception e) {failure.handleFailure("Error: " + e.getMessage());}
}// 调用时只需关注需要的回调（Lambda表达式）
fetchData(data -> System.out.println("Success: " + data),  // 成功回调error -> System.err.println("Failed: " + error)  // 失败回调（可选）
);

优势：
代码简洁：无需冗余的匿名类模板。
按需实现：只传递关心的回调（如失败回调可省略）。
可读性高：Lambda直接表达逻辑意图。

1.2 灵活扩展

1. 结合默认方法
   为函数式接口添加默认方法，增强功能：

@FunctionalInterface
public interface SuccessCallback {void handleSuccess(String data);// 默认方法：添加日志功能default SuccessCallback withLogging() {return data -> {System.out.println("[Log] Success data: " + data);handleSuccess(data);};}
}// 使用增强的回调
SuccessCallback callback = data -> System.out.println("处理数据: " + data);
fetchData(callback.withLogging(), null);

2. 支持链式调用

fetchData(data -> processData(data).andThen(() -> logOperation("完成"))
);

2 组合函数

一个接口被实现后，干了很多事

@FunctionalInterface
public interface TextTransformer {String transform(String text);default TextTransformer andThen(TextTransformer after) {return text -> after.transform(this.transform(text));}
}// 使用
TextTransformer upperCase = String::toUpperCase;
TextTransformer addExclamation = s -> s + "!";
TextTransformer combined = upperCase.andThen(addExclamation);
System.out.println(combined.transform("hello")); // 输出 "HELLO!"

4 实践举例

4.1 资源清理（自动关闭）

场景：需要在操作完成后自动释放资源（如文件、数据库连接）。

@FunctionalInterface
public interface ResourceHandler<T> {void handle(T resource) throws IOException;// 封装资源打开和关闭逻辑static <T extends AutoCloseable> void useResource(Supplier<T> resourceSupplier, ResourceHandler<T> handler) throws IOException {try (T resource = resourceSupplier.get()) {handler.handle(resource);}}
}// 使用示例：自动关闭文件流
ResourceHandler.useResource(() -> new FileInputStream("data.txt"), // 资源提供者inputStream -> {byte[] data = inputStream.readAllBytes();System.out.println("读取到 " + data.length + " 字节");} // 处理逻辑（无需手动关闭）
);

优势：将资源获取/释放与业务逻辑解耦，避免忘记关闭资源。

4.2 策略模式（动态算法选择）

场景：根据运行时条件选择不同的处理策略。

@FunctionalInterface
public interface PaymentStrategy {void pay(BigDecimal amount);
}public class PaymentService {private PaymentStrategy strategy;public void setStrategy(PaymentStrategy strategy) {this.strategy = strategy;}public void executePayment(BigDecimal amount) {strategy.pay(amount);}
}// 使用示例：动态切换支付方式
PaymentService service = new PaymentService();// 选择支付宝支付
service.setStrategy(amount -> System.out.println("支付宝支付：" + amount + "元"));
service.executePayment(new BigDecimal("100.00"));// 切换为微信支付
service.setStrategy(amount ->System.out.println("微信支付：" + amount + "元"));
service.executePayment(new BigDecimal("200.00"));

优势：避免继承导致的类膨胀，策略实现更灵活。

4.3 流水线处理（链式操作）

场景：对数据依次进行多个处理步骤（如数据清洗、转换）。

@FunctionalInterface
public interface DataProcessor<T> {T process(T data);// 组合多个处理器default DataProcessor<T> andThen(DataProcessor<T> next) {return data -> next.process(this.process(data));}
}// 定义处理步骤
DataProcessor<String> trimProcessor = String::trim;
DataProcessor<String> upperCaseProcessor = String::toUpperCase;
DataProcessor<String> appendProcessor = s -> s + "!";// 组合流水线
DataProcessor<String> pipeline = trimProcessor.andThen(upperCaseProcessor).andThen(appendProcessor);String result = pipeline.process("  hello  "); // 输出 "HELLO!"

优势：通过链式调用实现可复用的处理流程。

4.4 异步任务编排

场景：多个异步任务需要顺序执行或合并结果

@FunctionalInterface
public interface AsyncTask<T> {CompletableFuture<T> execute();// 组合任务：先执行当前任务，再执行后续任务default <U> AsyncTask<U> thenCompose(Function<T, AsyncTask<U>> next) {return () -> this.execute().thenCompose(result -> next.apply(result).execute());}
}// 示例：异步获取用户信息 → 异步获取订单
AsyncTask<User> fetchUser = () -> userService.getUserAsync(1);
AsyncTask<Order> fetchOrder = user -> orderService.getOrderAsync(user.getId());AsyncTask<Order> combinedTask = fetchUser.thenCompose(fetchOrder);
combinedTask.execute().thenAccept(order -> System.out.println("订单详情：" + order)
);

优势：用声明式语法替代回调地狱（Callback Hell）。

4.5 条件触发（事件驱动）

场景：满足特定条件时触发操作（如监控阈值报警）。

@FunctionalInterface
public interface ConditionTrigger {void triggerIf(Supplier<Boolean> condition, Runnable action);
}// 实现类：定期检查条件
public class SchedulerTrigger implements ConditionTrigger {@Overridepublic void triggerIf(Supplier<Boolean> condition, Runnable action) {ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);scheduler.scheduleAtFixedRate(() -> {if (condition.get()) {action.run();scheduler.shutdown();}}, 0, 1, TimeUnit.SECONDS);}
}// 使用示例：CPU使用率超过80%时报警
SchedulerTrigger trigger = new SchedulerTrigger();
trigger.triggerIf(() -> getCpuUsage() > 80.0, // 条件检测() -> sendAlert("CPU过载！")  // 触发动作
);

优势：将条件检测与响应动作解耦，便于复用。