Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Von API Gateway generiertes Java-SDK für eine REST-API verwenden
<a name="how-to-call-apigateway-generated-java-sdk"></a>

In diesem Abschnitt werden die Schritte zur Verwendung eines von API Gateway generierten Java-SDKs für eine REST-API unter Verwendung der [Simple Calculator](simple-calc-lambda-api-swagger-definition.md)-API als Beispiel vorgestellt. Bevor Sie fortfahren, müssen Sie die in [Generieren Sie SDKs für REST APIs in API Gateway](how-to-generate-sdk.md) beschriebenen Schritte durchführen. 

**So installieren und verwenden Sie ein von API Gateway generiertes Java-SDK:**

1. Extrahieren Sie den Inhalt der von API Gateway generierten ZIP-Datei, die Sie zuvor heruntergeladen haben.

1. Laden Sie [Apache Maven](https://maven.apache.org/) (Version 3.5 oder höher) herunter, und installieren Sie es.

1. Laden Sie [JDK 8](https://docs.oracle.com/javase/8/docs/technotes/guides/install/install_overview.html) herunter und installieren Sie die Software.

1. Legen Sie die `JAVA_HOME`-Umgebungsvariable fest.

1.  Öffnen Sie den entpackten SDK-Ordner, in dem die Datei pom.xml gespeichert ist. Dieser Ordner heißt standardmäßig `generated-code`. Führen Sie den Befehl **mvn install** aus, um die kompilierten Artefaktdateien in Ihrem lokalen Maven-Repository zu installieren. Dadurch wird ein Ordner namens `target` erzeugt, der die kompilierte SDK-Bibliothek enthält. 

1.  Geben Sie den folgenden Befehl in einem leeren Verzeichnis ein, um ein Client-Projekt-Stub zu erstellen, um die API über die installierte SDK-Bibliothek aufzurufen. 

   ```
   mvn -B archetype:generate \
       -DarchetypeGroupdId=org.apache.maven.archetypes \
       -DgroupId=examples.aws.apig.simpleCalc.sdk.app \
       -DartifactId=SimpleCalc-sdkClient
   ```
**Anmerkung**  
 Das Trennzeichen `\` in dem vorausgehenden Befehl dient der besseren Lesbarkeit. Der gesamte Befehl sollte in einer einzelnen Zeile ohne das Trennzeichen stehen. 

    Mit diesem Befehl wird ein Anwendungs-Stub erstellt. Das Anwendungs-Stub enthält die Datei `pom.xml` und einen `src`-Ordner im Stammverzeichnis des Projekts (*SimpleCalc sdkClient* im vorausgehenden Befehl). Anfänglich gibt es zwei Quelldateien: `src/main/java/{package-path}/App.java` und `src/test/java/{package-path}/AppTest.java`. In diesem Beispiel ist *\$1package-path\$1* `examples/aws/apig/simpleCalc/sdk/app`. Dieser Paketpfad ist von dem Wert `DarchetypeGroupdId` abgeleitet. Sie können die Datei `App.java` als Vorlage für Ihre Client-Anwendung verwenden, und Sie können nach Bedarf weitere in demselben Ordner hinzufügen. Sie können die Datei `AppTest.java` als Testvorlage für Ihre Anwendung benutzen, und Sie können nach Bedarf weitere Testcode-Dateien in demselben Ordner hinzufügen. 

1. Aktualisieren Sie die Paket-Abhängigkeiten in der generierten Datei `pom.xml` wie folgt; ersetzen Sie dabei nötigenfalls die Eigenschaften `groupId`, `artifactId`, `version` und `name` Ihres Projekts:

   ```
   <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>
   ```
**Anmerkung**  
 Wenn eine neuere Version des abhängigen Artefakts von `aws-java-sdk-core` nicht mit der Version des oben angegebenen (`1.11.94`) kompatibel ist, müssen Sie das `<version>`-Tag auf die neue Version aktualisieren.

1.  Als Nächstes zeigen wir, wie Sie die API mithilfe des SDK aufrufen, indem Sie die SDK-Methoden `getABOp(GetABOpRequest req)`, `getApiRoot(GetApiRootRequest req)` und `postApiRoot(PostApiRootRequest req)` aufrufen. Diese Methoden entsprechen den Methoden `GET /{a}/{b}/{op}`, `GET /?a={x}&b={y}&op={operator}` und `POST /`, mit einer jeweiligen Nutzlast von `{"a": x, "b": y, "op": "operator"}`-API-Anforderungen. 

    Aktualisieren Sie die Datei `App.java` wie folgt: 

   ```
   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());
   
           
       }
   }
   ```

    Im vorherigen Beispiel dienen die zum Instanziieren des SDK-Clients verwendeten Konfigurationseinstellungen zur Veranschaulichung und sind nicht notwendigerweise als empfohlene bewährte Methode zu verstehen. Darüber hinaus erfolgt das Aufrufen von `sdkClient.shutdown()` optional, besonders dann, wenn Sie eine genaue Kontrolle über das Freisetzen von Ressourcen benötigen. 

 Wir haben die wichtigsten Muster zum Aufrufen einer API über ein Java SDK gezeigt. Sie können die Anweisungen auch zum Aufrufen anderer API-Methoden verwenden.