Questa pagina è stata tradotta dall'API Cloud Translation.

Come creare un callout Java

Stai visualizzando la documentazione di Apigee Edge.
Vai alla sezione Documentazione di Apigee X. Informazioni

Che cos'è un callout Java?

Apigee Edge offre una gamma di criteri che rispondono a requisiti comuni di gestione delle API, come come sicurezza, trasformazione dei dati, gestione del traffico e altro.

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

Per le versioni supportate di Java, consulta la sezione Supportato software e le versioni supportate.

Come faccio a utilizzare il codice Java in un proxy?

Un criterio di callout Java consente di richiamare il codice Java dall'interno di un flusso proxy in esecuzione. Il tuo codice Java il codice deve implementare determinate interfacce Java specifiche per Edge che consentono al codice di interagire con il proxy in esecuzione. Ad esempio, esistono metodi Java per ottenere e impostare intestazioni, parametri, variabili di flusso e altre entità nel contesto di flusso corrente del proxy.

Quando devo utilizzare un callout Java?

Diamo un'occhiata a situazioni in cui i callout Java sono utili e a situazioni in cui prendi in considerazione altri approcci.

Innanzitutto, considera approcci alternativi

Prima di utilizzare un callout Java, tieni presente che potrebbero essere disponibili approcci alternativi . Ad esempio:

Per operazioni leggere, come le chiamate API HTTP a servizi remoti, valuta la possibilità di utilizzare ServiceCallout. Consulta le norme relative ai callout di servizio.
Per interazioni relativamente semplici con il contenuto dei messaggi, come la modifica o l'estrazione Intestazioni, parametri o contenuto dei messaggi HTTP, puoi utilizzare i linguaggi JavaScript o Python.

Cosa puoi fare nel codice Java

Un callout Java supporta le seguenti operazioni di base:

Esame o manipolazione dei messaggi di richiesta o di risposta
Recupero e impostazione delle variabili di flusso. Puoi utilizzare metodi Java per accedere alle variabili di flusso Edge. Se vuoi accedere alle informazioni della mappa chiave-valore (KVM), utilizza un criterio KVM, assegnare valori KVM alle variabili di flusso, dopodiché potrai accedere alle variabili di flusso nel callout Java.
Chiamata a servizi esterni
Aumento dei guasti
Manipolazione di messaggi di errore e codici di stato

Cosa non puoi fare in Java codice

La maggior parte delle chiamate di sistema non è consentita. Non è possibile:

Consente di eseguire operazioni di lettura o scrittura del file system interno. Ciò significa che non puoi utilizzare pacchetti Java per la lettura/scrittura nei file system interni; tuttavia, puoi rendere disponibili chiamate remote.
Ottieni informazioni sul processo attuale, sull'elenco di processi o sull'utilizzo di CPU/memoria su della macchina.
Accedi al codice sorgente in "expressions-1.0.0.jar" e "message-flow-1.0.0.jar".

Sebbene alcune chiamate di questo tipo possano funzionare, non sono supportate e potrebbero essere disattivate attivamente in qualsiasi momento. Evita di effettuare chiamate di questo tipo nel codice.

Non utilizzare o fare affidamento sulle librerie Java incluse in Apigee Edge. Queste biblioteche sono solo per la funzionalità del prodotto Edge e non vi è alcuna garanzia che sia disponibile una libreria dalla release all'uscita. Se usi tali librerie, usale in dimostrazioni non di produzione. .

Ciao callout Java

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

Se passi in un "nome utente" intestazione con un "nome" , 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 nella piattaforma Apigee api-platform-samples.

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

Scrivi il codice Java

Apri il file di origine Java: java-hello/callout/src/main/java/HelloJava.java. Questo file è una versione scheletro della classe Java principale che implementeremo. Il valore sono necessari pacchetti per il codice callout Edge Java. Questi corsi offrono metodi che ti consentono per accedere al contesto di esecuzione del proxy. Vedremo in dettaglio i passaggi per la compilazione e il deployment questo codice a breve.

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: il componente MessageContext consente di accedere alle entità all'interno del flusso in cui viene eseguito il criterio callout Java. Iniziamo indica che il criterio callout Java è collegato al flusso Risposta endpoint proxy. Il codice indicato sopra recupera l'oggetto del messaggio HTTP per quel contesto di flusso. Il Messaggio a sua volta, ti dà accesso a intestazioni, parametri di query, contenuti del corpo variabili.
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 seguendo l'esempio Maven.

