Function Compute Java handler configuration and examples - Function Compute: Central de Documentação do Alibaba Cloud

Um handler Java processa eventos recebidos na função do Function Compute (FC). O FC encaminha cada invocação ao método handler definido na configuração da função.

Nota

Para invocar funções por meio de gatilhos HTTP ou nomes de domínio personalizados, consulte Usar um gatilho HTTP para invocar uma função.

Formato do handler

Defina o parâmetro Handler no console do Function Compute com o seguinte formato:

[Package name].[Class name]::[Method name]

Por exemplo, se o pacote for example, a classe for HelloFC e o método for handleRequest:

example.HelloFC::handleRequest

Os nomes do pacote e da classe são personalizáveis, mas devem corresponder ao valor de Handler na configuração da função. Consulte Criar uma função de evento.

Interfaces de handler

Handlers Java devem implementar uma interface da biblioteca fc-java-core:

Interface	Entrada/Saída	Quando usar
`StreamRequestHandler`	`InputStream` / `OutputStream`	Processamento de fluxos de bytes brutos ou dados sem mapeamento para POJO
`PojoRequestHandler<I, O>`	Tipos POJO personalizados	Trabalho com dados JSON estruturados mapeáveis para objetos Java

Dependência Maven

Adicione fc-java-core ao arquivo pom.xml:

<dependency>
    <groupId>com.aliyun.fc.runtime</groupId>
    <artifactId>fc-java-core</artifactId>
    <version>1.4.1</version>
</dependency>

Verifique a versão mais recente no repositório Maven.

Antes de criar a função, empacote o código e a dependência fc-java-core em um arquivo JAR. Consulte Compilar e implantar pacotes de código.

StreamRequestHandler

O StreamRequestHandler lê a entrada de um InputStream e grava a saída em um OutputStream.

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());
    }
}

**inputStream**: Contém os dados do evento transmitidos durante a invocação da função.
**outputStream**: Recebe os dados de retorno da função.
**context**: Fornece informações de tempo de execução, como ID da solicitação e par de AccessKey temporário. Tipo: com.aliyun.fc.runtime.Context. Consulte Context.

PojoRequestHandler

O PojoRequestHandler<I, O> usa tipos genéricos para entrada e saída. Ambos devem ser POJOs com suporte a serialização JSON.

Classe do handler

// 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);
    }
}

Classes de solicitação e resposta

// 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;
    }
}

Exemplo de evento de entrada

{
  "firstName": "FC",
  "lastName": "aliyun"
}

Exemplo: Invocar uma função com gatilho HTTP

Este exemplo demonstra o tratamento de solicitações de gatilho HTTP e o retorno de respostas.

Pré-requisitos

Antes de começar, verifique se você tem:

Uma função criada em runtime Java com o código de exemplo abaixo. Consulte Criar uma função de evento
Um gatilho HTTP configurado para a função. Consulte Configurar um gatilho HTTP

Código de exemplo

O handler utiliza PojoRequestHandler com HTTPTriggerEvent e HTTPTriggerResponse como tipos de entrada e saída. Para formatos de solicitação e resposta, consulte Usar um gatilho HTTP para invocar uma função.

App.java - Classe de entrada

App.java

package example;

import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

import com.aliyun.fc.runtime.Context;
import com.aliyun.fc.runtime.PojoRequestHandler;

public class App implements PojoRequestHandler<HTTPTriggerEvent, HTTPTriggerResponse> {

    @Override
    public HTTPTriggerResponse handleRequest(HTTPTriggerEvent request, Context context) {
        context.getLogger().info("Receive HTTP Trigger request: " + request.toString());
        String requestBody = request.getBody();
        if (request.isIsBase64Encoded()) {
            requestBody = new String(java.util.Base64.getDecoder().decode(request.getBody()), StandardCharsets.UTF_8);
        }
        String message = "HTTP Trigger request body: " + requestBody;
        context.getLogger().info(message);
        Map<String, String> headers = new HashMap<>();
        headers.put("Content-Type", "text/plain");
        return HTTPTriggerResponse.builder().withStatusCode(200).withHeaders(headers).withBody(request.getBody())
                .withIsBase64Encoded(request.isIsBase64Encoded()).build();
    }
}

