先决条件步骤 1：安装所需工具步骤 2：添加代码步骤 3：生成并运行代码步骤 4：设置以使用 AWS SDK for Java 步骤 5：在环境中设置 AWS 凭证管理步骤 6：添加 AWS 开发工具包代码步骤 7：构建并运行 AWS 开发工具包代码第 8 步：清除

适用于 AWS Cloud9 的 Java 教程

重要

如果您使用的是由具有 2 GiB 或更多内存的 EC2 实例支持的 AWS Cloud9 开发环境，我们建议您激活增强型 Java 支持。这提供了对生产率特性的访问，比如代码完成、错误的 linting、特定于上下文的操作，以及调试选项，比如断点和步进。

有关更多信息，请参阅增强了对 Java 开发的支持。

该教程让您能够在 AWS Cloud9 开发环境中运行部分 Java 代码。

按照本教程操作并创建此示例可能会对您的 AWS 账户收费。其中包括可能对 Amazon EC2 和 Amazon S3 等服务收取的费用。有关更多信息，请参阅 Amazon EC2 定价和 Amazon S3 定价。

先决条件

在使用此示例之前，请确保您的设置满足以下要求：

您必须有现成的 AWS Cloud9 EC2 开发环境。本示例假设您已经有连接到运行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 实例的 EC2 环境。如果您有不同类型的环境或操作系统，可能需要按照本示例的说明来设置相关的工具。有关更多信息，请参阅在 AWS Cloud9 中创建环境。
您已将适用于现有环境的 AWS Cloud9 IDE 打开。当您打开环境时，AWS Cloud9 会在 Web 浏览器中为该环境打开 IDE。有关更多信息，请参阅在 AWS Cloud9 中打开环境。

步骤 1：安装所需工具

在此步骤中，您将在 AWS Cloud9 开发环境中安装一组 Java 开发工具。如果您已在环境中安装了一组 Java 开发工具（如 Oracle JDK 或 OpenJDK），则可以向前跳到步骤 2：添加代码。此示例是使用 OpenJDK 8 开发的，您可以通过完成以下过程在环境中安装它。

确认是否已安装 OpenJDK 8。为此，请在 AWS Cloud9 IDE 的终端会话中，运行带 -version 选项的 Java 运行程序的命令行版本。（要开始新的终端会话，请在菜单栏上依次选择 Window（窗口）> New Terminal（新建终端）。）
```
java -version
```
根据上述命令的输出，执行以下操作之一：
- 如果输出说明未找到 java 命令，请继续此过程中的步骤 2 来安装 OpenJDK 8。
- 如果输出包含以 Java(TM)、Java Runtime Environment、Java SE、J2SE 或 Java2 开头的值，则表明未安装 OpenJDK 或未将 OpenJDK 设置为默认 Java 开发工具集。继续此过程中的步骤 2 来安装 OpenJDK 8，然后切换为使用 OpenJDK 8。
- 如果输出包含以 java version 1.8 和 OpenJDK 开头的值，请向前跳到步骤 2：添加代码。已为此示例正确安装 OpenJDK 8。
- 如果输出包含低于 java version 的 1.8 和以 OpenJDK 开头的值，请继续此过程中的步骤 2 来将已安装的 OpenJDK 版本升级到 OpenJDK 8。
确保已安装最新的安全更新和错误修复。为此，请使用 update 命令运行 yum 工具（适用于 Amazon Linux）或 apt 工具（适用于 Ubuntu Server）。

对于 Amazon Linux：
```
sudo yum -y update
```
对于 Ubuntu Server：
```
sudo apt update
```
安装 OpenJDK 8。为此，请使用 install 命令运行 yum 工具（适用于 Amazon Linux）或 apt 工具（适用于 Ubuntu Server），指定 OpenJDK 8 程序包。

对于 Amazon Linux：
```
sudo yum -y install java-1.8.0-openjdk-devel
```
对于 Ubuntu Server：
```
sudo apt install -y openjdk-8-jdk
```
有关更多信息，请参阅 OpenJDK 网站上的如何下载并安装预先构建的 OpenJDK 程序包。
将默认的 Java 开发工具集切换或升级到 OpenJDK 8。为此，请运行带 --config 选项的 update-alternatives 命令。运行此命令两次来切换或升级 Java 运行程序和编译器的命令行版本。
```
sudo update-alternatives --config java
sudo update-alternatives --config javac
```
在每个提示符处，键入 OpenJDK 8 的选择编号（包含 java-1.8 的那一个）。
确认 Java 运行程序和编译器的命令行版本使用的是 OpenJDK 8。为此，请运行带 -version 选项的 Java 运行程序和编译器的命令行版本。
```
java -version
javac -version
```
如果已正确安装并设置 OpenJDK 8，则 Java 运行程序版本输出会包含以 openjdk version 1.8 开头的值，并且 Java 编译器版本输出会以值 javac 1.8 开头。

