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

Come creare un callout Java

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

Che cos'è un callout Java?

Apigee Edge fornisce una serie di policy che soddisfano i requisiti comuni di gestione delle API, come sicurezza, trasformazione dei dati, gestione del traffico e altro ancora.

Tuttavia, in alcuni casi l'API richiede un comportamento personalizzato che non è implementato in una policy standard. In questi casi, Apigee offre diverse opzioni che consentono di creare script o codice per il comportamento personalizzato delle API. Un approccio consiste nell'implementare il comportamento desiderato in Java.

Per le versioni di Java supportate, consulta Software supportato e versioni supportate.

Come faccio a utilizzare il codice Java in un proxy?

Una policy di callout Java consente di chiamare il codice Java da un flusso proxy in esecuzione. Il codice Java deve implementare alcune interfacce Java specifiche di Edge che consentono al codice di interagire con il proxy in esecuzione. Ad esempio, esistono metodi Java per ottenere e impostare intestazioni, parametri di ricerca , variabili di flusso e altre entità all'interno del contesto di flusso corrente del proxy.

Quando devo utilizzare un callout Java?

Diamo un'occhiata alle situazioni in cui i callout Java sono utili e a quelle in cui dovresti prendere in considerazione altri approcci.

Innanzitutto, prendi in considerazione approcci alternativi

Prima di utilizzare un callout Java, tieni presente che potrebbero esistere approcci alternativi che puoi utilizzare invece. Ad esempio:

Per operazioni leggere, come le chiamate API HTTP ai servizi remoti, valuta la possibilità di utilizzare la policy ServiceCallout. Consulta la policy Service Callout.
Per interazioni relativamente semplici con i contenuti dei messaggi, come la modifica o l'estrazione intestazioni, parametri o contenuti dei messaggi HTTP, puoi utilizzare i linguaggi JavaScript o Python.

Cosa puoi fare nel codice Java

Un callout Java supporta queste operazioni di base:

Esaminare o manipolare i messaggi di richiesta o risposta
Ottenere e impostare le variabili di flusso. Puoi utilizzare i metodi Java per accedere alle variabili di flusso Edge. Se vuoi accedere alle informazioni della mappa chiave-valore (KVM), utilizza una policy KVM, assegna i valori KVM alle variabili di flusso e poi puoi accedere alle variabili di flusso da all'interno del callout Java.
Chiamare servizi esterni
Generare errori
Manipolare i messaggi di errore e i codici di stato

Cosa non puoi fare nel codice Java

La maggior parte delle chiamate di sistema non sono consentite. Non puoi:

Eseguire letture o scritture del file system interno. Ciò significa che non puoi utilizzare nessuno dei pacchetti Java per leggere/scrivere nei file system interni; tuttavia, puoi effettuare chiamate remote esterne.
Ottenere informazioni sul processo corrente, sull'elenco dei processi o sull'utilizzo di CPU/memoria sulla macchina su la macchina.
Accedere al codice sorgente in `expressions-1.0.0.jar` e `message-flow-1.0.0.jar`.

Anche se alcune di queste chiamate potrebbero funzionare, non sono supportate e possono essere disattivate attivamente at in qualsiasi momento. Evita di effettuare queste chiamate nel codice.

Non utilizzare o fare affidamento sulle librerie Java incluse in Apigee Edge. Queste librerie sono destinate esclusivamente alla funzionalità del prodotto Edge e non è garantita la disponibilità di una libreria da una release all'altra. Se utilizzi queste librerie, usale solo in dimostrazioni non di produzione solo.

Callout Java Hello

Vediamo un esempio di callout Java di base "Hello World". In questo esempio, creiamo un semplice proxy con un callout Java che restituisce una risposta "Hello World". Il proxy può restituire una delle due risposte possibili:

Se passi un'intestazione "username" con un valore "name", il proxy restituisce:
```
Hello, <name>!
```
Se ometti l'intestazione, il proxy restituisce semplicemente:
```
"Hello, Guest!"
```

Scarica il progetto iniziale

Per semplificare le cose, abbiamo preparato un progetto di base su GitHub nel repository Apigee api-platform-samples.

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-hello progetto.

Scrivi il codice Java

Apri il file di origine Java: java-hello/callout/src/main/java/HelloJava.java. Questo file è una versione scheletrica della classe Java principale che implementeremo. I pacchetti importati sono necessari per il codice di callout Java Edge. Queste classi forniscono metodi che consentono di accedere al contesto di esecuzione del proxy. A breve vedremo 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;


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

}