HTTPTriggerEvent.java - Formato da solicitação

HTTPTriggerEvent.java

package example;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import com.fasterxml.jackson.annotation.JsonProperty;

import java.util.Map;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder(setterPrefix = "with")
public class HTTPTriggerEvent {
    private String version;
    private String rawPath;
    private Map<String, String> headers;
    private Map<String, String> queryParameters;
    private RequestContext requestContext;

    @JsonProperty("isBase64Encoded")
    private boolean IsBase64Encoded;
    private String body;

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @Builder(setterPrefix = "with")
    public static class RequestContext {
        private String accountId;
        private String domainName;
        private String domainPrefix;
        private HttpInfo http;
        private String requestId;
        private String time;
        private String timeEpoch;

        @Data
        @NoArgsConstructor
        @AllArgsConstructor
        @Builder(setterPrefix = "with")
        public static class HttpInfo {
            private String method;
            private String path;
            private String protocol;
            private String sourceIp;
            private String userAgent;
        }
    }

}

HTTPTriggerResponse.java - Formato da resposta

HTTPTriggerResponse.java

package example;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Map;

import com.fasterxml.jackson.annotation.JsonProperty;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder(setterPrefix = "with")
public class HTTPTriggerResponse {
    private int statusCode;
    private Map<String, String> headers;

    @JsonProperty("isBase64Encoded")
    private boolean IsBase64Encoded;
    private String body;
}

Dependências Maven adicionais

Adicione jackson e lombok além do fc-java-core:

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.16.1</version>
</dependency>
<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <version>1.18.30</version>
</dependency>

Invocar a função

Faça login no console do Function Compute. No painel de navegação à esquerda, clique em Functions.
Na barra de navegação superior, selecione uma região. Na página Functions, clique em a função desejada.
Clique em a aba Triggers para obter o endpoint público do gatilho HTTP.

Execute o comando curl abaixo, substituindo a URL pelo endpoint público do seu gatilho:

   curl -i "https://dev-jav-test-fc-luiqas****.cn-shanghai.fcapp.run" -d 'hello fc3.0'

   HTTP/1.1 200 OK
   Content-Disposition: attachment
   Content-Length: 11
   Content-Type: application/json
   X-Fc-Request-Id: 1-652503f2-afbfd2b1dc4dd0fcb0230959
   Date: Tue, 10 Oct 2023 07:57:38 GMT

   hello fc3.0%

Importante

Se o Authentication Method for No Authentication, invoque a função diretamente com Postman ou curl.
Caso o Authentication Method seja Signature Authentication ou JWT Authentication, autentique-se conforme necessário. Consulte Autenticação.

Erros comuns

Este handler requer entrada de gatilho HTTP. A invocação pelo botão Test Function com uma string simples (como "Hello, FC!") gera erro de desserialização:

{
    "errorType": "com.fasterxml.jackson.databind.exc.MismatchedInputException",
    "errorMessage": "Cannot construct instance of `example.HTTPTriggerEvent` (although at least one Creator exists): no String-argument constructor/factory method to deserialize from String value ('Hello, FC!')\n at [Source: (byte[])\"\"Hello, FC!\"\"; line: 1, column: 1]",
    "stackTrace": [
        "com.fasterxml.jackson.databind.exc.MismatchedInputException.from(MismatchedInputException.java:63)",
        "com.fasterxml.jackson.databind.DeserializationContext.reportInputMismatch(DeserializationContext.java:1588)",
        "..."
    ]
}

Para testar este handler, invoque-o pelo endpoint do gatilho HTTP ou forneça um payload JSON compatível com a estrutura HTTPTriggerEvent.

Programas de exemplo

Exemplos de programas para diferentes tipos de handler:

java11-blank-stream-event - Handler de eventos no formato Stream
java11-blank-pojo-event - Handler de eventos no formato POJO