Assicurati che Maven sia installato:
```
mvn -version
```
Esegui lo script java-hello/buildsetup.sh. Questo script installa lo script Dipendenze JAR nel repository Maven locale.
cd alla directory java-hello/callout.
Esegui Maven:
```
mvn clean package
```
Nota: se ricevi un errore Maven, assicurati di essere nella java-hello/callout.
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 obbligatoria per File JAR di cui vuoi eseguire il deployment con un proxy.

Compila con javac (facoltativo)

Nella sezione precedente, genererai automaticamente il file JAR Java richiesto con una Comando Maven. In alternativa, se vuoi utilizzare javac per compilare il codice, puoi procedere qualcosa di simile al seguente (dalla directory java-hello). Il campo obbligatorio I file JAR vengono forniti nella directory java-hello/lib.

da CD a api-platform-samples/doc-samples/java-hello.
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/HelloJava.java

Questa operazione crea com/apigeesample/HelloJava.class.

Crea un file JAR contenente la classe compilata nel Directory apiproxy/resources/java. Questa è la posizione richiesta per JAR i file di cui vuoi eseguire il deployment con un proxy. Puoi farlo eseguendo questo 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

È stato fornito uno script di deployment nella directory ./java-hello. Ma prima di eseguirlo, devi effettuare una configurazione rapida.

da CD a api-platform-samples/doc-samples/java-hello
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 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 o se cambi lo script cURL per rimuovere l'intestazione, il comando restituisce "Hello, Guest!"

Informazioni sul proxy

Esaminiamo rapidamente i criteri utilizzati in questo proxy. Fai attenzione a dove si trovano le norme. posizionati nel flusso proxy e perché.

Il criterio Assegna messaggio

Un criterio Assegna messaggio è collegato al flusso di richiesta ProxyEndpoint. it copia l'intestazione del nome utente dalla richiesta e la assegna alla risposta. Questa operazione consente il criterio callout Java, collegato al flusso di risposta, per accedere all'intestazione del nome utente e creare un corpo della risposta personalizzata utilizzando il valore dell'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>

Norme relative ai callout Java

Il criterio di callout Java è collegato al flusso di risposta. Questo perché il codice Java personalizzato modifica le intestazioni e il messaggio della risposta. La classe ClassName del criterio specifica la classe principale eseguita dal criterio. L'elemento ResourceURL è 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

Di seguito sono riportati alcuni aspetti importanti da considerare sull'implementazione di un callout Java:

Importa classi da com.apigee.flow.execution e com.apigee.flow.message di pacchetti. Questi pacchetti devono essere inclusi nel file JAR pacchettizzato e distribuito. Puoi caricare il JAR Java tramite il proxy dell'interfaccia utente di gestione oppure puoi includerlo nella directory /resources/java nei proxy API che che sviluppi localmente.
Implementa l'interfaccia di esecuzione. Qualsiasi codice Java eseguito all'interno di un proxy API deve implementare l'esecuzione.
Un criterio callout Java non contiene codice effettivo. Un criterio callout Java fa invece riferimento a un La risorsa Java "resource", che deve essere pacchettizzata in un JAR.
Nomi dei pacchetti da evitare: non utilizzare io.apigee o com.apigee come nomi di pacchetto 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 JAR indipendenti quindi posiziona i file JAR nella directory /resources/java per per assicurarti che vengano caricati correttamente in fase di runtime.
Se esistono più JAR, è sufficiente aggiungerli come risorse aggiuntive. Non è necessario modificare la configurazione dei criteri per fare riferimento a file JAR aggiuntivi. Inserendo /resources/java è sufficiente.
Per ulteriori informazioni sul caricamento di JAR Java, consulta File di risorse.