如何使用Java开发函数计算？

在函数计算服务使用 Java 编程，需要定义一个 Java 函数作为入口。Java 运行环境根据是否支持 HTTP 触发器分为 普通函数入口 和 HTTP 触发器函数入口 两种函数入口，为函数设置 HTTP 触发器后的函数入口形式会不同，这是为了方便处理发来的 HTTP request 请求并允许用户返回自定义 HTTP header。其中 普通函数入口 又分为 处理函数入口 和 initializer入口。

本文对 普通函数入口 和 HTTP 触发器函数入口 进行详细介绍：

普通函数入口 处理函数入口 StreamRequestHandler PojoRequestHandler initializer 入口 HTTP 触发器函数入口 Java 代码打包

普通函数入口

处理函数入口 用户在使用 Java 编程时，必须要实现函数计算提供的接口类，对于普通函数入口目前有 2 个预定义接口可选择：

StreamRequestHandler以流的方式接受调用输入event和返回执行结果，用户需要从inputStream中读取调用函数时的输入，处理完成后把函数执行结果写入到outputStream中来返回。

PojoRequestHandler通过泛型的方式，用户可以自定义输入和输出的类型，但是它们必须是POJO类型。

StreamRequestHandler 一个最简单的处理函数定义如下：

package example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.StreamRequestHandler; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class HelloFC implements StreamRequestHandler { @Override public void handleRequest( InputStream inputStream, OutputStream outputStream, Context context) throws IOException { outputStream.write(new String("hello world").getBytes()); } } 1. 包名/类名 包名和类名可以是任意的，但是需要与创建函数时的 “Handler” 字段相对应：上面的例子包名是 “example”，类名是 “HelloFC”，那么创建函数时指定的 Handler 为 example.HelloFC::handleRequest，”Handler” 的格式为 {package}.{class}::{method}。

1. 实现的接口 用户的代码中必须要实现函数计算预定义的接口。上面的例子中实现了StreamRequestHandler，其中的 inputStream 参数是调用函数时传入的数据，outputStream 用于返回函数的执行结果。