步骤 2：添加代码

在 AWS Cloud9 IDE 中，创建一个包含以下代码的文件，并使用文件名 hello.java 保存该文件。（要创建文件，请在菜单栏上依次选择 File（文件）、New File（新建文件）。要保存文件，请依次选择 File（文件）、Save（保存）。）


public class hello {

  public static void main(String []args) {
    System.out.println("Hello, World!");

    System.out.println("The sum of 2 and 3 is 5.");

    int sum = Integer.parseInt(args[0]) + Integer.parseInt(args[1]);

    System.out.format("The sum of %s and %s is %s.\n",
      args[0], args[1], Integer.toString(sum));
  }
}

步骤 3：生成并运行代码

使用 Java 编译器的命令行版本将 hello.java 文件编译为 hello.class 文件。为此，请使用 AWS Cloud9 IDE 中的终端，从 hello.java 文件所在的相同目录中，运行 Java 编译器，指定 hello.java 文件。
```
javac hello.java
```
使用 Java 运行程序的命令行版本来运行 hello.class 文件。为此，请从 hello.class 文件所在的相同目录中，运行 Java 运行程序，指定在 hello 文件中声明的 hello.java 类的名称，并添加两个整数（例如 5 和 9）。
```
java hello 5 9
```

比较您的输出。


Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.

步骤 4：设置以使用 AWS SDK for Java

您可以改进此示例，以使用 AWS SDK for Java 创建 Amazon S3 存储桶，列出您的可用存储桶，然后删除刚刚创建的存储桶。

在此步骤中，您将在环境中安装 Apache Maven 或 Gradle。Maven 和 Gradle 是可用于 Java 项目的常见构建自动化系统。在您安装 Maven 或 Gradle 后，您可以使用它来生成新的 Java 项目。在此新项目中，您将添加对AWS SDK for Java的引用。此 AWS SDK for Java 提供了从 Java 代码与 AWS 服务（如 Amazon S3）交互的便捷方式。

主题

使用 Maven 设置
使用 Gradle 设置

使用 Maven 设置

在环境中安装 Maven。要查看是否已安装 Maven，请使用 AWS Cloud9 IDE 中的终端，运行带 -version 选项的 Maven。
```
mvn -version
```
如果成功，输出将包含 Maven 版本号。如果已安装 Maven，请向前跳到此过程中的步骤 4 来使用 Maven 在环境中生成新的 Java 项目。
通过使用终端运行以下命令来安装 Maven。

对于 Amazon Linux，以下命令将获取有关 Maven 存储所在的程序包存储库的信息，然后使用此信息来安装 Maven。
```
sudo wget http://repos.fedorapeople.org/repos/dchen/apache-maven/epel-apache-maven.repo -O /etc/yum.repos.d/epel-apache-maven.repo
sudo sed -i s/\$releasever/6/g /etc/yum.repos.d/epel-apache-maven.repo
sudo yum install -y apache-maven
```
有关上述命令的更多信息，请参阅 Fedora 项目 Wiki 网站上的 Extra Packages for Enterprise Linux (EPEL)。

对于 Ubuntu Server，则运行以下命令。
```
sudo apt install -y maven
```
带 -version 选项运行 Maven 以确认安装。
```
mvn -version
```

使用 Maven 生成新的 Java 项目。为此，请使用终端从您希望 Maven 在其中生成项目的目录（例如，环境的根目录）中运行以下命令。


mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

上述命令在环境中为项目创建以下目录结构。


my-app
  |- src
  |   `- main
  |        `- java
  |             `- com
  |                 `- mycompany
  |                      `- app
  |                          `-App.java
  |- test
  |   `- java
  |        `- com
  |            `- mycompany
  |                 `- app
  |                     `- AppTest.java
  `- pom.xml

有关上述目录结构的更多信息，请参阅 Apache Maven 项目网站上的 Maven Quickstart 原型和标准目录布局简介。

修改项目的项目对象模型 (POM) 文件。（POM 文件定义 Maven 项目的设置。）为此，请从 Environment（环境）窗口中打开 my-app/pom.xml 文件。在编辑器中，将该文件的当前内容替换为以下代码，然后保存 pom.xml 文件。


