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

Convertir la réponse en majuscules avec un appel Java

<ph type="x-smartling-placeholder"></ph> Vous consultez la documentation Apigee Edge.
Accédez à la page Documentation sur Apigee X. En savoir plus

Si vous utilisez l'accroche Java pour la première fois, nous vous recommandons de commencer par la section Comment créer un d'accroche.

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

À quoi sert l'exemple de code ?

Le proxy d'API de cet exemple appelle un service cible qui renvoie une réponse JSON simple. La La stratégie d'appel 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 majuscules. Il s'agit d'un exemple simple. mais elle montre à quel point pour faire fonctionner le 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 allons également inclure un exemple à la suite de 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 d'être dans le 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. Mais avant d’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 vous ne l'avez pas déjà fait, ouvrez le fichier ../../setup/setenv.sh et modifiez-le comme indiqué dans vos informations de compte Apigee: votre nom d'utilisateur (l'adresse e-mail associé à votre compte), le nom de votre organisation et le domaine que vous utilisez pour créer l'API de gestion de projet. Par exemple, pour le cloud Edge, le domaine est https://api.enterprise.apigee.com; Cependant, votre domaine peut être différent à l'aide de Edge Private Cloud.
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 ressemble à ceci:

< 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 proxy

Voici une séquence de l'outil Trace montrant le flux du proxy:

Structure du proxy

Il s'agit de la structure du proxy. Notez qu'il inclut un fichier JAR dans le fichier Répertoire apiproxy/resources/java. Veuillez indiquer un fichier JAR. Nous le fournissons mais si vous faites un travail personnalisé, vous devez le créer vous-même et le copier dans ce l'emplacement. Pour obtenir des conseils sur la compilation et le déploiement d'une légende Java, consultez la section How to create a Java d'accroche.

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 Java Call exécute le code Java suivant, qui convertit les en-têtes de réponse et l'attribut en majuscules. Notez que le programme utilise des packages spécifiques à Apigee. Ces packages fournir des objets et des méthodes que vous pouvez utiliser pour interagir directement avec le flux proxy. 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

C'est à vous d'ouvrir le proxy et d'examiner les fichiers. Voici la règle Java Call. Notez qu'elle fait référence à la classe exécutée par l'accroche et au fichier JAR. Tous les appels Java règles suivent ce schéma. Consultez également le Règlement concernant les appels Java.

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