

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 設定 適用於 Java 的 AWS SDK 2.x
<a name="setup"></a>

本節提供如何設定開發環境和專案以使用 的相關資訊 AWS SDK for Java 2.x。

## 設定概觀
<a name="setup-overview"></a>

若要成功開發 AWS 服務 使用 存取的應用程式 適用於 Java 的 AWS SDK，需要下列條件：
+ Java 開發套件必須能夠存取登入資料，以代表您[驗證請求](get-started-auth.md#setup-auth)。
+ 為 SDK 設定的 [IAM 角色許可](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html)必須允許存取 AWS 服務 您的應用程式所需的 。與 **PowerUserAccess** AWS 受管政策相關聯的許可足以滿足大多數開發需求。
+ 具有下列元素的開發環境：
  + 至少以下列其中一種方式設定的[共用組態檔案](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)：
    + `config` 檔案包含 [IAM Identity Center 單一登入設定](get-started-auth.md#setup-credentials)，讓 SDK 可以取得 AWS 登入資料。
    + `credentials` 檔案包含臨時登入資料。
  + [安裝 Java 8 ](setup-java-buildtool.md)或更新版本。
  + [建置自動化工具](setup-java-buildtool.md)，例如 [Maven](https://maven.apache.org/download.cgi) 或 [Gradle](https://gradle.org/install/)。
  + 使用程式碼的文字編輯器。
  + （選用，但建議使用） IDE （整合式開發環境），例如 [IntelliJ IDEA](https://www.jetbrains.com/idea/download/#section=windows)、[Eclipse](https://www.eclipse.org/ide/) 或 [NetBeans](https://netbeans.apache.org/front/main/download/index.html)。

    如果您使用 IntelliJ IDEA，也可以新增 [AWS Toolkit for IntelliJ IDEA](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html) 以 AWS 服務 直接整合到 IDE，以協助您簡化開發。
+ 當您準備好執行應用程式時，作用中的 AWS 存取入口網站工作階段。您可以使用 AWS Command Line Interface [啟動 IAM Identity Center 存取入口網站的登入程序](get-started-auth.md#setup-login-sso)。 AWS 

**重要**  
此設定區段中的指示假設您或組織使用 IAM Identity Center。如果您的組織使用獨立於 IAM Identity Center 運作的外部身分提供者，請了解如何取得適用於 Java 的 SDK 暫時登入資料。請依照[這些指示](credentials-temporary.md#credentials-temporary-from-portal)，將臨時登入資料新增至 `~/.aws/credentials` 檔案。  
如果您的身分提供者自動將臨時登入資料新增至 `~/.aws/credentials` 檔案，請確定設定檔名稱為 ，`[default]`如此您就不需要提供設定檔名稱給 SDK 或 AWS CLI。

# 安裝 Java 和建置工具以使用 AWS SDK for Java 2.x
<a name="setup-java-buildtool"></a>

您需要下列 Java 開發環境需求，才能使用適用於 Java 的 SDK 2.x：
+ Java 8 或更新版本。 適用於 Java 的 AWS SDK 適用於 [Oracle Java SE 開發套件](https://www.oracle.com/java/technologies/downloads/)和 Open Java 開發套件 (OpenJDK) 的發行版本，例如 [Amazon Corretto](https://aws.amazon.com/corretto/)、[Red Hat OpenJDK](https://developers.redhat.com/products/openjdk/overview) 和 [Adoptium](https://adoptium.net/)。
+ 與 Maven 相容的建置工具，例如 Apache Maven、Apache Ant with Ivy、Gradle 或 IntelliJ。
  + 如需如何安裝和使用 Maven 的詳細資訊，請參閱 https：//[https://maven.apache.org/](https://maven.apache.org/)。
  + 如需如何安裝和使用 Apache Ivy 的詳細資訊，請參閱 https：//[https://ant.apache.org/ivy/](https://ant.apache.org/ivy/)。
  + 如需如何安裝和使用 Gradle 的詳細資訊，請參閱 https：//[https://gradle.org/](https://gradle.org/)。
  + 如需如何安裝和使用 IntelliJ IDEA 的資訊，請參閱 https：//[https://www.jetbrains.com/idea/](https://www.jetbrains.com/idea/)。

# 設定使用 的 Apache Maven 專案 AWS SDK for Java 2.x
<a name="setup-project-maven"></a>

您可以使用 [Apache Maven](https://maven.apache.org/) 來設定和建置 AWS SDK for Java 2.x 專案，或[建置 SDK 本身](https://github.com/aws/aws-sdk-java-v2/tree/master#building-from-source)。

## 先決條件
<a name="prerequisitesmaven"></a>

若要搭配 Maven 使用適用於 Java 的 SDK 2.x，您需要下列項目：
+ Java *8.0 或更新版本*。您可以從 [http://www.oracle.com/technetwork/java/javase/downloads/](https://www.oracle.com/java/technologies/downloads/) 下載最新的 Java SE 開發套件軟體。適用於 Java 的 SDK 2.x 也適用於 [OpenJDK](https://openjdk.org/) Amazon Corretto和 Open Java 開發套件 (OpenJDK) 的發行版本。從 [https://openjdk.java.net/install/index.html](https://openjdk.org/install/index.html) 下載最新版本的 OpenJDK。從 [Corretto 頁面](https://aws.amazon.com/corretto/)下載最新的 Amazon Corretto 8 或 Amazon Corretto 11 版本。
+  *Apache Maven*。如果您需要安裝 Maven，請前往 [http://maven.apache.org/](https://maven.apache.org/) 下載並安裝。

## 建立 Maven 專案
<a name="create-maven-project"></a>

若要從命令列建立 Maven 專案，請從終端機或命令提示字元視窗執行下列命令````。

```
mvn -B archetype:generate \
 -DarchetypeGroupId=software.amazon.awssdk \
 -DarchetypeArtifactId=archetype-lambda -Dservice=s3 -Dregion=US_WEST_2 \
 -DarchetypeVersion=2.X.X \
 -DgroupId=com.example.myapp \
 -DartifactId=myapp
```

**注意**  
將 *com.example.myapp* 更換為您應用程式的完整套件命名空間。亦請將 *myapp* 更換為您的專案名稱。這會成為您專案的目錄名稱。  
若要使用最新版本的原型，請將 *2.X.X 取代*為 [Maven 中央的最新版本](https://central.sonatype.com/artifact/software.amazon.awssdk/archetype-lambda)。

此命令會使用原型範本化工具組建立 Maven 專案。原型會為 AWS Lambda 函數處理常式專案 產生 scaffolding。此專案原型已預先設定為使用 Java SE 8 編譯，並包含對使用 指定之適用於 Java 2.x 的 SDK 版本的相依性。 `-DarchetypeVersion`

如需建立和設定 Maven 專案的詳細資訊，請參閱 [Maven 入門指南](https://maven.apache.org/guides/getting-started/)。

## 設定適用於 Maven 的 Java 編譯器
<a name="configure-maven-compiler"></a>

如果您如先前所述使用 AWS Lambda 專案原型建立專案，Java 編譯器的組態已為您完成。

若要驗證此組態是否存在，請從您執行上一個指令時所建立的專案資料夾中 (例如 `myapp`)，開啟 `pom.xml` 檔案開始。查看第 11 行和第 12 行中此 Maven 專案的 Java 編譯器版本設定，以及在第 71 至 75 行中必須包含的 Maven 編譯器外掛程式。

```
<project>
  <properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>${maven.compiler.plugin.version}</version>
      </plugin>
    </plugins>
  </build>
</project>
```

如果您使用不同的原型或使用其他方法建立專案，則必須確保 Maven 編譯器外掛程式是組建的一部分，且其來源和目標屬性在 `pom.xml` 檔案中都設定為 **1.8**。

請參閱上一個程式碼片段，以了解設定這些必要設定的一種方法。

或者，您也可以使用外掛程式宣告設定編譯器組態內嵌，如下所示。

```
<project>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>
```

## 將開發套件宣告為相依性
<a name="sdk-as-dependency"></a>

若要在專案 適用於 Java 的 AWS SDK 中使用 ，您需要在專案的 `pom.xml` 檔案中將其宣告為相依性。

如果您如先前所述使用專案原型建立專案，則 SDK 的最新版本已在專案中設定為相依性。

原型會為`software.amazon.awssdk`群組 ID 產生 BOM （物料帳單） 成品相依性。使用 BOM，您不需要為共用相同群組 ID 的個別成品相依性指定 maven 版本。

如以不同方式建立 Maven 專案，請確保 `pom.xml` 檔案包含以下內容，以為專案設定開發套件的最新版本。

```
<project>
  <properties>
    <aws.java.sdk.version>2.X.X</aws.java.sdk.version>
  </properties>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>bom</artifactId>
        <version>${aws.java.sdk.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
</project>
```

**注意**  
將 `pom.xml` 檔案中的 *2.X.X* 取代為[最新版本的 AWS SDK for Java 2.x](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) 。

## 設定開發套件模組的相依性
<a name="modules-dependencies"></a>

現在您已設定 SDK，您可以為一或多個要在專案中使用的 適用於 Java 的 AWS SDK 模組新增相依性。

雖然您可以指定每個元件的版本編號，但您不需要 ，因為您已在 `dependencyManagement`區段中使用物料清單成品宣告 SDK 版本。若要載入指定模組的不同版本，請指定其相依性的版本編號。

如果您使用上述的專案原型建立專案，您的專案已設定多個相依性。這些包括 AWS Lambda 函數處理常式和 Amazon S3 的相依性，如下所示。

```
<project>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>netty-nio-client</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>apache-client</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>url-connection-client</artifactId>
        </dependency>

        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-lambda-java-core</artifactId>
            <version>${aws.lambda.java.version}</version>
        </dependency>
    </dependencies>
</project>
```

**注意**  
在上述`pom.xml`範例中，相依性來自不同的 `groupId`。`s3` 相依性來自 `software.amazon.awssdk`，`aws-lambda-java-core`而相依性來自 `com.amazonaws`。BOM 相依性管理組態會影響 的成品`software.amazon.awssdk`，因此`aws-lambda-java-core`成品需要 版本。  
對於使用適用於 Java 的 SDK 2.x 開發 *Lambda 函數處理常式*， `aws-lambda-java-core`是正確的相依性。不過，如果您的應用程式需要使用 `listFunctions`、、 `deleteFunction``invokeFunction`和 等操作來管理 Lambda 資源`createFunction`，您的應用程式需要下列相依性。  

```
<groupId>software.amazon.awssdk</groupId>
<artifactId>lambda</artifactId>
```

**注意**  
`s3` 相依性會排除 `netty-nio-client`和可`apache-client`轉移相依性。原型會取代其中一個 HTTP 用戶端，包括`url-connection-client`相依性，這有助於[減少函數的 AWS Lambda 啟動延遲](lambda-optimize-starttime.md#lambda-quick-url)。

將模組新增至專案，以取得專案所需的 AWS 服務 和 功能。由 BOM 管理的 適用於 Java 的 AWS SDK 模組 （相依性） 會列在 [Maven 中央儲存庫](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)上。

**注意**  
您可以在程式碼範例中查看 `pom.xml` 檔案，以判斷專案需要的相依性。例如，如果您對 DynamoDB 服務的相依性感興趣，請參閱 GitHub 上[AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2)中的[此範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/dynamodb/pom.xml)。（尋找 [/javav2/example\$1code/dynamodb](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb) 下的 `pom.xml` 檔案。)

### 在專案中建立整個開發套件
<a name="build-the-entire-sdk-into-your-project"></a>

若要最佳化您的應用程式，強烈建議您只提取所需元件，不要提取整個開發套件。不過，若要在專案 適用於 Java 的 AWS SDK 中建置整個 ，請在您的 `pom.xml` 檔案中宣告它，如下所示。

```
<project>
  <dependencies>
    <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>aws-sdk-java</artifactId>
      <version>2.X.X</version>
    </dependency>
  </dependencies>
</project>
```

## 建立專案
<a name="build-project"></a>

設定 `pom.xml` 檔案後，您就可以使用 Maven 建立您的專案。

若要從命令列建立 Maven 專案，請開啟終端機或命令提示視窗，導覽至您的專案目錄 (例如 `myapp`)，輸入或貼上以下命令，然後按 Enter 或 Return。

```
mvn package
```

這會在 `target` 目錄中建立單一 `.jar` 檔案 (JAR) (例如 `myapp/target`)。此 JAR 包含您在 `pom.xml` 檔案中指定為相依性的所有開發套件模組。

# 設定使用 的 Gradle 專案 AWS SDK for Java 2.x
<a name="setup-project-gradle"></a>

您可以使用 [Gradle](https://gradle.org/) 來設定和建置 AWS SDK for Java 2.x 專案。

下列範例中的初始步驟來自 [Gradle 的 8.4 版入門指南](https://docs.gradle.org/current/samples/sample_building_java_applications.html)。如果您使用不同的版本，結果可能會略有不同。

**使用 Gradle 建立 Java 應用程式 （命令列）**

1. 建立目錄以保留您的專案。在此範例中， `demo`是目錄名稱。

1. 在 `demo`目錄中，執行 `gradle init`命令，並提供以紅色反白顯示的值，如下列命令列輸出所示。針對演練，我們選擇 Kotlin 做為建置指令碼 DSL 語言，但本主題結尾也會顯示 Groovy 的完整範例。

   ```
   > gradle init
   Starting a Gradle Daemon (subsequent builds will be faster)
   
   Select type of project to generate:
   1: basic
   2: application
   3: library
   4: Gradle plugin
   Enter selection (default: basic) [1..4] 2
   
   Select implementation language:
   1: C++
   2: Groovy
   3: Java
   4: Kotlin
   5: Scala
   6: Swift
   Enter selection (default: Java) [1..6] 3
   
   Generate multiple subprojects for application? (default: no) [yes, no] no
   Select build script DSL:
   1: Kotlin
   2: Groovy
   Enter selection (default: Kotlin) [1..2] <Enter>
   
   Select test framework:
   1: JUnit 4
   2: TestNG
   3: Spock
   4: JUnit Jupiter
   Enter selection (default: JUnit Jupiter) [1..4] 4
   
   Project name (default: demo): <Enter>
   Source package (default: demo): <Enter>
   Enter target version of Java (min. 7) (default: 11): <Enter>
   Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] <Enter>
   
   > Task :init
   To learn more about Gradle by exploring our Samples at https://docs.gradle.org/8.4/samples/sample_building_java_applications.html
   
   BUILD SUCCESSFUL in 3m 43s
   2 actionable tasks: 2 executed
   ```

1. `init` 任務完成後，`demo`目錄會包含下列樹狀結構。在下一節中，我們會進一步了解主要建置檔案 `build.gradle.kts`（以紅色標示）。

   ```
   ├── app
   │   ├── build.gradle.kts
   │   └── src
   │       ├── main
   │       │   ├── java
   │       │   │   └── demo
   │       │   │       └── App.java
   │       │   └── resources
   │       └── test
   │           ├── java
   │           │   └── demo
   │           │       └── AppTest.java
   │           └── resources
   ├── gradle
   │   └── wrapper
   │       ├── gradle-wrapper.jar
   │       └── gradle-wrapper.properties
   ├── gradlew
   ├── gradlew.bat
   └── settings.gradle.kts
   ```

   `build.gradle.kts` 檔案包含下列 scaffolded 內容。

   ```
   /*
    * This file was generated by the Gradle 'init' task.
    *
    * This generated file contains a sample Java application project to get you started.
    * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation.
    */
   
   plugins {
       // Apply the application plugin to add support for building a CLI application in Java.
       application
   }
   
   repositories {
       // Use Maven Central for resolving dependencies.
       mavenCentral()
   }
   
   dependencies {
       // Use JUnit Jupiter for testing.
       testImplementation("org.junit.jupiter:junit-jupiter:5.9.3")
   
       testRuntimeOnly("org.junit.platform:junit-platform-launcher")
   
       // This dependency is used by the application.
       implementation("com.google.guava:guava:33.3.0-jre")
   }
   
   // Apply a specific Java toolchain to ease working on different environments.
   java {
       toolchain {
           languageVersion.set(JavaLanguageVersion.of(11))
       }
   }
   
   application {
       // Define the main class for the application.
       mainClass.set("demo.App")
   }
   
   tasks.named<Test>("test") {
       // Use JUnit Platform for unit tests.
       useJUnitPlatform()
   }
   ```

1. 使用堆疊的 Gradle 建置檔案做為 AWS 專案的基礎。

   1. 若要管理 Gradle 專案的 SDK 相依性，請將 的 Maven 物料清單 (BOM) 新增至 `build.gradle.kts` 檔案的 AWS SDK for Java 2.x `dependencies`區段。

      ```
      ...
      dependencies {
          implementation(platform("software.amazon.awssdk:bom:2.27.21"))
          // With the bom declared, you specify individual SDK dependencies without a version.
       ...
      }
      ...
      ```
**注意**  
在此範例建置檔案中，將 *2.27.21* 取代為最新版本的適用於 Java 的 SDK 2.x。尋找 [Maven 中央儲存庫](https://central.sonatype.com/artifact/software.amazon.awssdk/bom/versions)中可用的最新版本。

   1. 在 `dependencies`區段中指定應用程式所需的 SDK 模組。例如，以下內容會在 Amazon Simple Storage Service 上新增相依性。

      ```
      ...
      dependencies {    
          implementation(platform("software.amazon.awssdk:bom:2.27.21"))
          implementation("software.amazon.awssdk:s3")
       ...
      }
      ...
      ```

      Gradle 會使用 BOM 中的資訊，自動解析宣告相依性的正確版本。

下列範例顯示 Kotlin 和 Groovy DSLs中完整的 Gradle 建置檔案。建置檔案包含 Amazon S3、身分驗證、記錄和測試的相依性。Java 的來源和目標版本是版本 11。

------
#### [ Kotlin DSL (build.gradle.kts) ]

```
/*
 * This file was generated by the Gradle 'init' task.
 *
 * This generated file contains a sample Java application project to get you started.
 * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation.
 */

plugins {
    // Apply the application plugin to add support for building a CLI application in Java.
    application
}

repositories {
    // Use Maven Central for resolving dependencies.
    mavenCentral()
}

dependencies {
    implementation(platform("software.amazon.awssdk:bom:2.20.56"))
    implementation("software.amazon.awssdk:s3")
    implementation("software.amazon.awssdk:sso")
    implementation("software.amazon.awssdk:ssooidc")
    implementation(platform("org.apache.logging.log4j:log4j-bom:2.20.0"))
    implementation("org.apache.logging.log4j:log4j-slf4j2-impl")
    implementation("org.apache.logging.log4j:log4j-1.2-api")
    testImplementation(platform("org.junit:junit-bom:5.10.0"))
    testImplementation("org.junit.jupiter:junit-jupiter")
}

// Apply a specific Java toolchain to ease working on different environments.
java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(11))
    }
}

application {
    // Define the main class for the application.
    mainClass.set("demo.App")
}

tasks.named<Test>("test") {
    // Use JUnit Platform for unit tests.
    useJUnitPlatform()
}
```

------
#### [ Groovy DSL (build.gradle) ]

```
/*
 * This file was generated by the Gradle 'init' task.
 *
 * This generated file contains a sample Java application project to get you started.
 * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation.
 */

plugins {
    // Apply the application plugin to add support for building a CLI application in Java.
    id 'application'
}

repositories {
    // Use Maven Central for resolving dependencies.
    mavenCentral()
}

dependencies {
    implementation platform('software.amazon.awssdk:bom:2.27.21')
    implementation 'software.amazon.awssdk:s3'
    implementation 'software.amazon.awssdk:sso'
    implementation 'software.amazon.awssdk:ssooidc'
    implementation platform('org.apache.logging.log4j:log4j-bom:2.20.0')
    implementation 'org.apache.logging.log4j:log4j-slf4j2-impl'
    implementation 'org.apache.logging.log4j:log4j-1.2-api'
    testImplementation platform('org.junit:junit-bom:5.10.0')
    testImplementation 'org.junit.jupiter:junit-jupiter'
}

// Apply a specific Java toolchain to ease working on different environments.
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
    }
}

application {
    // Define the main class for the application.
    mainClass = 'demo_groovy.App'
}

tasks.named('test') {
    // Use JUnit Platform for unit tests.
    useJUnitPlatform()
}
```

------

如需後續步驟，請參閱 Gradle 網站上的入門指南，以取得如何[建置和執行 Gradle 應用程式](https://docs.gradle.org/current/samples/sample_building_java_applications.html#run_the_application)的指示。

# 設定使用 的 GraalVM 原生映像專案 AWS SDK for Java 2.x
<a name="setup-project-graalvm"></a>

使用 2.16.1 版和更新版本時， 為 GraalVM 原生映像應用程式 AWS SDK for Java 2.x 提供out-of-the-box支援。使用 `archetype-app-quickstart` Maven 原型來設定具有內建原生映像支援的專案。

## 先決條件
<a name="setup-graalvmnativeimage-prereq"></a>
+ 完成[設定 適用於 Java 的 AWS SDK 2.x](setup.md) 中的步驟。
+ 安裝 [GraalVM 原生映像](https://www.graalvm.org/reference-manual/native-image/#install-native-image)。

## 使用原型建立專案
<a name="setup-graalvmnativeimage-project"></a>

若要建立具有內建原生映像支援的 Maven 專案，請在終端機或命令提示字元視窗中使用下列命令。

**注意**  
`com.example.mynativeimageapp` 以應用程式的完整套件命名空間取代 。也請將 取代`mynativeimageapp`為您的專案名稱。這會成為您專案的目錄名稱。

```
mvn archetype:generate \
    -DarchetypeGroupId=software.amazon.awssdk \
    -DarchetypeArtifactId=archetype-app-quickstart \
    -DarchetypeVersion=2.27.21\
    -DnativeImage=true \
    -DhttpClient=apache-client \
    -Dservice=s3 \
    -DgroupId=com.example.mynativeimageapp \
    -DartifactId=mynativeimageapp \
    -DinteractiveMode=false
```

此命令會為 適用於 Java 的 AWS SDK Amazon S3、 和 `ApacheHttpClient` HTTP 用戶端建立以相依性設定的 Maven 專案。它還包含 [GraalVM 原生映像 Maven 外掛程式](https://graalvm.github.io/native-build-tools/latest/index.html)的相依性，因此您可以使用 Maven 建置原生映像。

若要包含不同 的相依性 Amazon Web Services，請將 `-Dservice` 參數的值設定為該服務的成品 ID。範例包括 `dynamodb`、`comprehend` 和 `pinpoint`。如需成品 IDs 的完整清單，請參閱 [Maven Central 上 software.amazon.awssdk](https://mvnrepository.com/artifact/software.amazon.awssdk/bom/latest) 的受管相依性清單。

若要使用非同步 HTTP 用戶端，請將 `-DhttpClient` 參數設定為 `netty-nio-client`。若要使用 `UrlConnectionHttpClient`做為同步 HTTP 用戶端而非 `apache-client`，請將 `-DhttpClient` 參數設定為 `url-connection-client`。

## 建置原生映像
<a name="build-graalvmnativeimage-project"></a>

建立專案之後，請從專案目錄執行下列命令，例如 `mynativeimageapp`：

```
mvn package -P native-image
```

這會在 `target`目錄中建立原生映像應用程式，例如 `target/mynativeimageapp`。