<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>com.mycompany.app</groupId>
  <artifactId>my-app</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>
        <version>3.6.0</version>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
          <archive>
            <manifest>
              <mainClass>com.mycompany.app.App</mainClass>
            </manifest>
          </archive>
        </configuration>
        <executions>
          <execution>
            <phase>package</phase>
              <goals>
                <goal>single</goal>
              </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.amazonaws</groupId>
      <artifactId>aws-java-sdk</artifactId>
      <version>1.11.330</version>
    </dependency>
  </dependencies>
</project>

上述 POM 文件包含指定声明的项目设置，如下所示：

artifactid 的 my-app 设置将设置项目的根目录名称，group-id 的 com.mycompany.app 设置将设置 com/mycompany/app 子目录结构以及 package 和 App.Java 文件中的 AppTest.java 声明。
artifactId 的 my-app 设置、packaging 的 jar 设置、version 的 1.0-SNAPSHOT 设置和 descriptorRef 的 jar-with-dependencies 设置将设置 my-app-1.0-SNAPSHOT-jar-with-dependencies.jar 的输出 JAR 文件的名称。
plugin 部分声明将构建单个 JAR，其中包括所有依赖项。
具有 com.amazon.aws 的 groupId 设置和 aws-java-sdk 的 artifactId 设置的 dependency 部分包含AWS SDK for Java库文件。通过 version 设置声明要使用的AWS SDK for Java版本。要使用其他版本，请替换此版本号。

向前跳至步骤 5：在环境中设置 AWS 凭证管理。

使用 Gradle 设置

在环境中安装 Gradle。要查看是否已安装 Gradle，请使用 AWS Cloud9 IDE 中的终端，运行带 -version 选项的 Gradle。
```
gradle -version
```
如果成功，输出将包含 Gradle 版本号。如果已安装 Gradle，请向前跳到此过程中的步骤 4 来使用 Gradle 在环境中生成新的 Java 项目。
通过使用终端运行以下命令来安装 Gradle。这些命令安装并运行 SDKMAN! 工具，然后使用 SDKMAN! 安装最新版本的 Gradle。
```
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install gradle
```
有关上述命令的更多信息，请参阅 SDKMAN! 网站上的安装以及 Gradle 网站上的使用包管理器进行安装。
运行带 -version 选项的 Gradle 以确认安装。
```
gradle -version
```
使用 Gradle 在环境中生成新的 Java 项目。为此，请使用终端运行以下命令来为项目创建目录，然后切换到该目录。
```
mkdir my-app
cd my-app
```

运行以下命令来让 Gradle 在环境中的 my-app 目录中生成新的 Java 应用程序项目。


gradle init --type java-application

上述命令在环境中为项目创建以下目录结构。


my-app
  |- .gradle
  |   `- (various supporting project folders and files)
  |- gradle
  |   `- (various supporting project folders and files)
  |- src
  |   |- main
  |   |    `- java
  |   |         `- App.java
  |   `- test
  |        `- java
  |             `- AppTest.java
  |- build.gradle
  |- gradlew
  |- gradlew.bat
  `- settings.gradle

修改项目的 AppTest.java。（如果不这样做，则项目可能不会按预期方式构建或运行。）为此，请从 Environment（环境）窗口中打开 my-app/src/test/java/AppTest.java 文件。在编辑器中，将该文件的当前内容替换为以下代码，然后保存 AppTest.java 文件。
```
import org.junit.Test;
import static org.junit.Assert.*;

public class AppTest {
  @Test public void testAppExists () {
    try {
      Class.forName("com.mycompany.app.App");
    } catch (ClassNotFoundException e) {
      fail("Should have a class named App.");
    }
  }
}
```
修改项目的 build.gradle 文件。（build.gradle 文件定义 Gradle 项目的设置。）为此，请从 Environment（环境）窗口中打开 my-app/build.gradle 文件。在编辑器中，将该文件的当前内容替换为以下代码，然后保存 build.gradle 文件。
```
apply plugin: 'java'
apply plugin: 'application'

repositories {
  jcenter()
  mavenCentral()
}

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE"
  }
}

apply plugin: "io.spring.dependency-management"

dependencyManagement {
  imports {
    mavenBom 'com.amazonaws:aws-java-sdk-bom:1.11.330'
  }
}

dependencies {
  compile 'com.amazonaws:aws-java-sdk-s3'
  testCompile group: 'junit', name: 'junit', version: '4.12'
}

run {
  if (project.hasProperty("appArgs")) {
    args Eval.me(appArgs)
  }
}

mainClassName = 'App'
```
上述 build.gradle 文件包含指定声明的项目设置，如下所示：
- io.spring.dependency-management 插件用于导入AWS SDK for Java Maven 材料清单 (BOM) 以管理项目的AWS SDK for Java依赖项。classpath 声明要使用的版本。要使用其他版本，请替换此版本号。
- com.amazonaws:aws-java-sdk-s3 包含 AWS SDK for Java 库文件的 Amazon S3 部分。mavenBom 声明要使用的版本。如果您希望使用其他版本，请替换此版本号。

