Utilizzo di un SDK Java generato da API Gateway per un'API REST

In questa sezione verranno illustrate, a titolo di esempio, le fasi necessarie per utilizzare un SDK Java generato da API Gateway per un'API REST mediante l'API del calcolatore semplice. Per poter procedere, è necessario avere completato le fasi descritte in Genera SDKs per REST APIs in API Gateway.

Per installare e utilizzare l'SDK Java generato da API Gateway

1. Estrai il contenuto del file .zip generato da API Gateway scaricato precedentemente.

2. Scaricare e installare Apache Maven (versione 3.5 o successiva).

3. Scaricare e installare JDK 8.

4. Imposta la variabile di ambiente JAVA_HOME.

5. Passa alla cartella dell'SDK decompressa in cui si trova il file pom.xml. Per impostazione predefinita, questa cartella è generated-code. Eseguire il comando mvn install per installare i file di artefatto compilati nel repository Maven locale. Viene creata una cartella target contenente la libreria SDK compilata.

6. Digita il comando seguente in una directory vuota per creare uno stub di progetto del client e chiamare l'API mediante la libreria SDK installata.

   mvn -B archetype:generate \
       -DarchetypeGroupdId=org.apache.maven.archetypes \
       -DgroupId=examples.aws.apig.simpleCalc.sdk.app \
       -DartifactId=SimpleCalc-sdkClient

   Nota

   Nel comando precedente è stato inserito il separatore \ per maggiore leggibilità. Il comando deve trovarsi su un'unica riga senza il separatore.

   Questo comando crea uno stub di applicazione. Lo stub dell'applicazione contiene un pom.xml file e una src cartella nella directory principale del progetto (SimpleCalc-SdkClient nel comando precedente). Inizialmente sono presenti due file di origine: src/main/java/{package-path}/App.java e src/test/java/{package-path}/AppTest.java. In questo esempio {package-path} è examples/aws/apig/simpleCalc/sdk/app. Il precorso del pacchetto viene derivato dal valore DarchetypeGroupdId. Puoi usare il file App.java come modello per l'applicazione client e, se necessario, aggiungerne altri nella stessa cartella. Puoi usare il file AppTest.java come modello di test di unità per l'applicazione e, se necessario, aggiungere altri file di codice di test nella stessa cartella.

7. Aggiorna le dipendenze di pacchetto nel file pom.xml generato come segue sostituendo, se necessario, le proprietà groupId, artifactId, version e name del progetto:

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

   Nota

   Quando una versione più recente dell'artefatto dipendente di aws-java-sdk-core è incompatibile con la versione specificata sopra (1.11.94), è necessario aggiornare il tag <version> alla nuova versione.

8. Quindi mostreremo come chiamare l'API mediante l'SDK chiamando i metodi getABOp(GetABOpRequest req), getApiRoot(GetApiRootRequest req) e postApiRoot(PostApiRootRequest req) dell'SDK. Questi metodi corrispondono ai metodi GET /{a}/{b}/{op}, GET /?a={x}&b={y}&op={operator} e POST /, rispettivamente con un payload di richieste API {"a": x, "b": y, "op": "operator"}.

   Aggiorna il file App.java come segue:

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

   Nel'esempio precedente le impostazioni di configurazione utilizzate per creare istanze del client SDK hanno esclusivamente scopo illustrativo e non sono necessariamente best practice consigliate. Anche la chiamata a sdkClient.shutdown() è facoltativa, soprattutto se si ha necessità di esercitare un controllo accurato su quando liberare risorse.

Abbiamo mostrato i modelli fondamentali per chiamare un'API utilizzando un SDK Java. Le istruzioni possono essere applicate per chiamare altri metodi API.