Cette page a été traduite par l'API Cloud Translation.

Convertir la réponse en majuscules avec une accroche Java

Vous consultez la documentation sur Apigee Edge.
Consultez la documentation sur Apigee X.

Si vous essayez d'utiliser l'accroche Java pour la première fois, nous vous recommandons de commencer par lire Créer une accroche Java.

Cet exemple de livre de recettes montre comment créer une règle Javaaccroche simple qui exécute du code Java personnalisé dans un contexte de flux proxy.

Que fait l'exemple de code ?

Dans cet exemple, le proxy d'API appelle un service cible qui renvoie une réponse JSON simple. La stratégie d'accroche Java est placée sur le flux de réponse cible. Le code Java convertit les en-têtes et le contenu de la réponse en lettres majuscules. Il s'agit d'un exemple simple. Toutefois, il montre comment obtenir 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 projet api-platform-samples/doc-samples/java-cookbook.

Compiler le code avec Maven

Le projet est configuré pour que vous puissiez le compiler avec Maven. Si vous souhaitez utiliser javac, nous incluons également un exemple qui 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, assurez-vous que vous vous trouvez dans le répertoire java-cookbook/callout.
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 répertoire java-cookbook). 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. Avant de l'exécuter, vous devez toutefois procéder à une configuration rapide.

Accédez au répertoire api-platform-samples/doc-samples/java-cookbook à l'aide de la commande cd.
Si vous ne l'avez 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 passer des appels de gestion des API. Par exemple, pour le cloud périphérique, le domaine est https://api.enterprise.apigee.com. Cependant, votre domaine peut être différent si vous utilisez un cloud privé périphérique.
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 suivant :
```
./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 un plan de l'outil de trace montrant le flux du proxy:

Structure du proxy

Il s'agit de la structure du proxy. Notez qu'il contient un fichier JAR dans le répertoire apiproxy/resources/java. Le fichier JAR est obligatoire. Nous fournissons cet exemple 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'une accroche Java, consultez Créer une accroche Java.

java-cookbook

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

À propos du code Java

La stratégie d'accroche 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 faire pour ouvrir le proxy et examiner les fichiers. Voici la règle relative aux appels Java. Notez qu'il fait référence à la classe exécutée par l'accroche et au fichier JAR. Toutes les règles sur les accroches Java suivent ce schéma. Consultez également la Règle sur les accroches Java.

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