Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utilisation d'un kit SDK Java généré par API Gateway pour une API REST
<a name="how-to-call-apigateway-generated-java-sdk"></a>

Dans cette section, nous présentons les étapes relatives à l'utilisation d'un kit SDK Java généré par API Gateway pour une API REST en utilisant l'API [Simple Calculator](simple-calc-lambda-api-swagger-definition.md) comme exemple. Avant de poursuivre, vous devez suivre la procédure indiquée dans [Générer SDKs pour REST APIs dans API Gateway](how-to-generate-sdk.md). 

**Pour installer et utiliser un kit SDK Java généré par API Gateway**

1. Extrayez le contenu du fichier .zip généré par API Gateway que vous avez téléchargé plus tôt.

1. Téléchargez et installez [Apache Maven](https://maven.apache.org/) (version 3.5 ou ultérieure).

1. Téléchargez et installez le kit [JDK 8](https://docs.oracle.com/javase/8/docs/technotes/guides/install/install_overview.html).

1. Définissez la variable d’environnement `JAVA_HOME`.

1.  Accédez au dossier SDK décompressé où se trouve le fichier pom.xml. Ce dossier est `generated-code` par défaut. Exécutez la commande **mvn install** pour installer les fichiers d'artefact compilés dans votre référentiel Maven local. Cela crée un dossier `target` contenant la bibliothèque de kits SDK compilés. 

1.  Entrez la commande suivante dans un répertoire vide pour créer un stub de projet client et appeler l'API à l'aide de la bibliothèque de kit SDK installée. 

   ```
   mvn -B archetype:generate \
       -DarchetypeGroupdId=org.apache.maven.archetypes \
       -DgroupId=examples.aws.apig.simpleCalc.sdk.app \
       -DartifactId=SimpleCalc-sdkClient
   ```
**Note**  
 Le séparateur `\` de la commande précédente est inclus pour faciliter la lecture. La commande entière doit figurer sur une seule ligne sans le séparateur. 

    Cette commande crée un stub d'application. Le stub de l'application contient un fichier `pom.xml` et un dossier `src` sous le répertoire racine du projet (*SimpleCalc-sdkClient* dans la commande précédente). A l'origine, il existe deux fichiers sources : `src/main/java/{package-path}/App.java` et `src/test/java/{package-path}/AppTest.java`. Dans cet exemple, le *\$1chemin d'accès au package\$1* est `examples/aws/apig/simpleCalc/sdk/app`. Ce chemin d'accès au package provient de la valeur `DarchetypeGroupdId`. Vous pouvez utiliser le fichier `App.java` comme modèle pour votre application cliente et vous pouvez en ajouter d'autres dans le même dossier si nécessaire. Vous pouvez utiliser le fichier `AppTest.java` comme modèle de test unitaire pour votre application et vous pouvez ajouter d'autres fichiers de code de test dans le même dossier de test si nécessaire. 

1. Mettez à jour les dépendances de package dans le fichier `pom.xml` généré avec ce qui suit, en remplaçant les propriétés `groupId`, `artifactId`, `version` et `name` de votre projet si nécessaire :

   ```
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>examples.aws.apig.simpleCalc.sdk.app</groupId>
     <artifactId>SimpleCalc-sdkClient</artifactId>
     <packaging>jar</packaging>
     <version>1.0-SNAPSHOT</version>
     <name>SimpleCalc-sdkClient</name>
     <url>http://maven.apache.org</url>
   
      <dependencies>
         <dependency>
             <groupId>com.amazonaws</groupId>
             <artifactId>aws-java-sdk-core</artifactId>
             <version>1.11.94</version>
         </dependency>
         <dependency>
             <groupId>my-apig-api-examples</groupId>
             <artifactId>simple-calc-sdk</artifactId>
             <version>1.0.0</version>
         </dependency>
         
       <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.12</version>
         <scope>test</scope>
       </dependency>
   
       <dependency>
           <groupId>commons-io</groupId>
           <artifactId>commons-io</artifactId>
           <version>2.5</version>
       </dependency>    
     </dependencies>
   
     <build>
       <plugins>
         <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>3.5.1</version>
           <configuration>
             <source>1.8</source>
             <target>1.8</target>
           </configuration>
         </plugin>
       </plugins>
     </build>
   </project>
   ```
**Note**  
 Lorsqu'une version plus récente de l'artéfact dépendant de `aws-java-sdk-core` n'est pas compatible avec la version indiquée ci-dessus (`1.11.94`), vous devez mettre à jour la balise `<version>` vers la nouvelle version.

1.  Ensuite, nous montrons comment appeler l'API à l'aide du kit SDK en appelant les méthodes `getABOp(GetABOpRequest req)`, `getApiRoot(GetApiRootRequest req)` et `postApiRoot(PostApiRootRequest req)` du kit SDK. Ces méthodes correspondent aux méthodes `GET /{a}/{b}/{op}`, `GET /?a={x}&b={y}&op={operator}`, et `POST /`, avec, respectivement, la charge utile des demandes d'API `{"a": x, "b": y, "op": "operator"}`. 

    Mettez à jour le fichier `App.java` comme suit : 

   ```
   package examples.aws.apig.simpleCalc.sdk.app;
   
   import java.io.IOException;
   
   import com.amazonaws.opensdk.config.ConnectionConfiguration;
   import com.amazonaws.opensdk.config.TimeoutConfiguration;
   
   import examples.aws.apig.simpleCalc.sdk.*;
   import examples.aws.apig.simpleCalc.sdk.model.*;
   import examples.aws.apig.simpleCalc.sdk.SimpleCalcSdk.*;
   
   public class App 
   {
       SimpleCalcSdk sdkClient;
   
       public App() {
           initSdk();
       }
   
       // The configuration settings are for illustration purposes and may not be a recommended best practice.
       private void initSdk() {
           sdkClient = SimpleCalcSdk.builder()
                 .connectionConfiguration(
                     new ConnectionConfiguration()
                           .maxConnections(100)
                           .connectionMaxIdleMillis(1000))
                 .timeoutConfiguration(
                     new TimeoutConfiguration()
                           .httpRequestTimeout(3000)
                           .totalExecutionTimeout(10000)
                           .socketTimeout(2000))
           .build();
   
       }
       // Calling shutdown is not necessary unless you want to exert explicit control of this resource.
       public void shutdown() {
           sdkClient.shutdown();
       }
        
       // GetABOpResult getABOp(GetABOpRequest getABOpRequest)
       public Output getResultWithPathParameters(String x, String y, String operator) {
       	operator = operator.equals("+") ? "add" : operator;
       	operator = operator.equals("/") ? "div" : operator; 
   
           GetABOpResult abopResult = sdkClient.getABOp(new GetABOpRequest().a(x).b(y).op(operator));
           return abopResult.getResult().getOutput();
       }
   
       public Output getResultWithQueryParameters(String a, String b, String op) {
           GetApiRootResult rootResult = sdkClient.getApiRoot(new GetApiRootRequest().a(a).b(b).op(op));
           return rootResult.getResult().getOutput();
       }
   
       public Output getResultByPostInputBody(Double x, Double y, String o) {
       	PostApiRootResult postResult = sdkClient.postApiRoot(
       		new PostApiRootRequest().input(new Input().a(x).b(y).op(o)));
       	return postResult.getResult().getOutput();
       }
   
       public static void main( String[] args )
       {
           System.out.println( "Simple calc" );
           // to begin
           App calc = new App();
           
           // call the SimpleCalc API
           Output res = calc.getResultWithPathParameters("1", "2", "-");
           System.out.printf("GET /1/2/-: %s\n", res.getC());
   
           // Use the type query parameter
           res = calc.getResultWithQueryParameters("1", "2", "+");
           System.out.printf("GET /?a=1&b=2&op=+: %s\n", res.getC());
   
           // Call POST with an Input body.
           res = calc.getResultByPostInputBody(1.0, 2.0, "*");
           System.out.printf("PUT /\n\n{\"a\":1, \"b\":2,\"op\":\"*\"}\n %s\n", res.getC());
   
           
       }
   }
   ```

    Dans l'exemple précédent, les paramètres de configuration utilisés pour instancier le client du kit SDK le sont à titre d'illustration et ne sont pas nécessairement la bonne pratique recommandée. En outre, l'appel de `sdkClient.shutdown()`est facultatif, surtout si vous avez besoin d'un contrôle précis du moment où libérer des ressources. 

 Nous avons montré les modèles essentiels pour appeler une API à l'aide d'un kit SDK Java. Vous pouvez étendre les instructions à l'appel d'autres méthodes de l'API.