步骤 5：在环境中设置 AWS 凭证管理

每次您使用 AWS SDK for Java 调用 AWS 服务时，都必须提供一组 AWS 凭证才能进行调用。这些凭证确定 AWS SDK for Java 是否具有相应的权限以进行该调用。如果凭证没有包括合适的权限，调用将失败。

在此步骤中，您将凭证存储在环境内。为此，请按照从 AWS Cloud9 中的环境调用 AWS 服务中的说明操作，然后返回到本主题。

有关其他信息，请参阅 AWS SDK for Java 开发人员指南中的设置用于开发的 AWS 凭证和区域。

步骤 6：添加 AWS 开发工具包代码

在此步骤中，您添加用于与 Amazon S3 交互的代码，以创建存储桶，列出可用的存储桶，然后删除刚刚创建的存储桶。

从 Environment（环境）窗口中，打开 my-app/src/main/java/com/mycompany/app/App.java 文件（适用于 Maven）或 my-app/src/main/java/App.java 文件（适用于 Gradle）。在编辑器中，将该文件的当前内容替换为以下代码，然后保存 App.java 文件。


package com.mycompany.app;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AmazonS3Exception;
import com.amazonaws.services.s3.model.Bucket;
import com.amazonaws.services.s3.model.CreateBucketRequest;

import java.util.List;

public class App {

    private static AmazonS3 s3;

    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.format("Usage: <the bucket name> <the AWS Region to use>\n" +
                    "Example: my-test-bucket us-east-2\n");
            return;
        }

        String bucket_name = args[0];
        String region = args[1];

        s3 = AmazonS3ClientBuilder.standard()
                .withCredentials(new ProfileCredentialsProvider())
                .withRegion(region)
                .build();

        // List current buckets.
        ListMyBuckets();

        // Create the bucket.
        if (s3.doesBucketExistV2(bucket_name)) {
            System.out.format("\nCannot create the bucket. \n" +
                    "A bucket named '%s' already exists.", bucket_name);
            return;
        } else {
            try {
                System.out.format("\nCreating a new bucket named '%s'...\n\n", bucket_name);
                s3.createBucket(new CreateBucketRequest(bucket_name, region));
            } catch (AmazonS3Exception e) {
                System.err.println(e.getErrorMessage());
            }
        }

        // Confirm that the bucket was created.
        ListMyBuckets();

        // Delete the bucket.
        try {
            System.out.format("\nDeleting the bucket named '%s'...\n\n", bucket_name);
            s3.deleteBucket(bucket_name);
        } catch (AmazonS3Exception e) {
            System.err.println(e.getErrorMessage());
        }

        // Confirm that the bucket was deleted.
        ListMyBuckets();

    }

    private static void ListMyBuckets() {
        List<Bucket> buckets = s3.listBuckets();
        System.out.println("My buckets now are:");

        for (Bucket b : buckets) {
            System.out.println(b.getName());
        }
    }

}

步骤 7：构建并运行 AWS 开发工具包代码

要运行上一步中的代码，请从终端中运行以下命令。这些命令使用 Maven 或 Gradle 为项目创建可执行的 JAR 文件，然后使用 Java 运行程序来运行 JAR。JAR 使用要在 Amazon S3 中创建的存储桶的名称（如 my-test-bucket）和要在其中创建存储桶的 AWS 区域的 ID（如 us-east-2）作为输入来运行。

对于 Maven，运行以下命令。


cd my-app
mvn package
java -cp target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar com.mycompany.app.App my-test-bucket us-east-2

对于 Gradle，运行以下命令。


gradle build
gradle run -PappArgs="['my-test-bucket', 'us-east-2']"

将结果与以下输出进行比较。


My buckets now are:

Creating a new bucket named 'my-test-bucket'...

My buckets now are:

my-test-bucket

Deleting the bucket named 'my-test-bucket'...

My buckets now are:

第 8 步：清除

为防止在使用完该示例后一直对您的 AWS 账户收费，应删除环境。有关说明，请参阅在 AWS Cloud9 中删除环境。

Javascript 在您的浏览器中被禁用或不可用。

要使用 Amazon Web Services 文档，必须启用 Javascript。请参阅浏览器的帮助页面以了解相关说明。

文档惯例

WordPress 教程

C++ 教程