Esta página se ha traducido con Cloud Translation API.

Cómo usar las propiedades en JavaCallout

Esta página se aplica a Apigee y Apigee Hybrid.

Consulta la documentación de Apigee Edge.

¿Qué es una llamada de código Java?

Si no has usado nunca JavaCallouts, te recomendamos que empieces con el artículo Cómo crear una llamada de código Java.

Usar propiedades en políticas JavaCallout

Las propiedades le permiten especificar pares nombre/valor en una política JavaCallout a los que puede acceder desde su código Java en tiempo de ejecución. Debe especificar un valor de cadena literal para cada propiedad. No puede hacer referencia a variables de flujo en este elemento.

Vamos a ver un ejemplo sencillo de una política JavaCallout que usa propiedades. En este ejemplo, creamos un proxy que incluye una política JavaCallout. La política usa el elemento <Properties> para especificar un par nombre/valor. En el código Java, obtenemos el valor y lo usamos para definir un encabezado de respuesta.

Descargar el proyecto

Para simplificar las cosas, puedes descargar este proyecto del repositorio api-platform-samples de Apigee en GitHub.

Descarga o clona api-platform-samples en tu sistema.
En el terminal o editor de código que prefieras, ve al proyecto api-platform-samples/doc-samples/java-properties.

Política JavaCallout

La política usa el elemento <Properties>. Este elemento te permite especificar pares de nombre/valor. En tiempo de ejecución, tu código Java puede acceder a los valores de las propiedades especificadas en la política, como veremos en breve.

<JavaCallout name="java-callout">
    <ClassName>com.apigeesample.JavaProperties</ClassName>
    <ResourceURL>java://edge-custom-policy-java-properties.jar</ResourceURL>
    <Properties>
        <Property name="prop">WORLD!</Property>
    </Properties>
</JavaCallout>

Código de muestra de Java

El código Java de este ejemplo muestra cómo obtener una propiedad que se ha especificado en la política JavaCallout. En el proyecto de ejemplo, puedes encontrar el código fuente en java-properties/callout/src/main/java/JavaProperties.java. Más adelante en este tema, veremos 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;

import java.util.Map;

public class JavaProperties implements Execution {

	private Map <String,String> properties; // read-only

	public JavaProperties(Map <String,String> properties) {
	        this.properties = properties;
	}

	public ExecutionResult execute(MessageContext messageContext, ExecutionContext executionContext) {

		try {

		    messageContext.getMessage().setHeader("X-PROPERTY-HELLO", this.properties.get("prop"));

            return ExecutionResult.SUCCESS;

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

Compilar el código con Maven

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

Asegúrate de que tienes instalado Maven:
```
mvn -version
```
Ejecuta la secuencia de comandos java-properties/buildsetup.sh. Esta secuencia de comandos instala las dependencias JAR necesarias en tu repositorio Maven local.
Ve al directorio java-properties/callout.
Ejecuta Maven:
```
mvn clean package
```
Nota: Si aparece un error de Maven, asegúrate de que estás en el directorio java-properties/callout.
Si quieres, comprueba que el archivo JAR edge-custom-policy-java-properties.jar se ha copiado en java-properties/apiproxy/resources/java. Esta es la ubicación obligatoria de los archivos JAR que quieras implementar con un proxy.

Compilar con javac (opcional)

Si quieres usar javac para compilar el código, puedes hacer algo parecido a lo siguiente (desde el directorio java-properties). Los archivos JAR necesarios se proporcionan en el directorio java-properties/lib.

cd a api-platform-samples/doc-samples/java-properties.
Asegúrate de que tienes javac en tu ruta.
```
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/JavaProperties.java

Crea un archivo JAR:

jar -cvf edge-custom-policy-java-properties.jar ./com/apigeesample/JavaProperties.class
Copia el archivo JAR en el directorio apiproxy/resources/java. Esta es la ubicación obligatoria de los archivos JAR que quieras implementar con un proxy.
```
cp edge-custom-policy-java-properties.jar apiproxy/resources/java
```

Implementar y llamar al proxy

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

cd a api-platform-samples/doc-samples/java-properties
La forma más sencilla de desplegar el proxy es empaquetarlo en un archivo ZIP y subirlo a un entorno de tu organización de Apigee. Consulta Crear un proxy de APIs. Asegúrate de usar la opción Subir paquete proxy. Consulta también Consejos y trucos para subir un proxy de API en un paquete de proxy en la comunidad de Apigee.
Cuando se haya implementado el proxy, prueba a llamarlo:
```
curl  https://$HOSTNAME/java-properties
```
El proxy devuelve el encabezado X-PROPERTY-HELLO: WORLD!. Recuerda que en la política hemos añadido un par nombre/valor de propiedad "prop/WORLD!". La política JavaCallout recupera el valor "WORLD!" y lo define en un encabezado llamado X-PROPERTY-HELLO:
```
messageContext.getMessage().setHeader("X-PROPERTY-HELLO", this.properties.get("prop"));
```