Sostituisci la riga commentata // Your code here con il seguente codice:
```
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: l'oggetto MessageContext consente di accedere alle entità all'interno del flusso in cui viene eseguita la policy di callout Java. Supponiamo che la policy di callout Java sia collegata al flusso di risposta dell'endpoint proxy. Il codice elencato sopra recupera l'oggetto messaggio HTTP per quel contesto di flusso. L'oggetto Message , a sua volta, ti consente di accedere a intestazioni, parametri di ricerca, contenuti del corpo e variabili di flusso.
Salva il file.

Compila il codice con Maven

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

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

Compila con javac (facoltativo)

Nella sezione precedente, il file JAR Java richiesto viene generato automaticamente con un comando Maven. In alternativa, se vuoi utilizzare javac per compilare il codice, puoi eseguire un'operazione simile alla seguente (dalla directory java-hello). I file JAR richiesti sono forniti nella java-hello/lib directory.

Vai a api-platform-samples/doc-samples/java-hello.
Assicurati di avere javac nel 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/HelloJava.java

Viene creato com/apigeesample/HelloJava.class.

Crea un file JAR contenente la classe compilata nella apiproxy/resources/java directory. Questa è la posizione richiesta per i file JAR che vuoi eseguire il deployment con un proxy. Puoi farlo eseguendo il seguente comando nella directory java-hello (non dimenticare il punto alla fine).
```
jar cvf apiproxy/resources/java/edge-custom-policy-java-hello.jar -C com .
```

Esegui il deployment e chiama il proxy

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

Vai a api-platform-samples/doc-samples/java-hello
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 tuo 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 chiama un comando cURL simile al seguente:
```
curl  http://$org-$env.$api_domain/java-hello -H "username:Will"
```
Che restituisce "Hello, Will!

Puoi modificare lo script invoke.sh per cambiare il nome oppure, se modifichi la chiamata cURL per rimuovere l'intestazione, il comando restituisce "Hello, Guest!"

Informazioni sul proxy

Esaminiamo rapidamente le policy utilizzate in questo proxy. Presta attenzione alla posizione delle policy nel flusso proxy e al motivo.

La policy Assign Message

Una policy Assign Message è collegata al flusso di richiesta ProxyEndpoint. Copia l'intestazione del nome utente dalla richiesta e la assegna alla risposta. Questa operazione consente alla policy di callout Java, collegata al flusso di risposta, di accedere all'intestazione del nome utente e di creare un corpo di risposta personalizzato utilizzando il valore di questa intestazione.

<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 policy di callout Java

La policy di callout Java è collegata al flusso di risposta. Questo perché il codice Java personalizzato apporta modifiche alle intestazioni e al messaggio di risposta. L'elemento ClassName della policy specifica la classe principale eseguita dalla policy. L'elemento ResourceURL è il nome del file JAR che hai creato e aggiunto alla directory resources/java del proxy.

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

Cosa devi sapere sul callout Java

Ecco alcuni aspetti importanti da tenere presenti sull'implementazione di un callout Java:

Importa le classi dai pacchetti com.apigee.flow.execution e com.apigee.flow.message. Questi pacchetti devono essere inclusi nel file JAR che viene pacchettizzato ed eseguito il deployment. Puoi caricare il file JAR Java tramite l'editor proxy dell'interfaccia utente di gestione oppure puoi includerlo nella directory /resources/java nei proxy API che sviluppi localmente.
Implementa l'interfaccia Execution. Qualsiasi codice Java eseguito all'interno di un proxy API deve implementare Execution.
Una policy di callout Java non contiene codice effettivo. Al contrario, una policy di callout Java fa riferimento a una risorsa Java, che devi pacchettizzare in un file JAR.
Nomi di pacchetti da evitare: non utilizzare io.apigee o com.apigee come nomi di pacchetti nei callout Java. Questi sono riservati e utilizzati da altri moduli Apigee.
Se il callout Java si basa su librerie di terze parti aggiuntive pacchettizzate come file JAR indipendenti, inserisci questi file JAR anche nella directory /resources/java per assicurarti che vengano caricati correttamente in fase di runtime.
Se sono presenti più file JAR, aggiungili semplicemente come risorse aggiuntive. Non è necessario modificare la configurazione della policy per fare riferimento a file JAR aggiuntivi. È sufficiente inserirli in /resources/java
Per ulteriori informazioni sul caricamento dei file JAR Java, consulta File di risorse.