Function Compute Java handler configuration and examples - Function Compute

Un handler Java traite les événements entrants de votre fonction Function Compute (FC). FC achemine chaque invocation vers la méthode de handler spécifiée dans la configuration de votre fonction.

Remarque

Pour invoquer des fonctions via des déclencheurs HTTP ou des noms de domaine personnalisés, consultez Utiliser un déclencheur HTTP pour invoquer une fonction.

Format du handler

Définissez le paramètre Handler dans la console Function Compute selon le format suivant :

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

Par exemple, si votre package est example, votre classe HelloFC et votre méthode handleRequest :

example.HelloFC::handleRequest

Les noms du package et de la classe sont personnalisables, mais doivent correspondre à la valeur Handler définie dans la configuration de votre fonction. Consultez Créer une fonction événementielle.

Interfaces de handler

Les handlers Java doivent implémenter une interface de la bibliothèque fc-java-core :

Interface	Entrée/Sortie	Cas d'usage
`StreamRequestHandler`	`InputStream` / `OutputStream`	Traitement de flux d'octets bruts ou de données ne correspondant pas à un POJO
`PojoRequestHandler<I, O>`	Types POJO personnalisés	Manipulation de données JSON structurées mappées sur des objets Java

Dépendance Maven

Ajoutez fc-java-core à votre fichier pom.xml :

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

Consultez le référentiel Maven pour obtenir la version la plus récente.

Avant de créer une fonction, empaquetez votre code et la dépendance fc-java-core dans un fichier JAR. Reportez-vous à Compiler et déployer des packages de code.

StreamRequestHandler

L'interface StreamRequestHandler lit les entrées depuis un InputStream et écrit les sorties vers un 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** : contient les données d'événement transmises lors de l'invocation de la fonction.
**outputStream** : reçoit les données retournées par la fonction.
**context** : fournit des informations d'exécution telles que l'ID de requête et la paire d'AccessKey temporaire. Type : com.aliyun.fc.runtime.Context. Consultez Context.

PojoRequestHandler

L'interface PojoRequestHandler<I, O> utilise des types génériques pour les entrées et les sorties. Ces deux types doivent être des POJO prenant en charge la sérialisation JSON.

Classe du 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 requête et de réponse

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

Exemple d'événement d'entrée

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

Exemple : Invoquer une fonction avec un déclencheur HTTP

Cet exemple illustre le traitement des requêtes issues d'un déclencheur HTTP et le renvoi des réponses associées.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

Une fonction créée dans un environnement d'exécution Java, intégrant le code d'exemple ci-dessous. Reportez-vous à Créer une fonction événementielle
Un déclencheur HTTP configuré pour cette fonction. Consultez Configurer un déclencheur HTTP

Code d'exemple

Le handler utilise PojoRequestHandler avec HTTPTriggerEvent et HTTPTriggerResponse comme types d'entrée et de sortie. Pour connaître les formats de requête et de réponse, consultez Utiliser un déclencheur HTTP pour invoquer une fonction.

App.java - Classe d'entrée

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 - Format de requête

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 - Format de réponse

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

Dépendances Maven supplémentaires

Ajoutez jackson et lombok en complément de 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>

Invocation de la fonction

Connectez-vous à la console Function Compute. Dans le volet de navigation de gauche, cliquez sur Functions.
Dans la barre de navigation supérieure, sélectionnez une région. Sur la page Functions, cliquez sur la fonction cible.
Cliquez sur l'onglet Triggers pour récupérer l'endpoint public du déclencheur HTTP.

Exécutez la commande curl suivante en remplaçant l'URL par l'endpoint public de votre déclencheur :

   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%

Important

Si le paramètre Authentication Method est défini sur No Authentication, invoquez directement la fonction à l'aide de Postman ou de curl.
Si le paramètre Authentication Method est défini sur Signature Authentication ou JWT Authentication, authentifiez-vous au préalable. Consultez Authentification.

Erreurs courantes

Ce handler attend une entrée provenant d'un déclencheur HTTP. L'invoquer via le bouton Test Function avec une chaîne simple (telle que "Hello, FC!") provoque une erreur de désérialisation :

{
    "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)",
        "..."
    ]
}

Pour tester ce handler, invoquez-le via l'endpoint du déclencheur HTTP ou fournissez une charge utile JSON conforme à la structure HTTPTriggerEvent.

Programmes d'exemple

Programmes d'exemple pour différents types de handlers :

java11-blank-stream-event - Handler d'événements au format flux
java11-blank-pojo-event - Handler d'événements au format POJO