Come gestire gli errori di callout Java

Stai visualizzando la documentazione di Apigee Edge.
Consulta la documentazione di Apigee X. info

Che cos'è un callout Java?

Se non hai mai utilizzato i callout Java, ti consigliamo di iniziare con la sezione Come creare un callout Java.

Gestire gli errori in un callout Java

Quando scrivi un callout Java, potresti voler eseguire la gestione degli errori personalizzata nel codice Java. Ad esempio, potresti voler restituire messaggi di errore e intestazioni personalizzati e/o impostare variabili di flusso con informazioni sugli errori nel flusso del proxy su Edge.

Vediamo un semplice esempio di callout Java che illustra i pattern di base per la gestione degli errori personalizzata. L'esempio restituisce un messaggio di errore personalizzato quando si verifica un'eccezione. Inserisce anche lo stacktrace dell'errore in una variabile di flusso, che può essere una tecnica di debug utile.

Scaricare il progetto

Per semplificare le operazioni, puoi scaricare questo progetto dal repository api-platform-samples di Apigee su GitHub.

  1. Scarica o clona api-platform-samples sul tuo sistema.
  2. In un terminale o in un editor di codice a tua scelta, vai al api-platform-samples/doc-samples/java-error progetto.

Il codice Java di esempio

I pattern di gestione degli errori sono semplici. Puoi impostare le variabili di flusso nel contesto del flusso Edge corrente con il metodo messageContext.setVariable(). Per restituire informazioni sugli errori personalizzate, crea un'istanza ExecutionResult e chiama i metodi per impostare la risposta e le intestazioni di errore.

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


Compilare il codice con Maven

Il progetto è configurato in modo che tu possa compilare con Maven. Se vuoi utilizzare javac, includeremo anche un esempio.

  1. Assicurati di aver installato Maven: 
    mvn -version
  2. Esegui lo script java-error/buildsetup.sh. Questo script installa le dipendenze JAR richieste nel repository Maven locale.
  3. Vai alla directory java-error/callout.
  4. Esegui Maven: 
    mvn clean package
  5. Se vuoi, verifica che il file JAR edge-custom-policy-java-error.jar sia stato copiato in java-error/apiproxy/resources/java. Questa è la posizione richiesta per file JAR che vuoi eseguire il deployment con un proxy.

Compilare con javac

Se vuoi utilizzare javac per compilare il codice, puoi eseguire un'operazione simile alla seguente (dalla directory java-error). I file JAR richiesti sono forniti per te nella java-error/lib directory.

  1. Vai a api-platform-samples/doc-samples/java-error.
  2. Assicurati di avere javac nel percorso.

    javac -version
  3. Esegui il seguente comando javac:

    javac -d . -classpath ./lib/expressions-1.0.0.jar:./lib/message-flow-1.0.0.jar:. callout/src/main/java/JavaProperties.java
  4. Copia il file JAR nella directory apiproxy/resources/java. Questa è la posizione richiesta per i file JAR che vuoi eseguire il deployment con un proxy.

    cp com/apigeesample/JavaProperties.class apiproxy/resources/java

Eseguire il deployment e chiamare il proxy

Nella directory ./java-error è disponibile uno script di deployment. Prima di eseguirlo, però, devi eseguire una configurazione rapida.

  1. Vai a api-platform-samples/doc-samples/java-error
  2. Se non l'hai ancora fatto, apri il file ../../setup/setenv.sh e modificalo come indicato con le informazioni del tuo account Apigee: il tuo nome utente (l'indirizzo email associato al tuo account), il nome dell'organizzazione e il dominio che utilizzi per effettuare chiamate di gestione delle API. Ad esempio, per il cloud Edge, il dominio è https://api.enterprise.apigee.com; tuttavia, il dominio potrebbe essere diverso se utilizzi Edge Private Cloud.
  3. Salva il file setenv.sh.
  4. Esegui lo script di deployment: 
    ./deploy.sh
  5. Se il deployment ha esito positivo, esegui lo script di chiamata: 
    ./invoke.sh

    Lo script di chiamata chiama un comando cURL simile al seguente:

    curl  http://$org-$env.$api_domain/java-error

    Poiché la chiamata non include un parametro di query "name", il codice Java genera un errore di runtime. Il proxy restituisce questo messaggio e questa intestazione:

  • Messaggio di errore: Please specify a name parameter!
  • Intestazione: ExceptionClass: java.lang.RuntimeException