Come gestire gli errori dei callout Java

Stai visualizzando la documentazione di Apigee Edge.
Vai alla documentazione di Apigee X.
informazioni

Che cos'è un callout Java?

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

Gestione degli errori in un callout Java

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

Esaminiamo un semplice esempio di callout Java che illustra i pattern di gestione degli errori personalizzati di base. L'esempio restituisce un messaggio di errore personalizzato quando si verifica un'eccezione. Inoltre, inserisce lo stacktrace degli errori in una variabile di flusso, che può essere una tecnica di debug pratica.

Scarica il progetto

Per semplificare le cose, 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 progetto api-platform-samples/doc-samples/java-error.

Il codice Java di esempio

I pattern di gestione degli errori sono semplici. Puoi impostare variabili di flusso nel contesto di flusso perimetrale attuale con il metodo messageContext.setVariable(). Per restituire informazioni personalizzate sugli errori, crea un'istanza ExecutionResult e chiama i metodi su di essa 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;
        }
    }
}


Compila il codice con Maven

Il progetto è configurato in modo da poter eseguire la compilazione con Maven. Se vuoi utilizzare javac, includeremo anche un esempio.

  1. Assicurati di avere installato Maven:
    mvn -version
    
  2. Esegui lo script java-error/buildsetup.sh. Questo script installa le dipendenze JAR necessarie nel repository Maven locale.
  3. cd nella 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 obbligatoria per i file JAR di cui vuoi eseguire il deployment con un proxy.

Compila con javac

Se vuoi utilizzare javac per compilare il codice, puoi eseguire una procedura simile a quella riportata di seguito (dalla directory java-error). I file JAR richiesti sono forniti nella directory java-error/lib.

  1. CD su api-platform-samples/doc-samples/java-error.
  2. Assicurati che nel percorso sia presente javac.

    javac -version
    
  3. Esegui questo 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 obbligatoria per i file JAR di cui vuoi eseguire il deployment con un proxy.

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

Esegui il deployment e chiama il proxy

Nella directory ./java-error è presente uno script di deployment. Ma prima di eseguirlo, devi eseguire una configurazione rapida.

  1. CD 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 i dati del tuo account Apigee: il tuo nome utente (l'indirizzo email associato al tuo account), il nome della tua organizzazione e il dominio che utilizzi per effettuare chiamate di gestione delle API. Ad esempio, per il cloud perimetrale, 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!
  • Titolo: ExceptionClass: java.lang.RuntimeException