AWS Cloud9 is no longer available to new customers. Existing customers of
AWS Cloud9 can continue to use the service as normal.
Learn more
Java tutorial for AWS Cloud9
Important
If you're using an AWS Cloud9 development environment that's backed by an EC2 instance with 2 GiB or more of memory, we recommend that you activate enhanced Java support. This provides access to productivity features such as code completion, linting for errors, context-specific actions, and debugging options such as breakpoints and stepping.
For more information, see Enhanced support for Java development.
This tutorial enables you to run some Java code in an AWS Cloud9 development environment.
Following this tutorial and creating this sample might result in charges to your AWS
account. These include possible charges for services such as Amazon EC2 and Amazon S3. For more
information, see Amazon EC2 Pricing
Topics
Prerequisites
Before you use this sample, make sure that your setup meets the following requirements:
-
You must have an existing AWS Cloud9 EC2 development environment. This sample assumes that you already have an EC2 environment that's connected to an Amazon EC2 instance that runs Amazon Linux or Ubuntu Server. If you have a different type of environment or operating system, you might need to adapt this sample's instructions to set up related tools. For more information, see Creating an environment in AWS Cloud9.
-
You have the AWS Cloud9 IDE for the existing environment already open. When you open an environment, AWS Cloud9 opens the IDE for that environment in your web browser. For more information, see Opening an environment in AWS Cloud9.
Step 1: Install required tools
In this step, you install a set of Java development tools in your AWS Cloud9 development environment. If you already have a set of Java development tools such as the Oracle JDK or OpenJDK installed in your environment, you can skip ahead to Step 2: Add code. This sample was developed with OpenJDK 8, which you can install in your environment by completing the following procedure.
-
Confirm whether OpenJDK 8 is already installed. To do this, in a terminal session in the AWS Cloud9 IDE, run the command line version of the Java runner with the
-version
option. (To start a new terminal session, on the menu bar, choose Window, New Terminal.)java -version
Based on the output of the preceding command, do one of the following:
-
If the output states that the
java
command isn't found, continue with step 2 in this procedure to install OpenJDK 8. -
If the output contains values starting with
Java(TM)
,Java Runtime Environment
,Java SE
,J2SE
, orJava2
, the OpenJDK isn't installed or isn't set as the default Java development toolset. Continue with step 2 in this procedure to install OpenJDK 8, and then switch to using OpenJDK 8. -
If the output contains values starting with
java version 1.8
andOpenJDK
, skip ahead to Step 2: Add code. OpenJDK 8 is installed correctly for this sample. -
If the output contains a
java version
less than1.8
and values starting withOpenJDK
, continue with step 2 in this procedure to upgrade the installed OpenJDK version to OpenJDK 8.
-
-
Ensure the latest security updates and bug fixes are installed. To do this, run the yum tool (for Amazon Linux) or the apt tool (for Ubuntu Server) with the
update
command.For Amazon Linux:
sudo yum -y update
For Ubuntu Server:
sudo apt update
-
Install OpenJDK 8. To do this, run the yum tool (for Amazon Linux) or the apt tool (for Ubuntu Server) with the
install
command, specifying the OpenJDK 8 package.For Amazon Linux:
sudo yum -y install java-1.8.0-openjdk-devel
For Ubuntu Server:
sudo apt install -y openjdk-8-jdk
For more information, see How to download and install prebuilt OpenJDK packages
on the OpenJDK website. -
Switch or upgrade the default Java development toolset to OpenJDK 8. To do this, run the
update-alternatives
command with the--config
option. Run this command twice to switch or upgrade the command line versions of the Java runner and compiler.sudo update-alternatives --config java sudo update-alternatives --config javac
At each prompt, type the selection number for OpenJDK 8 (the one that contains
java-1.8
). -
Confirm that the command line versions of the Java runner and compiler are using OpenJDK 8. To do this, run the command line versions of the Java runner and compiler with the
-version
option.java -version javac -version
If OpenJDK 8 is installed and set correctly, the Java runner version output contains a value starting with
openjdk version 1.8
, and the Java compiler version output starts with the valuejavac 1.8
.
Step 2: Add code
In the AWS Cloud9 IDE, create a file with the following code, and save the file with the name
hello.java
. (To create a file, on the menu bar, choose
File, New File. To save the file, choose
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)); } }
Step 3: Build and run the code
-
Use the command line version of the Java compiler to compile the
hello.java
file into ahello.class
file. To do this, using the terminal in the AWS Cloud9 IDE, from the same directory as thehello.java
file, run the Java compiler, specifying thehello.java
file.javac hello.java
-
Use the command line version of the Java runner to run the
hello.class
file. To do this, from the same directory as thehello.class
file, run the Java runner, specifying the name of thehello
class that was declared in thehello.java
file, with two integers to add (for example,5
and9
).java hello 5 9
-
Compare your output.
Hello, World! The sum of 2 and 3 is 5. The sum of 5 and 9 is 14.
Step 4: Set up to use the AWS SDK for Java
You can enhance this sample to use the AWS SDK for Java to create an Amazon S3 bucket, list your available buckets, and then delete the bucket you just created.
In this step, you install Apache Maven
Set up with Maven
-
Install Maven in your environment. To see whether Maven is already installed, using the terminal in the AWS Cloud9 IDE, run Maven with the
-version
option.mvn -version
If successful, the output contains the Maven version number. If Maven is already installed, skip ahead to step 4 in this procedure to use Maven to generate a new Java project in your environment.
-
Install Maven by using the terminal to run the following commands.
For Amazon Linux, the following commands get information about the package repository where Maven is stored, and then use this information to install 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
For more information about the preceding commands, see Extra Packages for Enterprise Linux (EPEL)
on the Fedora Project Wiki website. For Ubuntu Server, run the following command instead.
sudo apt install -y maven
-
Confirm the installation by running Maven with the
-version
option.mvn -version
-
Use Maven to generate a new Java project. To do this, use the terminal to run the following command from the directory where you want Maven to generate the project (for example, the root directory of your environment).
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
The preceding command creates the following directory structure for the project in your environment.
my-app |- src | `- main | `- java | `- com | `- mycompany | `- app | `-App.java |- test | `- java | `- com | `- mycompany | `- app | `- AppTest.java `- pom.xml
For more information about the preceding directory structure, see Maven Quickstart Archetype
and Introduction to the Standard Directory Layout on the Apache Maven Project website. -
Modify the Project Object Model (POM) file for the project. (A POM file defines a Maven project's settings.) To do this, from the Environment window, open the
my-app/pom.xml
file. In the editor, replace the file's current contents with the following code, and then save thepom.xml
file.<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>
The preceding POM file includes project settings that specify declarations such as the following:
-
The
artifactid
setting ofmy-app
sets the project's root directory name, and thegroup-id
setting ofcom.mycompany.app
sets thecom/mycompany/app
subdirectory structure and thepackage
declaration in theApp.Java
andAppTest.java
files. -
The
artifactId
setting ofmy-app
, with thepackaging
setting ofjar
, theversion
setting of1.0-SNAPSHOT
, and thedescriptorRef
setting ofjar-with-dependencies
set the output JAR file's name ofmy-app-1.0-SNAPSHOT-jar-with-dependencies.jar
. -
The
plugin
section declares that a single JAR, which includes all dependencies, will be built. -
The
dependency
section with thegroupId
setting ofcom.amazon.aws
and theartifactId
setting ofaws-java-sdk
includes the AWS SDK for Java library files. The AWS SDK for Java version to use is declared by theversion
setting. To use a different version, replace this version number.
-
Skip ahead to Step 5: Set up AWS credentials management in your environment.
Set up with Gradle
-
Install Gradle in your environment. To see whether Gradle is already installed, using the terminal in the AWS Cloud9 IDE, run Gradle with the
-version
option.gradle -version
If successful, the output contains the Gradle version number. If Gradle is already installed, skip ahead to step 4 in this procedure to use Gradle to generate a new Java project in your environment.
-
Install Gradle by using the terminal to run the following commands. These commands install and run the SDKMAN! tool, and then use SDKMAN! to install the latest version of Gradle.
curl -s "https://get.sdkman.io" | bash source "$HOME/.sdkman/bin/sdkman-init.sh" sdk install gradle
For more information about the preceding commands, see Installation
on the SDKMAN! website and Install with a package manager on the Gradle website. -
Confirm the installation by running Gradle with the
-version
option.gradle -version
-
Use Gradle to generate a new Java project in your environment. To do this, use the terminal to run the following commands to create a directory for the project, and then switch to that directory.
mkdir my-app cd my-app
-
Run the following command to have Gradle generate a new Java application project in the
my-app
directory in your environment.gradle init --type java-application
The preceding command creates the following directory structure for the project in your environment.
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
-
Modify the
AppTest.java
for the project. (If you do not do this, the project might not build or run as expected). To do this, from the Environment window, open themy-app/src/test/java/AppTest.java
file. In the editor, replace the file's current contents with the following code, and then save theAppTest.java
file.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."); } } }
-
Modify the
build.gradle
file for the project. (Abuild.gradle
file defines a Gradle project's settings.) To do this, from the Environment window, open themy-app/build.gradle
file. In the editor, replace the file's current contents with the following code, and then save thebuild.gradle
file.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'
The preceding
build.gradle
file includes project settings that specify declarations such as the following:-
The
io.spring.dependency-management
plugin is used to import the AWS SDK for Java Maven Bill of Materials (BOM) to manage AWS SDK for Java dependencies for the project.classpath
declares the version to use. To use a different version, replace this version number. -
com.amazonaws:aws-java-sdk-s3
includes the Amazon S3 portion of the AWS SDK for Java library files.mavenBom
declares the version to use. If you want to use a different version, replace this version number.
-
Step 5: Set up AWS credentials management in your environment
Each time you use the AWS SDK for Java to call an AWS service, you must provide a set of AWS credentials with the call. These credentials determine whether the AWS SDK for Java has the appropriate permissions to make that call. If the credentials don't cover the appropriate permissions, the call will fail.
In this step, you store your credentials within the environment. To do this, follow the instructions in Calling AWS services from an environment in AWS Cloud9, and then return to this topic.
For additional information, see Set up AWS Credentials and Region for Development in the AWS SDK for Java Developer Guide.
Step 6: Add AWS SDK code
In this step, you add code to interact with Amazon S3 to create a bucket, list your available buckets, and then delete the bucket you just created.
From the Environment window, open the
my-app/src/main/java/com/mycompany/app/App.java
file for Maven or the
my-app/src/main/java/App.java
file for Gradle. In the editor, replace
the file's current contents with the following code, and then save the
App.java
file.
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()); } } }
Step 7: Build and run the AWS SDK code
To run the code from the previous step, run the following commands from the terminal.
These commands use Maven or Gradle to create an executable JAR file for the project, and then
use the Java runner to run the JAR. The JAR runs with the name of the bucket to create in Amazon S3
(for example, my-test-bucket
) and the ID of the AWS Region to create the bucket
in as input (for example, us-east-2
).
For Maven, run the following commands.
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
For Gradle, run the following commands.
gradle build gradle run -PappArgs="['my-test-bucket', 'us-east-2']"
Compare your results to the following output.
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:
Step 8: Clean up
To prevent ongoing charges to your AWS account after you're done using this sample, you should delete the environment. For instructions, see Deleting an environment in AWS Cloud9.