NOTA: Algunos aspectos de este producto están en versión Beta. Las opciones de instalación híbrida son GA. Para unirte al programa Beta, comunícate con tu representante de Apigee.

Cómo manejar los errores de texto destacado de Java

¿Qué es un texto destacado de Java?

Si es la primera vez que usas textos destacados de Java, te recomendamos comenzar con la sección Cómo crear un texto destacado de Java.

Maneja errores en un texto destacado de Java

Cuando escriba un texto destacado de Java, es posible que desee realizar una administración de errores personalizada en su código Java. Por ejemplo, quizás desees mostrar mensajes de error y encabezados personalizados o configurar variables de flujo con información de error en el flujo del proxy en Apigee.

Veamos un ejemplo simple de texto destacado de Java que ilustra los patrones básicos de manejo de errores personalizados. El ejemplo muestra un mensaje de error personalizado cuando ocurre una excepción. También coloca el seguimiento de pila de errores en una variable de flujo, que puede ser una técnica de depuración útil.

Descarga el proyecto

Para simplificar el proceso, puedes descargar este proyecto desde el repositorio de Apigee api-platform-samples en GitHub.

  1. Descarga o clona api-platform-samples en tu sistema.
  2. En una terminal o editor de código de tu elección, ve al proyecto api-platform-samples/doc-samples/java-error.

El código Java de muestra

Los patrones de manejo de errores son directos. Puedes configurar variables de flujo en el contexto de flujo actual de Apigee con el método messageContext.setVariable(). Para mostrar información de error personalizada, crea una instancia ExecutionResult y llama a los métodos en ella a fin de configurar la respuesta y los encabezados de error.

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 tu código con Maven

El proyecto está configurado para que puedas compilar con Maven. Si deseas usar javac, también incluiremos un ejemplo.

  1. Asegúrate de tener instalado Maven: 
    mvn -version
  2. Ejecute la siguiente secuencia de comandos java-error/buildsetup.sh. Esta secuencia de comandos instala las dependencias JAR necesarias en tu repositorio local de Maven.
  3. cd en el directorio java-error/callout.
  4. Ejecuta Maven: 
    mvn clean package
  5. Si lo deseas, verifica que el archivo JAR edge-custom-policy-java-error.jar se copió a java-error/apiproxy/resources/java. Esta es la ubicación requerida para los archivos JAR que deseas implementar con un proxy.

Compila con javac

Si quieres usar javac para compilar el código, puedes hacer algo similar al siguiente (desde el directorio java-error). Los archivos JAR necesarios se proporcionan para el directorio java-error/lib.

  1. cd en api-platform-samples/doc-samples/java-error.
  2. Asegúrate de tener javac en tu ruta de acceso.

    javac -version
  3. Ejecuta el siguiente comando de 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 el archivo JAR al directorio apiproxy/resources/java. Esta es la ubicación requerida para los archivos JAR que deseas implementar con un proxy.

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

Implemente y llame al proxy

Se proporciona una secuencia de comandos de implementación en el directorio ./java-error. Antes de ejecutarlo, debes realizar una configuración rápida.

  1. Esc en api-platform-samples/doc-samples/java-error
  2. La forma más sencilla de implementar el proxy es empaquetarlo en un archivo ZIP y subir el paquete de proxy a un entorno de tu organización de Apigee. Consulta Crea un proxy de API. Asegúrate de usar la opción Subir paquete de proxy. Consulta también Sugerencias y trucos para subir el proxy de API en un paquete de proxy en la comunidad de Apigee.
  3. Cuando el proxy se implemente, intenta llamarlo:
    curl  https://$HOSTNAME/java-error

    Debido a que la llamada no incluye un parámetro de consulta de "nombre", el código de Java muestra un error de entorno de ejecución. El proxy muestra este mensaje y encabezado:

  • Mensaje de error: Please specify a name parameter!
  • Encabezado: ExceptionClass: java.lang.RuntimeException