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

Converti la risposta in lettere maiuscole con un callout Java

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

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

Questo esempio di ricetta mostra come creare una semplice policy 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 policy Java Callout viene inserita nel flusso di risposta di destinazione. Il codice Java converte le intestazioni e i contenuti della risposta in lettere maiuscole. È un esempio semplice, ma illustra come far funzionare il codice Java personalizzato nel contesto di un proxy API su Edge.

Provare l'esempio

Scaricare il progetto

Per semplificare le operazioni, 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-cookbook progetto.

Compilare il codice con Maven

Il progetto è configurato in modo che tu possa compilare con Maven. Se vuoi utilizzare javac, includeremo anche un esempio dopo l'esempio di 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.
Vai alla directory java-cookbool/callout.
Esegui Maven:
```
mvn clean package
```
Nota: se ricevi un errore di Maven, assicurati di trovarti 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 richiesta per file JAR che vuoi eseguire il deployment con un proxy.

Compilare con javac

Se vuoi utilizzare javac per compilare il codice, puoi eseguire un'operazione simile alla seguente (dalla java-cookbook directory). I file JAR richiesti sono forniti per te nella java-cookbook/lib directory.

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

Copia il file JAR nella directory apiproxy/resources/java. Questa è la posizione richiesta per i file JAR che vuoi eseguire il deployment con un proxy.
```
cp com/apigeesample/ResponseUppercase.class apiproxy/resources/java
```

Eseguire il deployment e chiamare il proxy

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

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

La risposta ha un aspetto simile al seguente:

< 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

Ecco uno screenshot 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 apiproxy/resources/java directory. Il file JAR è obbligatorio. Lo forniamo per l' esempio, ma se stai eseguendo un lavoro personalizzato, devi crearlo tu e copiarlo in questa posizione. Per indicazioni sulla compilazione e sul deployment di un callout Java, vedi 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

La policy Java Callout esegue il seguente codice Java, che converte le intestazioni della risposta e il corpo della risposta in lettere maiuscole. Tieni presente che il programma utilizza pacchetti specifici di Apigee. Questi pacchetti forniscono oggetti e metodi che puoi utilizzare per interagire direttamente con il flusso proxy. Esistono metodi che consentono di recuperare 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;
        }
    }
}

Esaminare il proxy di esempio

Ti lasciamo aprire il proxy ed esaminare i file. Ecco la policy Java Callout. Nota come fa riferimento alla classe eseguita dal callout e al file JAR. Tutte le policy Java Callout seguono questo pattern. Vedi anche Policy Java Callout.

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