Java-Callout-Fehler beheben

Sie lesen die Dokumentation zu Apigee X.
Apigee Edge-Dokumentation aufrufen

Was ist ein Java-Callout?

Wenn Sie noch nicht mit Java-Callouts vertraut sind, sollten Sie mit dem Erstellen einer Java-Erweiterung beginnen.

Umgang mit Fehlern in einem Java-Callout

Beim Schreiben eines Java-Callouts kann es hilfreich sein, eine benutzerdefinierte Fehlerbehandlung in Ihrem Java-Code auszuführen. Beispielsweise können Sie benutzerdefinierte Fehlermeldungen und Header zurückgeben und/oder Ablaufvariablen mit Fehlerinformationen im Proxyablauf von Apigee festlegen.

Im Folgenden finden Sie ein einfaches Java-Callout-Beispiel, das einfache benutzerdefinierte Fehlerbehandlungen veranschaulicht. Im Beispiel wird eine benutzerdefinierte Fehlermeldung zurückgegeben, wenn eine Ausnahme auftritt. Außerdem wird der Fehler-Stacktrace in eine Ablaufvariable verschoben, was eine praktische Debugging-Methode sein kann.

Projekt herunterladen

Sie können dieses Projekt aus dem Apigee-Repository api-platform-samples auf GitHub herunterladen.

Laden Sie api-platform-samples in Ihr System herunter oder klonen Sie es.
Wechseln Sie in einem Terminal oder Codeeditor Ihrer Wahl zum api-platform-samples/doc-samples/java-error-Projekt.

Java-Beispielcode

Die Muster zur Fehlerbehandlung sind unkompliziert. Sie können Ablaufvariablen im aktuellen Apigee-Ablaufkontext mit der messageContext.setVariable()-Methode festlegen. Erstellen Sie eine ExecutionResult-Instanz und rufen Sie Methoden dafür auf, um die Fehlerantwort und die Header festzulegen, um benutzerdefinierte Fehlerinformationen zurückzugeben.

package com.apigeesample;

import com.apigee.flow.execution.ExecutionContext;
import com.apigee.flow.execution.ExecutionResult;
import com.apigee.flow.execution.spi.Execution;
import com.apigee.flow.message.MessageContext;
import com.apigee.flow.execution.Action;

import org.apache.commons.lang.exception.ExceptionUtils;

public class JavaError implements Execution {
    public ExecutionResult execute(MessageContext messageContext, ExecutionContext executionContext) {

        try {

                String name = messageContext.getMessage().getHeader("username");

                if (name != null && name.length()>0) {
                        messageContext.getMessage().setContent("Hello, " + name + "!");
                        messageContext.getMessage().removeHeader("username");

                } else {
                        throw new RuntimeException("Please specify a name parameter!");
                }

                return ExecutionResult.SUCCESS;

        } catch (RuntimeException ex) {

            ExecutionResult executionResult = new ExecutionResult(false, Action.ABORT);

            //--Returns custom error message and header
            executionResult.setErrorResponse(ex.getMessage());
            executionResult.addErrorResponseHeader("ExceptionClass", ex.getClass().getName());

            //--Set flow variables -- may be useful for debugging.
            messageContext.setVariable("JAVA_ERROR", ex.getMessage());
            messageContext.setVariable("JAVA_STACKTRACE", ExceptionUtils.getStackTrace(ex));
            return executionResult;
        }
    }
}

Code mit Maven kompilieren

Das Projekt ist so eingerichtet, dass Sie es mit Maven kompilieren können. Wenn Sie javac verwenden möchten, fügen wir außerdem ein Beispiel hinzu.

Prüfen Sie, ob Maven installiert ist:
```
mvn -version
```
Führen Sie das java-error/buildsetup.sh-Skript aus: Mit diesem Skript werden die erforderlichen JAR-Abhängigkeiten in Ihrem lokalen Maven-Repository installiert.
cd in das java-error/callout-Verzeichnis.
Führen Sie Maven aus:
```
mvn clean package
```
Hinweis: Achten Sie darauf, dass Sie sich im java-error/callout-Verzeichnis befinden, wenn Sie einen Maven-Fehler erhalten.
Prüfen Sie bei Bedarf, ob die edge-custom-policy-java-error.jar-JAR-Datei nach java-error/apiproxy/resources/java kopiert wurde. Dies ist der erforderliche Speicherort für JAR-Dateien, die Sie mit einem Proxy bereitstellen möchten.

Kompilieren mit javac

Wenn Sie javac verwenden möchten, um den Code zu kompilieren, können Sie beispielsweise Folgendes ausführen (aus dem java-error-Verzeichnis). Die erforderlichen JAR-Dateien werden im java-error/lib-Verzeichnis für Sie bereitgestellt.

cd in api-platform-samples/doc-samples/java-error.
Achten Sie darauf, dass Ihr Pfad javac enthält.
```
javac -version
```

Führen Sie den folgenden javac-Befehl aus:

javac -d . -classpath ./lib/expressions-1.0.0.jar:./lib/message-flow-1.0.0.jar:. callout/src/main/java/JavaProperties.java

Kopieren Sie die JAR-Datei in das Verzeichnis apiproxy/resources/java. Dies ist der erforderliche Speicherort für JAR-Dateien, die Sie mit einem Proxy bereitstellen möchten.
```
cp com/apigeesample/JavaProperties.class apiproxy/resources/java
```

Proxy bereitstellen und aufrufen

Ein Bereitstellungsskript wird im ./java-error-Verzeichnis bereitgestellt. Bevor Sie es ausführen, müssen Sie jedoch eine schnelle Einrichtung vornehmen.

CD zu api-platform-samples/doc-samples/java-error
Die einfachste Methode zum Bereitstellen des Proxys besteht darin, ihn in einer ZIP-Datei zu bündeln und das Proxy-Bundle in eine Umgebung in Ihrer Apigee-Organisation hochzuladen. Siehe API-Proxy erstellen. Verwenden Sie unbedingt die Option Proxyproxy hochladen. Weitere Informationen finden Sie auch unter Tipps und Tricks zum Hochladen eines API-Proxys in einem Proxy-Bundle in der Apigee-Community.
Wenn der Proxy bereitgestellt ist, versuchen Sie, ihn aufzurufen:
```
curl  https://$HOSTNAME/java-error
```
Da der Aufruf keinen Suchparameter "name" enthält, löst der Java-Code einen Laufzeitfehler aus. Der Proxy gibt diese Nachricht und diesen Header zurück:

Fehlermeldung: Please specify a name parameter!
Header: ExceptionClass: java.lang.RuntimeException