Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Come utilizzare le proprietà in un callout Java

Stai visualizzando la documentazione di Apigee Edge.
Consulta la documentazione di Apigee X. info

Che cos'è un callout Java?

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

Utilizzo delle proprietà in un callout Java

Le proprietà consentono di specificare coppie nome/valore in un criterio di callout Java a cui puoi accedere da 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 callout Java che utilizza le proprietà. In questo esempio, creiamo un proxy che include un criterio di callout Java. Il criterio utilizza l' <Properties> elemento per specificare una coppia nome/valore. Nel codice Java, recuperiamo il valore e lo utilizziamo per impostare un'intestazione della risposta.

Scarica il progetto

Per semplificare le cose, 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 api-platform-samples/doc-samples/java-properties progetto.

Il criterio di callout Java

Il criterio utilizza l'elemento <Properties>. Questo elemento consente di specificare coppie nome/valore. In fase di runtime, il codice Java può accedere ai valori delle proprietà specificate in 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 di questo esempio mostra come recuperare una proprietà specificata nel criterio di callout Java. Nel progetto di esempio, puoi trovare il codice sorgente in java-properties/callout/src/main/java/JavaProperties.java. Più avanti in questo argomento, esamineremo i passaggi per compilare ed eseguire il deployment di questo codice.

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 di Maven, assicurati di trovarti nella java-properties/callout directory.
Se vuoi, verifica che il file JAR edge-custom-policy-java-properties.jar sia stato copiato in java-properties/apiproxy/resources/java. Questa è la posizione richiesta 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 eseguire un'operazione simile alla seguente (dalla directory java-properties). I file JAR richiesti sono forniti nella directory java-properties/lib.

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

Esegui il seguente 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 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

Nella directory ./java-properties è disponibile uno script di deployment. Prima di eseguirlo , però, devi eseguire una configurazione rapida.

Vai a api-platform-samples/doc-samples/java-properties
Se non l'hai ancora fatto, apri il file ../../setup/setenv.sh e modificalo come indicato con le informazioni del tuo account Apigee: il tuo nome utente (l'indirizzo email associato al tuo account), il nome dell'organizzazione e il dominio che utilizzi per effettuare chiamate di gestione delle API. Ad esempio, per il cloud Edge, il dominio è https://api.enterprise.apigee.com; tuttavia, il dominio potrebbe essere diverso se utilizzi Edge Private Cloud.
Salva il file setenv.sh.
Esegui lo script di deployment:
```
./deploy.sh
```
Se il deployment ha esito positivo, esegui lo script di chiamata:
```
./invoke.sh
```
Lo script di chiamata esegue 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 criterio abbiamo aggiunto una coppia nome/valore della proprietà "prop/WORLD!". Il callout Java recupera il valore "WORLD!" e lo imposta in un'intestazione chiamata X-PROPERTY-HELLO:
```
messageContext.getMessage().setHeader("X-PROPERTY-HELLO", this.properties.get("prop")); 
```