Questa pagina è stata tradotta dall'API Cloud Translation.

Come utilizzare le proprietà in JavaCallout

Questa pagina si applica ad Apigee e Apigee hybrid.

Visualizza la documentazione di Apigee Edge.

Che cos'è un callout Java?

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

Utilizzo delle proprietà nei criteri JavaCallout

Le proprietà consentono di specificare coppie nome/valore in un criterio JavaCallout a cui puoi accedere dal codice Java in fase di runtime. Devi specificare un valore stringa letterale per ogni proprietà; non puoi fare riferimento alle variabili di flusso in questo elemento.

Vediamo un semplice esempio di policy JavaCallout che utilizza le proprietà. In questo esempio, creiamo un proxy che include un criterio JavaCallout. Il criterio utilizza l'elemento <Properties> per specificare una coppia nome/valore. Nel codice Java, recuperiamo il valore e lo utilizziamo per impostare un'intestazione della risposta.

Scaricare il progetto

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

Scarica o clona api-platform-samples sul tuo sistema.
In un terminale o in un editor di codice a tua scelta, vai al progetto api-platform-samples/doc-samples/java-properties.

Il criterio JavaCallout

Il criterio utilizza l'elemento <Properties>. Questo elemento ti consente di specificare coppie nome/valore. In fase di runtime, il codice Java può accedere ai valori delle proprietà specificate nel criterio, come vedremo a 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>

Il codice Java di esempio

Il codice Java per questo esempio mostra come recuperare una proprietà specificata nelle norme JavaCallout. Nel progetto di esempio, puoi trovare il codice sorgente in java-properties/callout/src/main/java/JavaProperties.java. Vedremo i passaggi per compilare e distribuire questo codice più avanti in questo argomento.

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;
		}
	}
}

Compila il codice con Maven

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

Assicurati di aver installato Maven:
```
mvn -version
```
Esegui lo script java-properties/buildsetup.sh. Questo script installa le dipendenze JAR richieste nel repository Maven locale.
Vai alla directory java-properties/callout.
Esegui Maven:
```
mvn clean package
```
Nota:se ricevi un errore Maven, assicurati di trovarti nella directory java-properties/callout.
Se vuoi, verifica che il file JAR edge-custom-policy-java-properties.jar sia stato copiato in java-properties/apiproxy/resources/java. Questo è il percorso obbligatorio per i file JAR che vuoi eseguire il deployment con un proxy.

Compila con javac (facoltativo)

Se vuoi utilizzare javac per compilare il codice, puoi fare qualcosa di simile a quanto segue (dalla directory java-properties). I file JAR richiesti vengono forniti nella directory java-properties/lib.

cd a api-platform-samples/doc-samples/java-properties.
Assicurati di avere javac nel percorso.
```
javac -version
```

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

Crea un file JAR:

jar -cvf edge-custom-policy-java-properties.jar ./com/apigeesample/JavaProperties.class
Copia il file JAR nella directory apiproxy/resources/java. Questa è la posizione richiesta per i file JAR che vuoi eseguire il deployment con un proxy.
```
cp edge-custom-policy-java-properties.jar apiproxy/resources/java
```

Esegui il deployment e chiama il proxy

Nella directory ./java-properties viene fornito uno script di deployment. Ma prima di eseguirlo, devi eseguire una configurazione rapida.

cd a api-platform-samples/doc-samples/java-properties
Il modo più semplice per eseguire il deployment del proxy è raggrupparlo in un file ZIP e caricare il bundle di proxy in un ambiente dell'organizzazione Apigee. Consulta Creazione di un proxy API. Assicurati di utilizzare l'opzione Carica pacchetto proxy. Vedi anche Suggerimenti per caricare il proxy API in un bundle proxy nella community Apigee.
Una volta eseguito il deployment del proxy, prova a chiamarlo:
```
curl  https://$HOSTNAME/java-properties
```
Il proxy restituisce l'intestazione: X-PROPERTY-HELLO: WORLD!. Ricorda che nei criteri abbiamo aggiunto una coppia nome/valore della proprietà "prop/WORLD!". Il criterio JavaCallout recupera il valore "WORLD!" e lo imposta in un'intestazione denominata X-PROPERTY-HELLO:
```
messageContext.getMessage().setHeader("X-PROPERTY-HELLO", this.properties.get("prop"));
```