Se usó la API de Cloud Translation para traducir esta página.

Cómo crear un texto destacado de Java

Estás consultando la documentación de Apigee Edge.
Consulta la documentación de Apigee X. Información

¿Qué es un texto destacado de Java?

Apigee Edge proporciona una variedad de políticas que abordan requisitos comunes de administración de APIs, como seguridad, transformación de datos y administración del tráfico, entre otros.

Sin embargo, hay algunos casos en los que tu API requiere un comportamiento personalizado que no se implemente en una política estándar. En estos casos, Apigee proporciona varias opciones que te permiten codificar o crear secuencias de comandos de comportamientos de la API personalizados. Un enfoque consiste en implementar el comportamiento deseado en Java.

Para conocer las versiones compatibles de Java, consulta Software y versiones compatibles.

¿Cómo uso el código Java en un proxy?

Una política de texto destacado de Java te permite llamar a un código de Java desde el flujo de un proxy en ejecución. Tu código Java debe implementar ciertas interfaces de Java específicas de Edge que permiten que el código interactúe con el proxy en ejecución. Por ejemplo, existen métodos de Java para obtener y configurar encabezados, parámetros de búsqueda, variables de flujo y otras entidades dentro del contexto de flujo actual del proxy.

¿Cuándo debo usar un texto destacado de Java?

Analicemos situaciones en las que los textos destacados de Java son útiles y situaciones en las que debes considerar otros enfoques.

Primero, considera enfoques alternativos

Antes de usar un texto destacado de Java, ten en cuenta que puede haber enfoques alternativos que puedes usar en su lugar. Por ejemplo:

Para operaciones ligeras, como las llamadas a la API HTTP a servicios remotos, considera usar la política ServiceCallout. Consulta Política de texto destacado de servicio.
Para interacciones relativamente simples con el contenido del mensaje, como modificar o extraer encabezados HTTP, parámetros o contenido de mensajes, puedes usar lenguajes de Python o JavaScript.

Qué puedes hacer en el código de Java

Un texto destacado de Java admite estas operaciones básicas:

Examinar o manipular mensajes de solicitud o respuesta
Obtener y configurar variables de flujo. Puedes usar métodos de Java para acceder a las variables de flujo de Edge. Si deseas acceder a la información del mapa de clave-valor (KVM), usa una política de KVM, asigna valores de KVM a las variables de flujo y, luego, podrás acceder a las variables de flujo desde el texto destacado de Java.
Llama a servicios externos
Generar fallas
Manipula mensajes de error y códigos de estado

Qué no puedes hacer en el código de Java

La mayoría de las llamadas al sistema no están permitidas. No puedes hacer lo siguiente:

Realizar operaciones de lectura ni escritura en el sistema de archivos internos. Esto significa que no puedes usar ninguno de los paquetes de Java para leer o escribir en sistemas de archivos internos. Sin embargo, puedes realizar llamadas remotas externas.
Obtener información sobre el proceso actual, la lista de procesos o el uso de CPU o memoria en la máquina.
Acceder al código fuente en ʻexpressions-1.0.0.jar` y `message-flow-1.0.0.jar`.

Si bien algunas llamadas pueden funcionar, no son compatibles y están sujetas a la inhabilitación activa en cualquier momento. Evita hacer esas llamadas en tu código.

No uses las bibliotecas de Java incluidas en Apigee Edge ni dependas de ellas. Esas bibliotecas son solo para las funciones del producto Edge y no hay garantía de que haya una biblioteca disponible de un lanzamiento a otro. Si usas esas bibliotecas, úsalas solo en demostraciones sin producción.

Texto destacado de Java de Hello

Veamos un ejemplo básico de texto destacado de Java de Hello World. En este ejemplo, creamos un proxy simple con un texto destacado de Java que muestra una respuesta “hello world”. El proxy puede mostrar una de las dos respuestas posibles:

Si pasas un encabezado de "nombre de usuario" con un valor de "nombre", el proxy mostrará lo siguiente:
```
Hello, <name>!
```
Si omites el encabezado, el proxy solo mostrará lo siguiente:
```
"Hello, Guest!"
```

Descarga el proyecto inicial

A fin de simplificar el proceso, tenemos un proyecto básico preparado para ti en GitHub en el repositorio api-platform-samples de Apigee.

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

Escribe el código de Java

Abre el archivo fuente de Java: java-hello/callout/src/main/java/HelloJava.java. Este archivo es una versión básica de la clase principal de Java que implementaremos. Los paquetes importados son obligatorios para el código de texto destacado de Edge para Java. Estas clases proporcionan métodos que te permiten acceder al contexto de ejecución del proxy. En breve, explicaremos los pasos para compilar e implementar este código.

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;


public class HelloJava implements Execution {

        public ExecutionResult execute(MessageContext messageContext, ExecutionContext executionContext) {
                
                try {

                        // Your code here.
            
            return ExecutionResult.SUCCESS;

                } catch (Exception e) {
                        return ExecutionResult.ABORT;
                }
        }

}

Reemplaza la línea con comentarios // Your code here por el siguiente código:
```
String name = messageContext.getMessage().getHeader("username");

