Questa pagina è stata tradotta dall'API Cloud Translation.

Come utilizzare le proprietà in un 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.

Utilizzo delle proprietà in un callout Java

Le proprietà consentono di specificare coppie di nomi/valore in un criterio di callout Java a cui puoi accedere da il tuo codice Java in fase di runtime. Devi specificare un valore letterale di stringa per ogni proprietà. non puoi variabili di flusso di riferimento in questo elemento.

Esaminiamo un semplice esempio di callout Java che utilizza le proprietà. In questo esempio, creare un proxy che includa un criterio di callout Java. Il criterio utilizza il parametro <Properties> per specificare una coppia nome/valore. Nel codice Java, recupera il valore e utilizzalo per impostare un'intestazione della risposta.

Scarica il progetto

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

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

Norme relative ai callout Java

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 in le norme, 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à che è stata specificata nel Norme sui callout Java. Nel progetto di esempio, puoi trovare il codice sorgente java-properties/callout/src/main/java/JavaProperties.java. In questo video vedremo come i passaggi per la compilazione e il deployment del 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.
cd alla directory java-properties/callout.
Esegui Maven:
```
mvn clean package
```
Nota: se ricevi un errore Maven, assicurati di essere nella java-properties/callout directory.
Se vuoi, verifica che il file JAR edge-custom-policy-java-properties.jar è stato copiato in java-properties/apiproxy/resources/java. Questo è il campo obbligatorio posizione per i file JAR di cui vuoi eseguire il deployment con un proxy.

Compila con javac (facoltativo)

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

da CD a api-platform-samples/doc-samples/java-properties.
Assicurati che nel percorso sia presente javac.
```
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 obbligatoria per i file JAR di cui vuoi eseguire il deployment con un proxy.
```
cp edge-custom-policy-java-properties.jar apiproxy/resources/java
```

Esegui il deployment e chiama il proxy

È stato fornito uno script di deployment nella directory ./java-properties. Ma prima di devi eseguire una configurazione rapida.

da CD a api-platform-samples/doc-samples/java-properties
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.
Salva il file setenv.sh.
Esegui lo script di deployment:
```
./deploy.sh
```
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-properties
```
Il proxy restituisce l'intestazione: X-PROPERTY-HELLO: WORLD!. Ricorda che nel , abbiamo aggiunto una coppia nome/valore proprietà "prop/WORLD!". Callout Java recupera il valore "WORLD!" e lo imposta in un'intestazione denominata X-PROPERTY-HELLO:
```
messageContext.getMessage().setHeader("X-PROPERTY-HELLO", this.properties.get("prop")); 
```