Unlock Serverless Power with Spring Cloud Function: A Hands‑On Guide

Introduction

Spring Cloud Function aims to promote business logic through functions, decouple the development lifecycle from any specific runtime, support a unified programming model across serverless providers, and bring Spring Boot features to serverless environments.

Core Concepts

It abstracts transport and infrastructure details, allowing developers to focus on business logic while using familiar Spring tools.

<code>@SpringBootApplication
public class Application {
    @Bean
    public Function<Flux<String>, Flux<String>> uppercase() {
        return flux -> flux.map(value -> value.toUpperCase());
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
</code>

The function is a regular Spring Boot application that can be built, run, and tested locally or in CI. The Function comes from java.util.function and works with Reactor Flux as a publisher. It can be accessed via HTTP or messaging.

Key Features

Choice of programming style – reactive, imperative, or mixed.

Function composition and adaptation.

Support for reactive functions with multiple inputs and outputs, enabling complex stream operations.

Transparent type conversion for inputs and outputs.

Packaging for target platforms such as AWS Lambda, Azure Functions, etc.

Adapters that expose functions as HTTP endpoints or message listeners.

Deployment using an isolated classloader to bundle the application context into a single JAR.

Compilation of Java function bodies from strings into bytecode.

Adapters for major serverless providers (AWS Lambda, Azure, Google Cloud Functions, Apache OpenWhisk).

Example Usage

Functions can be automatically exported as HTTP endpoints. The spring-cloud-function-web module activates when included in a Spring Boot web application, exposing an MVC endpoint (default “/”) where the function name becomes part of the URL path. Supported content types are plain text and JSON.

HTTP Endpoint Mappings

GET /{supplier} – returns items from the named supplier.

POST /{consumer} – accepts JSON or text, mirrors input and pushes it to the consumer.

POST /{function} – applies the named function to the request body and returns the result.

GET /{function}/{item} – converts the item to an object and applies the function.

Sample Beans

<code>@Bean
public Consumer<Person> consumer1() {
    return person -> System.out.println("Blocking call: " + person);
}
</code>

<code>@Bean
public Consumer<Flux<Person>> consumer2() {
    return flux -> flux.subscribe(System.out::println);
}
</code>

<code>@Bean
public Function<Flux<Person>, Flux<Map<String, Object>>> function1() {
    return flux -> flux.map(p -> {
        Map<String, Object> result = new HashMap<>();
        result.put("name", p.getName());
        result.put("age", p.getAge());
        return result;
    });
}
</code>

Result Screenshots

End of tutorial.