2. context参数 context 参数中包含一些函数的运行时信息(例如 request id/临时 AK 等）。其类型是 com.aliyun.fc.runtime.Context。

3. 返回值 实现StreamRequestHandler接口的函数通过outputStream参数返回执行结果

4. 引入接口库 其中用到的com.aliyun.fc.runtime这个包的依赖可以通过下面的 pom.xml 引用：

com.aliyun.fc.runtime fc-java-core 1.3.0 通过 maven 仓库 可以获取fc-java-core最新的版本号。

在创建函数之前，用户需要将代码及其依赖的 fc-java-core 打包成 jar。关于如何打包，请参见 Java 代码打包。 打包成 jar 后就可以使用 Fun 或者控制台上传代码，以 Fun 为例：

在项目根目录创建一个 template.yml 的文件：

ROSTemplateFormatVersion: '2015-09-01' Transform: 'Aliyun::Serverless-2018-04-03' Resources: FunDemo: Type: 'Aliyun::Serverless::Service' javademo: Type: 'Aliyun::Serverless::Function' Properties: Handler: example.HelloFC::handleRequest Runtime: java8 CodeUri: './example.jar' 这个 template.yml 的含义如下：声明一个名为 FunDemo 的 服务，并在这个服务下，再声明一个名为 javademo 的 函数，配置函数入口为 example.HelloFC::handleRequest，以及函数的 runtime 为 java8。并且，我们指定了 CodeUri 为 ./example.jar。在部署时，Fun 会将 CodeUri 指定的目录或文件打包上传。更多的配置规则 请参考。

示例代码包是示例中的 hello world 代码打包成的 jar 包，您可以直接使用 示例代码包 进行测试。

使用 Fun 部署：

fun deploy 执行成功时，会看到相关日志:

using region: cn-hangzhou using accountId: ***********3557 using accessKeyId: ***********r3Ra using timeout: 300 Waiting for service FunDemo to be deployed... Waiting for function javademo to be deployed... Waiting for packaging function javademo code... package function javademo code done function javademo deploy success service FunDemo deploy success 然后就可以登录控制台查看或直接调用了。

PojoRequestHandler 一个最简单的处理函数定义如下：

// HelloFC.java package example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.PojoRequestHandler; public class HelloFC implements PojoRequestHandler<SimpleRequest, SimpleResponse> { @Override public SimpleResponse handleRequest(SimpleRequest request, Context context) { String message = "Hello, " + request.getFirstName() + " " + request.getLastName(); return new SimpleResponse(message); } } // SimpleRequest.java package example; public class SimpleRequest { String firstName; String lastName; public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getLastName() { return lastName; } public void setLastName(String lastName) { this.lastName = lastName; } public SimpleRequest() {} public SimpleRequest(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } } // SimpleResponse.java package example; public class SimpleResponse { String message; public String getMessage() { return message; } public void setMessage(String message) { this.message = message; } public SimpleResponse() {} public SimpleResponse(String message) { this.message = message; } } 准备调用的输入文件：

{ "firstName": "FC", "lastName": "aliyun" } 使用 fcli 调用结果：

invk hello-java -f /tmp/a.json {"message":"Hello, FC aliyun"}

initializer 入口 无论您的函数使用流式输入还是通过泛型的方式自定义输入和输出，当需要在 Java runtime 中添加 initializer 接口时，都需在原有的基础上额外实现 initializer 预定义的接口。

initializer预定义接口如下：

package com.aliyun.fc.runtime; import java.io.IOException; public interface FunctionInitializer { /** * The interface to handle a function compute initialize request * * @param context The function compute initialize environment context object. * @throws IOException IOException during I/O handling */ void initialize(Context context) throws IOException; } 一个简单的流式输入的函数和 initializer 结合的 demo 如下：

package aliyun.serverless.test.example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.FunctionComputeLogger; import com.aliyun.fc.runtime.StreamRequestHandler; import com.aliyun.fc.runtime.FunctionInitializer; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class InitializerAndStreamRequest implements StreamRequestHandler, FunctionInitializer { @Override public void initialize(Context context) { FunctionComputeLogger logger = context.getLogger(); logger.debug(String.format("RequestID is %s %n", context.getRequestId())); } @Override public void handleRequest(InputStream input, OutputStream output, Context context) throws IOException { FunctionComputeLogger logger = context.getLogger(); logger.debug(String.format("RequestID is %s %n", context.getRequestId())); output.write(new String("hello world!").getBytes()); output.flush(); } } 针对 InitializerAndStreamRequest 中新增加的 initialize 方法即是 initializer 接口，特性如下：

1. 包名/类名 initializer 所属包名和类名和处理函数一致，都可以是任意的。”initializer” 的格式同为 {package}.{class}::{method}，与 “handler” 不同的是 handler 中的 method 为 handleRequest，initializer 的 method 为 initialize。根据定义可知此示例的 initializer 为 aliyun.serverless.test.example.InitializerAndStreamRequest::initialize。

2. 实现的接口 用户的代码中必须要实现函数计算预定义的接口。上面示例中 initializer 接口实现了FunctionInitializer，initializer 接口只有一个 context 参数。

3. context参数 context 参数中包含一些函数的运行时信息(例如 request id/临时 AK 等）。其类型是 com.aliyun.fc.runtime.Context。

4. 返回值 实现FunctionInitializer接口的函数无返回结果。

泛型的方式输入的函数和 initializer 结合的 demo 如下：

package aliyun.serverless.test.example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.PojoRequestHandler; import com.aliyun.fc.runtime.FunctionInitializer; import com.aliyun.fc.runtime.FunctionComputeLogger; public class InitializerAndPojoRequest implements FunctionInitializer,PojoRequestHandler<SimpleRequest, SimpleResponse> { @Override public void initialize(Context context) { FunctionComputeLogger logger = context.getLogger(); logger.debug(String.format("RequestID is %s %n", context.getRequestId())); } @Override public SimpleResponse handleRequest(SimpleRequest request, Context context) { FunctionComputeLogger logger = context.getLogger(); logger.debug(String.format("RequestID is %s %n", context.getRequestId())); String message = "Hello, " + request.getFirstName() + " " + request.getLastName(); return new SimpleResponse(message); } }

HTTP 触发器函数入口 HTTP 触发器函数接口 HTTP 触发器的简单示例 HTTP 触发器支持传统web应用 关于 HTTP 触发器 的使用请参考：HTTP 触发器

HTTP 触发器函数接口 函数计算提供基于 Servlet 协议的 HTTP 触发器入口，具体接口形式如下：

public interface HttpRequestHandler { /** * The entrance function of fc http trigger * @param request The servlet request * @param response The servlet response * @param context The fc context * @throws IOException If IO exception happened * @throws ServletException If servlet exception happened */ public void handleRequest(HttpServletRequest request, HttpServletResponse response, Context context) throws IOException, ServletException; } 使用 HTTP 触发器需将 fc-java-core 库版本升级到 1.3.0 及以上。

HTTP 触发器的简单示例 package com.aliyun.fc.example; import java.io.IOException; import java.io.OutputStream; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.HttpRequestHandler; public class Hello implements HttpRequestHandler { public void handleRequest(HttpServletRequest request, HttpServletResponse response, Context context) throws IOException, ServletException { String requestPath = (String) request.getAttribute("FC_REQUEST_PATH"); String requestURI = (String) request.getAttribute("FC_REQUEST_URI"); String requestClientIP = (String) request.getAttribute("FC_REQUEST_CLIENT_IP"); response.setStatus(200); response.setHeader("header1", "value1"); response.setHeader("header2", "value2"); String body = String.format("Path: %s\n Uri: %s\n IP: %s\n", requestPath, requestURI, requestClientIP); OutputStream out = response.getOutputStream(); out.write((body).getBytes()); out.flush(); out.close(); } } 1. HttpServletRequest 函数计算 HTTP 触发器的接口直接使用标准的 Servlet 协议。 用户的请求会封装成HttpServletRequest对象，用户请求参数、请求header等均可通过此对象获取。 除此之外，函数计算在HttpServletRequest中预封装了一些属性, 可通过 getAttribute 方法来获取, 具体包括:

FC_REQUEST_PATH

获取请求的 Path

FC_REQUEST_URI

获取请求的 URI

FC_REQUEST_CLIENT_IP

获取请求的 ClientIP

1. HttpServletResponse 用户可通过标准的HttpServletResponse协议对象来返回响应 header 和 body.

2. context参数 context 参数中包含一些函数的运行时信息(例如 request id/临时 AK 等）。其类型是 com.aliyun.fc.runtime.Context。

HTTP 触发器支持传统web应用 基于 Servlet 协议的传统 web 应用能很方便的迁移到函数计算平台，目前支持的主流框架包括 Spring 、 SpringBoot 、 Struts2 等。以下示例如何通过函数计算提供的 fc-java-common 库来加载 web 应用.

打包您的 web 工程，生成 demo.war 包

上传 demo.war 包到 OSS，比如为 demo-bucket 下的 demo.war

创建函数，并设置函数初始化入口和函数入口。

函数示例代码如下：

package com.aliyun.fc.example; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.FcAppLoader; import com.aliyun.fc.runtime.FunctionComputeLogger; import com.aliyun.fc.runtime.FunctionInitializer; import com.aliyun.fc.runtime.HttpRequestHandler; public class HelloWeb implements FunctionInitializer, HttpRequestHandler { private FcAppLoader fcAppLoader = new FcAppLoader(); private String ossEndPoint = "YourOSSEndPoint"; private String bucket = "YourOSSBucket"; private String key = "YourWarName"; private String userContextPath = "/2016-08-15/proxy/{YourServiceName}/{YourFunctionName}"; @Override public void initialize(Context context) throws IOException { FunctionComputeLogger fcLogger = context.getLogger(); fcAppLoader.setFCContext(context); // Load code from OSS fcAppLoader.loadCodeFromOSS(ossEndPoint, bucket, key); // Init webapp from code fcAppLoader.initApp(userContextPath, HelloWeb.class.getClassLoader()); } @Override public void handleRequest(HttpServletRequest request, HttpServletResponse response, Context context) throws IOException, ServletException { try { fcAppLoader.forward(request, response); } catch (Exception e) { e.printStackTrace(); } } } 引用 Maven 库

com.aliyun.fc.runtime fc-java-core 1.3.0 com.aliyun.fc.runtime fc-java-common 2.2.2

Java 代码打包 使用 maven 打包jar 使用 IDEA 打包jar

使用 maven 打包 jar 在 pom.xml 中添加 maven-assembly-plugin 插件

maven-assembly-plugin 3.1.0 jar-with-dependencies false make-assembly package single org.apache.maven.plugins maven-compiler-plugin 1.8 1.8 打包

mvn package 执行完毕后，生成的 jar 会被存放在 target 目录下。

使用 maven 打包 jar，并将依赖以 jar 的形式存放在 /lib 目录中 随着项目依赖的增加，jar 的体积会变得越来越大。而用户上传的 jar 或者 zip 代码，在执行前，首先会被解压缩，然后才会被加载、执行。因此在刚才的两种实现中，存在的一个问题是我们打包的 jar 中包含了大量的 class 文件，这无疑会增加解压缩的时间，进而增加函数的首次启动时间。

一个更好的实践是将第三方依赖以 jar 的形式，存放于 /lib 目录。

这里提供一种使用 maven-dependency-plugin 实现的方案：

org.apache.maven.plugins maven-dependency-plugin copy-dependencies prepare-package copy-dependencies ${project.build.directory}/classes/lib runtime 执行完 mvn package，打包好的 jar 的目录结构为：

/.class lib/*.jar

使用 IDEA 打包 jar 配置导出 jar 包的选项:

java1

java2

java3

验证打包结果

rockuw-MBP:hello-java (master) $ ls -lrth total 6520 -rw-r--r-- 1 rockuw staff 3.2M Aug 31 21:03 hellofc.jar rockuw-MBP:hello-java (master) $ jar -tf hellofc.jar | head Picked up _JAVA_OPTIONS: -Duser.language=en META-INF/MANIFEST.MF example/ example/HelloFC.class example/SimpleRequest.class example/SimpleResponse.class META-INF/ META-INF// org/ org// org/apache/

函数计算目前支持以下 Java 运行环境：

OpenJDK 1.8.0 (runtime = java8) 对于 Java 运行环境的基本使用请参考Java 函数入口。以下将介绍 Java 运行环境相关特性:

使用 context 使用 logging 使用自定义的模块 异常处理

使用context context 是函数计算在运行时生成的一个对象，其中包含一些运行时的信息，用户在代码中可以使用这些信息。其定义如下，具体实现可以在 这里 找到：

package com.aliyun.fc.runtime; public interface Context { public String getRequestId(); public Credentials getExecutionCredentials(); public FunctionParam getFunctionParam(); public FunctionComputeLogger getLogger(); } 可以看到 context 中包含了4个信息：

RequestId: 本次调用请求的唯一 id，用户可以把它记录下来在出现问题的时候方便调查 FunctionParam: 当前调用的函数的一些基本信息如函数名/函数入口/函数内存/超时时间 ExecutionCredentials: 函数计算服务通过扮演用户提供的 服务角色获得的一组临时密钥，其有效时间是 5 分钟。用户可以在代码中使用它去访问相应的服务（例如 OSS），这就避免了用户把自己的 AK 信息写死在函数代码里。 Logger: 函数计算封装过的 logger，见下面的 使用logging 例如下面的代码使用临时密钥，向 OSS 中上传了一个文件：

package example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.Credentials; import com.aliyun.fc.runtime.StreamRequestHandler; import com.aliyun.oss.OSSClient; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class HelloFC implements StreamRequestHandler { @Override public void handleRequest( InputStream inputStream, OutputStream outputStream, Context context) throws IOException { String endpoint = "oss-cn-shanghai.aliyuncs.com"; String bucketName = "my-bucket"; Credentials creds = context.getExecutionCredentials(); OSSClient client = new OSSClient( endpoint, creds.getAccessKeyId(), creds.getAccessKeySecret(), creds.getSecurityToken()); client.putObject(bucketName, "my-object", new ByteArrayInputStream(new String("hello").getBytes())); outputStream.write(new String("done").getBytes()); } }

使用logging 用户的函数通过 context.getLogger() 打印的内容会被收集到用户在创建 Service 时指定的 LogStore 中：

package example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.StreamRequestHandler; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class HelloFC implements StreamRequestHandler { @Override public void handleRequest( InputStream inputStream, OutputStream outputStream, Context context) throws IOException { context.getLogger().info("hello world"); outputStream.write(new String("hello world").getBytes()); } } 上面的代码输出的日志内容是：

message:2017-07-05T05:13:35.920Z a72df088-f738-cee3-e0fe-323ad89118e5 [INFO] hello world 使用 context.getLogger().warn 和 context.getLogger().error 分别可以打包 WARN/ERROR 级别的日志。

使用自定义的模块 如果用户需要使用自定义的模块，则需要在打包 jar 时，将它们与代码一起打包。以下演示如何将 OSS Java SDK 打包到项目中。

在 pom.xml 中添加 OSS java SDK：

com.aliyun.fc.runtime fc-java-core 1.2.1 com.aliyun.oss aliyun-sdk-oss 2.6.1 执行通用打包流程

请参考 Java 代码打包

错误处理 用户的函数在执行过程如果抛出异常，那么函数计算会把异常捕获并将异常信息返回。例如下面的代码：

package example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.StreamRequestHandler; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class HelloFC implements StreamRequestHandler { @Override public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context) throws IOException { throw new IOException("oops"); } } 调用时收到的响应为：

invk hello-java -f /tmp/a.json { "errorMessage" : "oops", "errorType" : "java.io.IOException", "errorCause" : "oops", "stackTrace" : [ "example.HelloFC.handleRequest(HelloFC.java:15)" ] } Error: Request id: 45dd8d90-6b78-cce3-087c-8bf4ebc6c9af. Error type: UnhandledInvocationError 发生异常时，函数调用的响应的HTTP header中会包含X-Fc-Error-Type: UnhandledInvocationError。