Questa pagina è stata tradotta dall'API Cloud Translation.

Converti la risposta in lettere maiuscole con un callout Java

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

Se stai provando il callout Java per la prima volta, ti consigliamo di iniziare con Come creare un callout Java callout.

Questo esempio di libro di ricette mostra come creare un semplice criterio JavaCallout che esegue codice Java personalizzato nel contesto di un flusso proxy.

Che cosa fa il codice campione?

Il proxy API in questo esempio chiama un servizio di destinazione che restituisce una semplice risposta JSON. La Il criterio callout Java viene posizionato nel flusso di risposta target. Il codice Java converte le intestazioni contenuto della risposta in lettere maiuscole. Questo è un semplice esempio: ma spiega come per far funzionare codice Java personalizzato nel contesto di un proxy API su Edge.

Prova l'anteprima

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

Compila il codice con Maven

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

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

Compila con javac

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

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

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 com/apigeesample/ResponseUppercase.class apiproxy/resources/java
```

Esegui il deployment e chiama il proxy

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

da CD a api-platform-samples/doc-samples/java-cookbook
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-cookbook/json
```

La risposta avrà un aspetto simile a questo:

< HTTP/1.1 200 OK
< Date: Tue, 09 May 2017 20:31:08 GMT
< Content-Type: APPLICATION/JSON; CHARSET=UTF-8
< Content-Length: 68
< Connection: keep-alive
< Access-Control-Allow-Origin: *
< ETag: W/"44-RA5ERT/MMLIK54NVBWBSZG"
< X-Powered-By: APIGEE
< Server: Apigee Router
<
* Curl_http_done: called premature == 0
* Connection #0 to host willwitman-test.apigee.net left intact
{"FIRSTNAME":"JOHN","LASTNAME":"DOE","CITY":"SAN JOSE","STATE":"CA"}

Flusso proxy

Questa è una ripresa dello strumento di traccia che mostra il flusso del proxy:

Struttura del proxy

Questa è la struttura del proxy. Tieni presente che include un file JAR nella Directory apiproxy/resources/java. Il JAR è obbligatorio. Forniamo queste informazioni ma se esegui un lavoro personalizzato, devi crearlo autonomamente e copiarlo in ogni località. Per indicazioni sulla compilazione e la distribuzione di un callout Java, consulta Come creare un callout Java callout.

java-cookbook

    apiproxy
        java-cookbook.xml
    policies
        responseUppercase.xml
    proxies
        default.xml
    resources
        java
            ResponseUppercase.jar
    targets
        default.xml

Informazioni sul codice Java

Il criterio callout Java esegue il seguente codice Java, che converte le intestazioni della risposta e il corpo della risposta in maiuscolo. Tieni presente che il programma utilizza pacchetti specifici di Apigee. Questi pacchetti fornisce oggetti e metodi che puoi utilizzare per interagire direttamente con il flusso del proxy. Metodi che ti consentono di ottenere e impostare variabili di flusso, intestazioni, contenuti dei messaggi e altro ancora.

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.Set; 

public class ResponseUppercase implements Execution{
    public ExecutionResult execute(MessageContext messageContext, ExecutionContext executionContext) {
        try {
            Set headers = messageContext.getMessage().getHeaderNames();
            for (String header : headers) {
                String h = messageContext.getMessage().getHeader(header).toUpperCase();
                messageContext.getMessage().setHeader(header, h);
            }
            String content = messageContext.getMessage().getContent();
            messageContext.getMessage().setContent(content.toUpperCase());
            return ExecutionResult.SUCCESS;
        } catch (Exception e) {
                return ExecutionResult.ABORT;
        }
    }
}

Esamina il proxy di esempio

Lasciamo a te l'autorizzazione ad aprire il proxy ed esaminare i file. Di seguito sono riportate le norme relative ai callout Java. Nota che fa riferimento alla classe eseguita dal callout e al file JAR. Tutti i callout Java seguono questo schema. Consulta anche le norme relative ai callout Java.

<JavaCallout name="responseUppercase">         
    <ClassName>com.apigeesample.ResponseUppercase</ClassName>         
    <ResourceURL>java://ResponseUppercase.jar</ResourceURL> 
</JavaCallout>