if (name != null && name.length()>0) {
        messageContext.getMessage().setContent("Hello, " + name + "!");
        messageContext.getMessage().removeHeader("username");
} else {
        messageContext.getMessage().setContent("Hello, Guest!");
}
```
Nota: Nota: El objeto MessageContext te permite acceder a entidades dentro del flujo en el que se ejecuta la política de texto destacado de Java. Supongamos que la política de texto destacado de Java está adjunta al flujo de respuesta de extremo del proxy. Con el código anterior, se obtiene el objeto HTTP Message para ese contexto de flujo. El objeto Message, a su vez, te brinda acceso a encabezados, parámetros de consulta, contenido del cuerpo y variables de flujo.
Guarda el archivo.

Compila tu código con Maven

El proyecto está configurado para que puedas compilar con Maven. Si deseas usar javac, incluiremos un ejemplo a continuación del ejemplo de Maven.

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

Compila con javac (opcional)

En la sección anterior, generaste automáticamente el archivo JAR de Java requerido con un comando de Maven. De forma alternativa, si quieres usar javac para compilar el código, puedes hacer algo similar a lo siguiente (desde el directorio java-hello). Los archivos JAR necesarios se proporcionan en el directorio java-hello/lib.

cd a api-platform-samples/doc-samples/java-hello.
Asegúrate de tener javac en tu ruta de acceso.
```
javac -version
```

Ejecuta el siguiente comando javac:

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

Esto crea com/apigeesample/HelloJava.class.

Crea un archivo JAR que contenga la clase compilada en el directorio apiproxy/resources/java. Esta es la ubicación requerida para los archivos JAR que deseas implementar con un proxy. Para ello, ejecuta el siguiente comando en el directorio java-hello (no olvides el punto al final).
```
jar cvf apiproxy/resources/java/edge-custom-policy-java-hello.jar -C com .
```

Implementa y llama al proxy

Se proporciona una secuencia de comandos de implementación en el directorio ./java-hello. Pero antes de ejecutarla, debes hacer una configuración rápida.

Ve a api-platform-samples/doc-samples/java-hello
Si aún no lo hiciste, abre el archivo ../../setup/setenv.sh y edítalo como se indica con la información de tu cuenta de Apigee: tu nombre de usuario (la dirección de correo electrónico asociada con tu cuenta), el nombre de tu organización y el dominio que usas para realizar llamadas de administración de API. Por ejemplo, para la nube perimetral, el dominio es https://api.enterprise.apigee.com. Sin embargo, el dominio puede ser diferente si usas la nube privada perimetral.
Guarda el archivo setenv.sh.
Ejecuta la secuencia de comandos de implementación:
```
./deploy.sh
```
Si la implementación se realiza correctamente, ejecuta la secuencia de comandos de invocación:
```
./invoke.sh
```
La secuencia de comandos de invocación llama a un comando cURL similar al siguiente:
```
curl  http://$org-$env.$api_domain/java-hello -H "username:Will"
```
Lo que muestra “Hello, Will!”

Puedes editar la secuencia de comandos invoke.sh para cambiar el nombre o, si cambias la llamada cURL para quitar el encabezado, el comando mostrará el mensaje "Hello, Guest!".

Acerca del proxy

Examinemos con rapidez las políticas que se usan en este proxy. Presta atención al lugar en el que se ubican las políticas en el flujo del proxy y los motivos de esa ubicación.

La política de asignación de mensajes

Se adjunta una política de asignación de mensajes al flujo de solicitud de ProxyEndpoint. Copia el encabezado del nombre de usuario de la solicitud y lo asigna a la respuesta. Esta operación permite que la política de texto destacado de Java, que se adjunta al flujo de respuesta, acceda al encabezado del nombre de usuario y compile un cuerpo de respuesta personalizado con el valor de ese encabezado.

<AssignMessage async="false" continueOnError="false" enabled="true" name="CopyHeader">     
    <DisplayName>CopyHeader</DisplayName>     
    <Copy source="request">         
        <Headers>             
          <Header name="username"/>         
        </Headers>     
    </Copy>     
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>     
    <AssignTo createNew="false" transport="http" type="response"/> 
</AssignMessage>

La política de texto destacado de Java

La política de texto destacado de Java se adjunta al flujo de respuesta. Esto se debe a que el código personalizado de Java realiza cambios en los encabezados y el mensaje de la respuesta. El elemento ClassName de la política especifica la clase principal que ejecuta la política. El elemento ResourceURL es el nombre del archivo JAR que compilaste y agregaste al directorio resources/java del proxy.

<JavaCallout name="hello-java">         
    <ClassName>com.apigeesample.HelloJava</ClassName>         
    <ResourceURL>java://edge-custom-policy-java-hello.jar</ResourceURL> 
</JavaCallout>

Qué necesitas saber sobre el texto destacado de Java

A continuación, se indican los aspectos importantes que se deben tener en cuenta sobre la implementación de un texto destacado de Java:

Importa clases desde los paquetes com.apigee.flow.execution y com.apigee.flow.message. Estos paquetes deben incluirse en el archivo JAR que se empaqueta e implementa. Puedes subir tu JAR de Java con el editor de proxy de la IU de administración o puedes incluirlo en el directorio /resources/java en los proxies de API que desarrollas de manera local.
Implementa la interfaz de ejecución. Cualquier código de Java que se ejecute dentro de un proxy de API debe implementar la ejecución.
Una política de texto destacado de Java no contiene código real, En cambio, una política de texto destacado de Java hace referencia a un “recurso” de Java, que debes empaquetar en un JAR.
Nombres de paquete que se deben evitar: No uses io.apigee ni com.apigee como nombres de paquete en los textos destacados de Java. Esos nombres están reservados y son usados por otros módulos de Apigee.
Si tu texto destacado de Java depende de bibliotecas de terceros adicionales empaquetadas como archivos JAR independientes, ubica también esos archivos JAR en el directorio /resources/java para asegurarte de que se carguen de forma correcta en el entorno de ejecución.
Si hay varios JAR, solo agrégalos como recursos adicionales. No necesitas modificar la configuración de la política para hacer referencia a archivos JAR adicionales. Ubicarlos en /resources/java es suficiente.
Para obtener información sobre cómo subir JAR de Java, consulta Archivos de recursos.