Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Convertir la réponse en majuscules avec un appel Java

Vous consultez la documentation Apigee Edge.
Accédez à la documentation**Apigee X**. info

Si vous essayez un appel Java pour la première fois, nous vous recommandons de commencer par consulter la section Créer un appel Java callout.

Cet exemple de guide pratique montre comment créer une règle JavaCallout simple qui exécute du code Java personnalisé dans le contexte d'un flux de proxy.

Que fait l'exemple de code ?

Le proxy d'API de cet exemple appelle un service cible qui renvoie une réponse JSON simple. La règle d'appel Java est placée dans le flux de réponse cible. Le code Java convertit les en-têtes et le contenu de la réponse en majuscules. Il s'agit d'un exemple simple, mais il illustre comment faire fonctionner du code Java personnalisé dans le contexte d'un proxy d'API sur Edge.

Essayer l'exemple

Télécharger le projet

Le moyen le plus simple pour découvrir ce projet est de le télécharger à partir du dépôt api-platform-samples d'Apigee sur GitHub.

Téléchargez ou clonez api-platform-samples sur votre système.
Dans le terminal ou l'éditeur de code de votre choix, accédez au api-platform-samples/doc-samples/java-cookbook projet.

Compiler le code avec Maven

Le projet est configuré pour que vous puissiez le compiler avec Maven. Si vous souhaitez utiliser javac, un exemple suit l'exemple Maven.

Assurez-vous que Maven est installé :
```
mvn -version
```
Exécutez le script java-cookbook/buildsetup.sh. Ce script installe les dépendances JAR requises dans votre dépôt local Maven.
Accédez au répertoire java-cookbool/callout à l'aide de la commande cd.
Exécutez Maven :
```
mvn clean package
```
Remarque : Si vous obtenez une erreur Maven, vérifiez que vous êtes bien dans le java-cookbook/callout répertoire.
Si vous le souhaitez, vérifiez que le fichier JAR edge-custom-policy-java-cookbook.jar a bien été copié dans le répertoire java-cookbook/apiproxy/resources/java. C'est à cet emplacement que doivent se trouver les fichiers JAR que vous souhaitez déployer avec un proxy.

Compiler avec javac

Si vous souhaitez utiliser javac pour compiler le code, vous pouvez employez quelque chose de semblable à ce qui suit (à partir du java-cookbook directory). Les fichiers JAR requis sont fournis dans le répertoire java-cookbook/lib.

Accédez au répertoire api-platform-samples/doc-samples/java-cookbook à l'aide de la commande cd.
Assurez-vous que javac se trouve dans la variable PATH.
```
javac -version
```

Exécutez la commande javac suivante :

javac -d . -classpath ./lib/expressions-1.0.0.jar:./lib/message-flow-1.0.0.jar:. callout/src/main/java/ResponseUppercase.java

Copiez le fichier JAR dans le répertoire apiproxy/resources/java. C'est à cet emplacement que doivent se trouver les fichiers JAR que vous souhaitez déployer avec un proxy.
```
cp com/apigeesample/ResponseUppercase.class apiproxy/resources/java
```

Déployer et appeler le proxy

Un script de déploiement est fourni dans le répertoire ./java-cookbook. Toutefois, avant de l'exécuter , vous devez effectuer une configuration rapide.

Accédez au répertoire api-platform-samples/doc-samples/java-cookbook à l'aide de la commande cd.
Si ce n'est pas déjà fait, ouvrez le fichier ../../setup/setenv.sh et modifiez le comme indiqué avec les informations de votre compte Apigee : votre nom d'utilisateur (adresse e-mail associée à votre compte), le nom de votre organisation et le domaine que vous utilisez pour effectuer des appels de gestion des API. Par exemple, pour le cloud Edge, le domaine est https://api.enterprise.apigee.com ; toutefois, votre domaine peut être différent si vous utilisez le cloud privé Edge.
Enregistrez le fichier setenv.sh.
Exécutez le script de déploiement :
```
./deploy.sh
```
Si le déploiement réussit, exécutez le script d'appel :
```
./invoke.sh
```
Le script d'appel appelle une commande cURL qui se présente comme suit :
```
curl  http://$org-$env.$api_domain/java-cookbook/json
```

La réponse se présente comme suit :

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

Flux de proxy

Voici une capture de l'outil de trace montrant le flux du proxy :

Structure du proxy

Voici la structure du proxy. Notez qu'il inclut un fichier JAR dans le apiproxy/resources/java répertoire. Le fichier JAR est obligatoire. Nous le fournissons pour l' exemple, mais si vous effectuez un travail personnalisé, vous devez le créer vous-même et le copier à cet emplacement. Pour obtenir des conseils sur la compilation et le déploiement d'un appel Java, consultez la section Créer un appel Java callout.

java-cookbook

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

À propos du code Java

La règle d'appel Java exécute le code Java suivant, qui convertit les en-têtes de réponse et le corps de la réponse en majuscules. Notez que le programme utilise des packages spécifiques à Apigee. Ces packages fournissent des objets et des méthodes que vous pouvez utiliser pour interagir directement avec le flux de proxy. Il existe des méthodes qui vous permettent d'obtenir et de définir des variables de flux, des en-têtes, le contenu des messages, etc.

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

Examiner l'exemple de proxy

Nous vous laissons le soin d'ouvrir le proxy et d'examiner les fichiers. Voici la règle d'appel Java. Notez comment elle fait référence à la classe que l'appel exécute et au fichier JAR. Toutes les règles d'appel Java suivent ce modèle. Consultez également la section Règle d'appel Java.

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