Tutoriel Java pour AWS Cloud9

Vérifiez si Open JDK 8 est déjà installé. Pour ce faire, dans une session de terminal dans le AWS Cloud9 IDE, exécutez la version en ligne de commande du Java Runner avec l'-versionoption. (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez Window (Fenêtre), New Terminal (Nouveau terminal).)

java -version

En fonction de la sortie de la commande précédente, exécutez l'une des actions suivantes :

Assurez-vous que les dernières mises à jour de sécurité et que les correctifs les plus récents sont installés. Pour ce faire, exécutez l'outil yum (pour Amazon Linux) ou l'outil apt (pour Ubuntu Server) avec la commande update .

Pour Amazon Linux :

sudo yum -y update

Pour Ubuntu Server :

sudo apt update

Installez Open JDK 8. Pour ce faire, exécutez l'outil yum (pour Amazon Linux) ou l'outil apt (pour Ubuntu Server) avec la installcommande, en spécifiant le package Open JDK 8.

Pour Amazon Linux :

sudo yum -y install java-1.8.0-openjdk-devel

Pour Ubuntu Server :

sudo apt install -y openjdk-8-jdk

Pour plus d'informations, consultez Comment télécharger et installer des JDK packages Open prédéfinis sur le JDK site Web Open.

Basculez ou mettez à niveau le jeu d'outils de développement Java par défaut vers Open JDK 8. Pour ce faire, exécutez la commande update-alternatives avec l'option --config . Exécutez cette commande deux fois pour basculer ou mettre à niveau les versions de ligne de commande de l'exécuteur et compilateur Java.

sudo update-alternatives --config java
sudo update-alternatives --config javac

À chaque invite, tapez le numéro de sélection pour Open JDK 8 (celui qui contientjava-1.8).

Vérifiez que les versions en ligne de commande du programme d'exécution et du compilateur Java utilisent Open JDK 8. Pour ce faire, exécutez les versions de ligne de commande de l'exécuteur et compilateur Java avec l'option -version.

java -version
javac -version

Si Open JDK 8 est installé et défini correctement, la sortie de la version de Java Runner contient une valeur commençant paropenjdk version 1.8, et la sortie de la version du compilateur Java commence par cette valeurjavac 1.8.

Utilisez la version de ligne de commande du compilateur Java pour compiler le fichier hello.java en un fichier hello.class. Pour ce faire, à l'aide du terminal situé AWS Cloud9 IDE dans le même répertoire que le hello.java fichier, exécutez le compilateur Java en spécifiant le hello.java fichier.

javac hello.java

Utilisez la version de ligne de commande de l'exécuteur Java pour exécuter le fichier hello.class. Pour ce faire, dans le même répertoire que le fichier hello.class, exécutez l'exécuteur Java, en spécifiant le nom de la classe hello qui a été déclarée dans le fichier hello.java, avec deux nombres entiers à ajouter (par exemple, 5 et 9).

java hello 5 9

Comparez votre sortie.

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

Installez Maven dans votre environnement. Pour voir si Maven est déjà installé, utilisez le terminal situé dans le AWS Cloud9 IDE, exécutez Maven avec l'-versionoption.

mvn -version

En cas de réussite, la sortie contient le numéro de version Maven. Si Maven est déjà installé, passez directement à l'étape 4 de cette procédure pour utiliser Maven et générer un nouveau projet Java dans votre environnement.

Installez Maven en utilisant le terminal pour exécuter les commandes suivantes.

Pour Amazon Linux, les commandes suivantes obtiennent des informations sur le répertoire du paquet où Maven est stocké, puis utilisent ces informations pour installer 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

Pour plus d'informations sur les commandes précédentes, consultez Extra Packages for Enterprise Linux (EPEL) sur le site Web du Wiki du projet Fedora.

Pour Ubuntu Server, exécutez la commande suivante à la place.

sudo apt install -y maven

Vérifiez l'installation en exécutant Maven avec l'option -version .

mvn -version

Utilisez Maven pour générer un nouveau projet Java. Pour ce faire, utilisez le terminal pour exécuter la commande suivante à partir du répertoire dans lequel vous voulez que Maven génère le projet (par exemple, le répertoire racine de votre environnement).

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

La commande précédente crée la structure de répertoire suivante pour le projet de votre environnement.

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

Pour plus d'informations sur la structure de répertoire précédente, consultez Maven Quickstart Archetype et Introduction to the Standard Directory Layout sur le site web Apache Maven Project.

Modifiez le fichier Project Object Model (POM) du projet. (Un POM fichier définit les paramètres d'un projet Maven.) Pour ce faire, depuis la fenêtre Environment (Environnement), ouvrez le fichier my-app/pom.xml. Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier 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>

Le POM fichier précédent inclut les paramètres du projet qui spécifient des déclarations telles que les suivantes :

Installez Gradle dans votre environnement. Pour voir si Gradle est déjà installé, à l'aide du terminal du AWS Cloud9 IDE, exécutez Gradle avec l'-versionoption.

gradle -version

En cas de réussite, la sortie contient le numéro de version Gradle. Si Gradle est déjà installé, passez directement à l'étape 4 de cette procédure pour utiliser Gradle et générer un nouveau projet Java dans votre environnement.

Installez Gradle en utilisant le terminal pour exécuter les commandes suivantes. Ces commandes installent et exécutent le SDKMAN ! outil, puis utilisez-le SDKMAN ! pour installer la dernière version de Gradle.

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install gradle

Pour plus d'informations sur les commandes précédentes, voir Installation sur le SDKMAN ! site Web et installez avec un gestionnaire de packages sur le site Web de Gradle.

Vérifiez l'installation en exécutant Gradle avec l'option -version .

gradle -version

Utilisez Gradle pour générer un nouveau projet Java dans votre environnement. Pour ce faire, utilisez le terminal pour exécuter les commandes suivantes pour créer un répertoire pour le projet, puis basculez vers ce répertoire.

mkdir my-app
cd my-app

Exécutez la commande suivante pour que Gradle génère un nouveau projet d'application Java dans le répertoire my-app de votre environnement.

gradle init --type java-application

La commande précédente crée la structure de répertoire suivante pour le projet de votre environnement.

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

Modifiez le fichier AppTest.java pour le projet. (Si vous ne le faites pas, le projet risque de ne pas être généré ou de ne pas s'exécuter comme prévu). Pour ce faire, depuis la fenêtre Environment (Environnement), ouvrez le fichier my-app/src/test/java/AppTest.java. Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier 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.");
    }
  }
}

Modifiez le fichier build.gradle pour le projet. (Un fichier build.gradle définit les paramètres d'un projet Maven.) Pour ce faire, depuis la fenêtre Environment (Environnement), ouvrez le fichier my-app/build.gradle. Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier 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'

Le fichier build.gradle précédent inclut les paramètres de projet qui spécifient les déclarations telles que les suivantes :