Come gestire gli errori dei callout Java

Stai visualizzando la documentazione di Apigee Edge.
Vai alla sezione Documentazione di Apigee X. Informazioni

Che cos'è un callout Java?

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

Gestione degli errori in un callout Java

Quando scrivi un callout Java, potrebbe essere utile eseguire una gestione personalizzata degli errori nel codice Java. Per 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.

Esaminiamo un semplice esempio di callout Java che illustra la gestione di base degli errori personalizzata. pattern. L'esempio restituisce un messaggio di errore personalizzato quando si verifica un'eccezione. Inoltre, inserisce l'analisi dello stack degli errori in una variabile di flusso, che può essere una tecnica di debug molto utile.

Scarica il progetto

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

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

Il codice Java di esempio

I pattern di gestione degli errori sono semplici. Puoi impostare le variabili di flusso nel Contesto del flusso perimetrale con il metodo messageContext.setVariable(). Per restituire un servizio personalizzato le informazioni sull'errore, costruisci un'istanza ExecutionResult e richiama metodi su quest'ultima 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 essere compilato 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 lo script Dipendenze JAR nel repository Maven locale.
3. cd 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 obbligatoria per File JAR di cui vuoi eseguire il deployment con un proxy.

Compila con javac

Se vuoi utilizzare javac per compilare il codice, puoi fare qualcosa di simile alla (dalla directory java-error). I file JAR richiesti sono forniti nella directory java-error/lib.

1. da CD a 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

È stato fornito uno script di deployment nella directory ./java-error. Ma prima di eseguirlo, devi effettuare una configurazione rapida.

1. da CD a api-platform-samples/doc-samples/java-error
2. Se non lo hai già fatto, apri il file ../../setup/setenv.sh e modifica come indicato con le informazioni del tuo account Apigee: il tuo nome utente (l'indirizzo email associati al tuo account), il nome della tua organizzazione e il dominio che utilizzi per creare l'API per la gestione delle chiamate. Ad esempio, per Edge Cloud, il dominio viene https://api.enterprise.apigee.com; ma il tuo dominio potrebbe essere diverso utilizzando il cloud privato perimetrale.
3. Salva il file setenv.sh.
4. Esegui lo script di deployment:

   ./deploy.sh
   

5. Se il deployment viene eseguito correttamente, 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
   

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

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

di Gemini Advanced.