Spring Boot 4 Microservices & REST APIs · 课时

使用 Spring Cloud 构建无服务器函数

探索使用 Spring Cloud Function 构建和部署无服务器函数。

使用 Spring Cloud 构建无服务器函数 是 CoddyKit 上的免费 Spring Boot 4 Microservices & REST APIs 课时。这是第 2 节课，共 3 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Spring Boot 4 Microservices & REST APIs 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Spring Boot 4 Microservices & REST APIs 课程共包含 3 节课。

本课时的部分内容尚未翻译，以英文显示。

What are Serverless Functions?

Serverless functions (also known as Functions as a Service or FaaS) are small, single-purpose pieces of code that run in response to events, without you having to manage any servers.

You only pay for the compute time consumed.
No server provisioning or scaling to worry about.
Focus purely on your code logic.

Introducing Spring Cloud Function

Spring Cloud Function is a framework that helps you write business logic as Java java.util.function types (Supplier, Function, Consumer).

The magic? You write your function once, and Spring Cloud Function makes it deployable across different serverless platforms like AWS Lambda, Azure Functions, or Google Cloud Functions, with minimal changes.

Supplier: No Input, Just Output

A Supplier is a function that takes no arguments but produces a result. Think of it as a data source or a generator.

It implements java.util.function.Supplier<T>.
It has a single method: T get().
Useful for polling, scheduled tasks, or generating initial data.

Your First Supplier Function

This example shows a simple Supplier that returns a greeting message. The @Bean annotation exposes it as a Spring Cloud Function.

Try running it to see the output!

import java.util.function.Supplier;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class SupplierApp {

    public static void main(String[] args) {
        // Run Spring Boot application context
        ConfigurableApplicationContext context = SpringApplication.run(SupplierApp.class, args);
        // Get the supplier bean and invoke its 'get' method
        Supplier<String> helloSupplier = context.getBean("helloSupplier", Supplier.class);
        System.out.println(helloSupplier.get());
        context.close(); // Clean up context
    }

    @Bean
    public Supplier<String> helloSupplier() {
        return () -> "Hello from CoddyKit Serverless!";
    }
}

Function: Input to Output

A Function is a mapping from one type to another. It takes an argument and produces a result.

It implements java.util.function.Function<T, R>.
It has a single method: R apply(T t).
Perfect for data transformation, processing requests, or applying business logic.

Transform Data with a Function

Here, our upperCaseFunction takes a String and returns its uppercase version. This demonstrates a simple data transformation.

Run the code and observe how the input changes!

import java.util.function.Function;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class FunctionApp {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(FunctionApp.class, args);
        Function<String, String> upperCaseFunction = context.getBean("upperCaseFunction", Function.class);
        String input = "coddykit serverless";
        String output = upperCaseFunction.apply(input);
        System.out.println("Input: " + input);
        System.out.println("Output: " + output);
        context.close();
    }

    @Bean
    public Function<String, String> upperCaseFunction() {
        return value -> value.toUpperCase();
    }
}

Consumer: Input, No Output

A Consumer is a function that takes an argument but produces no result. It's used for performing an action or side effect.

It implements java.util.function.Consumer<T>.
It has a single method: void accept(T t).
Ideal for logging, saving data, sending notifications, or triggering other processes.

Process Data with a Consumer

This printerConsumer takes a String and simply prints it to the console. It consumes the data without returning anything.

See how the message is processed!

import java.util.function.Consumer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class ConsumerApp {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(ConsumerApp.class, args);
        Consumer<String> printerConsumer = context.getBean("printerConsumer", Consumer.class);
        String message = "Processing complete for this event!";
        System.out.println("Consuming message...");
        printerConsumer.accept(message);
        context.close();
    }

    @Bean
    public Consumer<String> printerConsumer() {
        return value -> System.out.println("Received and processed: " + value);
    }
}

Deployment Agnostic Power

The core strength of Spring Cloud Function is its deployment agnosticism. You write your function once using standard Java interfaces, and the framework provides adapters to run it on various serverless platforms.

This means you're not locked into a specific cloud provider's API, making your code more portable and future-proof.

Function Type Check

Which type of Spring Cloud Function is designed to take an input and produce a transformed output?

Recap: Serverless & Spring Cloud Function

We've explored serverless functions and how Spring Cloud Function enables you to write portable business logic.

Serverless means focusing on code, not infrastructure.
Spring Cloud Function uses Supplier, Function, and Consumer interfaces.
These functions can be deployed to various FaaS platforms, offering great flexibility.

This approach simplifies development and increases the portability of your microservices.

常见问题解答

「使用 Spring Cloud 构建无服务器函数」课时是免费的吗？

是的 — 「使用 Spring Cloud 构建无服务器函数」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Spring Boot 4 Microservices & REST APIs 课程的其余内容，请升级到 CoddyKit PRO。 Spring Boot 4 Microservices & REST APIs 课程共包含 3 节课。

「使用 Spring Cloud 构建无服务器函数」这节课中我会学到什么？

探索使用 Spring Cloud Function 构建和部署无服务器函数。你通过在浏览器中直接运行的动手代码来练习 Spring Boot 4 Microservices & REST APIs，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Spring Boot 4 Microservices & REST APIs 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Spring Boot 4 Microservices & REST APIs 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 3 节。

「使用 Spring Cloud 构建无服务器函数」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Spring Boot 4 Microservices & REST APIs 课中编写并运行代码吗？

能。每节 Spring Boot 4 Microservices & REST APIs 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

部署到 Kubernetes 集群
使用 Spring Cloud 构建无服务器函数
微服务持续集成与持续交付流程

← 返回 Spring Boot 4 Microservices & REST APIs