Spring 的函数式编程支持和 Spring Cloud Function 是构建云原生、无服务器应用的关键技术。以下是核心概念和使用方法：

1. Spring 函数式编程支持

核心概念

  • 函数式端点（Functional Endpoints）：替代传统注解式控制器，通过 Java 8 函数式接口定义路由。
  • RouterFunction：定义请求路由逻辑，类似 @RequestMapping。
  • HandlerFunction：处理请求并返回响应，类似控制器方法。

优势

  • 更灵活的路由定义：编程式定义路由，避免注解限制。
  • 更好的测试性：函数式组件可独立测试，无需依赖 Spring 容器。
  • 适配 Serverless：与 Spring Cloud Function 无缝集成。

2. 使用 Spring 函数式端点

步骤1：定义模型

@Data
@AllArgsConstructor
public class Person {
    private String name;
    private Integer age;
}

步骤2：创建 HandlerFunction

@Component
public class PersonHandler {
    public Mono<ServerResponse> getPerson(ServerRequest request) {
        String name = request.pathVariable("name");
        return ServerResponse.ok()
                .bodyValue(new Person(name, 30));
    }

    public Mono<ServerResponse> savePerson(ServerRequest request) {
        return request.bodyToMono(Person.class)
                .flatMap(person -> ServerResponse.ok()
                        .bodyValue(person));
    }
}

步骤3：定义 RouterFunction

@Configuration
public class PersonRouter {
    @Bean
    public RouterFunction<ServerResponse> route(PersonHandler handler) {
        return RouterFunctions.route()
                .GET("/persons/{name}", handler::getPerson)
                .POST("/persons", handler::savePerson)
                .build();
    }
}

3. Spring Cloud Function 简介

Spring Cloud Function 将普通 Java 函数转换为云原生组件，支持多种运行方式（HTTP、消息队列、AWS Lambda 等）。

核心概念

  • Function：输入一个参数，返回一个结果（java.util.function.Function）。
  • Consumer：接收一个参数，无返回值。
  • Supplier：不接收参数，返回一个结果。
  • 适配器：将函数映射到不同运行环境（如 HTTP 端点、Kafka 消费者）。

4. 使用 Spring Cloud Function

步骤1：添加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-function-web</artifactId>
</dependency>

步骤2：定义函数 Bean

@Configuration
public class FunctionConfig {
    // Function：输入 String，输出 String
    @Bean
    public Function<String, String> uppercase() {
        return value -> value.toUpperCase();
    }

    // Consumer：接收消息但无返回
    @Bean
    public Consumer<String> logger() {
        return value -> System.out.println("Received: " + value);
    }

    // Supplier：定期生成消息
    @Bean
    public Supplier<Flux<String>> producer() {
        return () -> Flux.interval(Duration.ofSeconds(1))
                .map(i -> "Message-" + i);
    }
}

步骤3：部署方式

方式1：作为 HTTP 端点

函数自动映射为 HTTP POST 端点：

curl -X POST http://localhost:8080/uppercase -d "hello"
# 输出: HELLO
方式2：绑定消息队列（如 Kafka）

配置 spring.cloud.function.definition=uppercase，函数将自动处理 Kafka 消息。

方式3：部署到 AWS Lambda

添加依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-function-adapter-aws</artifactId>
</dependency>

创建 Handler：

public class StreamLambdaHandler extends SpringBootRequestHandler<String, String> {
    // 无需实现，由 Spring Cloud Function 自动处理
}

5. 函数组合与流式处理

函数组合

@Bean
public Function<Flux<String>, Flux<String>> process() {
    return flux -> flux
            .map(String::toUpperCase)
            .filter(s -> s.length() > 5);
}

使用 Stream 处理

@Bean
public Function<List<String>, List<String>> batchProcess() {
    return list -> list.stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());
}

6. 高级特性

多函数支持

通过 spring.cloud.function.definition 指定激活的函数：

spring.cloud.function.definition=uppercase|logger

自动类型转换

函数可直接处理复杂对象：

@Bean
public Function<Person, Person> processPerson() {
    return person -> {
        person.setAge(person.getAge() + 1);
        return person;
    };
}

7. 测试 Spring Cloud Function

@SpringBootTest
public class FunctionTest {
    @Autowired
    private ApplicationContext context;

    @Test
    public void testUppercaseFunction() {
        FunctionCatalog catalog = context.getBean(FunctionCatalog.class);
        Function<String, String> function = catalog.lookup("uppercase");
        
        String result = function.apply("test");
        assertEquals("TEST", result);
    }
}

8. 适用场景

  • 微服务：将单一功能封装为独立服务。
  • 无服务器（Serverless）：部署到 AWS Lambda、Azure Functions 等平台。
  • 事件驱动架构：通过消息队列连接多个函数。
  • 批处理：处理批量数据或定时任务。

总结

Spring 的函数式编程支持提供了灵活的路由定义方式，而 Spring Cloud Function 则进一步将普通 Java 函数转换为跨平台的云原生组件。通过简单定义 Function、Consumer 或 Supplier Bean，结合适当的适配器，可轻松实现 HTTP 服务、消息处理或无服务器应用，大大提升开发效率和可移植性。