Tutorial Java per AWS Cloud9

Verificate se Open JDK 8 è già installato. A tale scopo, in una sessione di terminale in AWS Cloud9 IDE, esegui la versione a riga di comando di Java runner con l'-versionopzione. Per avviare una nuova sessione del terminale, dalla barra dei menu scegli Window (Finestra), New Terminal (Nuovo terminale).

java -version

Dipendentemente dall'output del comando precedente, effettua una delle opzioni seguenti:

Assicurati che siano installati gli aggiornamenti di sicurezza e le correzioni dei bug i più recenti. Per effettuare questa operazione, esegui lo strumento yum (per Amazon Linux) o apt (per Ubuntu Server) con il comando update .

Per Amazon Linux:

sudo yum -y update

Per Ubuntu Server:

sudo apt update

Installa Open JDK 8. Per fare ciò, esegui lo strumento yum (per Amazon Linux) o lo strumento apt (per Ubuntu Server) con il installcomando, specificando il pacchetto Open JDK 8.

Per Amazon Linux:

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

Per Ubuntu Server:

sudo apt install -y openjdk-8-jdk

Per ulteriori informazioni, consulta Come scaricare e installare JDK pacchetti Open predefiniti sul sito Web Open. JDK

Passa o aggiorna il set di strumenti di sviluppo Java predefinito a Open JDK 8. A tale scopo, eseguire il comando update-alternatives con l'opzione --config . Esegui il comando due volte per passare o aggiornare le versioni della riga di comando del runner e compilatore Java.

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

A ogni prompt, digitate il numero di selezione per Open JDK 8 (quello che contienejava-1.8).

Verificate che le versioni a riga di comando del runner e del compilatore Java utilizzino Open 8. JDK Per effettuare questa operazione, esegui le versioni della riga di comando del runner e compilatore Java con l'opzione -version.

java -version
javac -version

Se Open JDK 8 è installato e impostato correttamente, l'output della versione di Java Runner contiene un valore che inizia con openjdk version 1.8 e l'output della versione del compilatore Java inizia con il valore. javac 1.8

Utilizza la versione della riga di comando del compilatore Java per compilare il file hello.java in un file hello.class. Per fare ciò, utilizzando il terminale contenuto in AWS Cloud9 IDE, dalla stessa directory del hello.java file, esegui il compilatore Java, specificando il hello.java file.

javac hello.java

Utilizza la versione della riga di comando del runner Java per eseguire il file hello.class. Per effettuare questa operazione, dalla stessa directory del file hello.class, esegui il runner Java, specificando il nome della classe hello che è stata dichiarata nel file hello.java, con due numeri interi da aggiungere (ad esempio, 5 e 9).

java hello 5 9

Confronta i risultati.

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

Installa Maven nell'ambiente. Per vedere se Maven è già installato, utilizza il terminale in AWS Cloud9 IDE, esegui Maven con l'opzione. -version

mvn -version

In caso di esito positivo, l'output includerà il numero di versione di Maven. Se Maven è già installato, passa alla fase 4 in questa procedura per utilizzare Maven per generare un nuovo progetto Java nell'ambiente.

Installa Maven utilizzando il terminale per eseguire i seguenti comandi.

Per Amazon Linux, i seguenti comandi ottengono informazioni sul repository di pacchetti in cui è archiviato Maven, quindi utilizzano queste informazioni per installare 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

Per ulteriori informazioni sui comandi precedenti, vedere Extra Packages for Enterprise Linux (EPEL) sul sito Wiki del Fedora Project.

Per Ubuntu Server, esegui invece il comando seguente.

sudo apt install -y maven

Conferma l'installazione eseguendo Maven con l'opzione -version .

mvn -version

Utilizza Maven per generare un nuovo progetto Java. Per effettuare questa operazione, utilizza il terminale per eseguire il comando seguente dalla directory in cui Maven deve generare il progetto (ad esempio, la directory principale dell'ambiente).

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

Il comando precedente crea la seguente struttura di directory per il progetto nell'ambiente.

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

Per ulteriori informazioni sulla struttura di directory precedente, consulta Maven Quickstart Archetype e Introduction to the Standard Directory Layout sul sito Web Apache Maven Project.

Modifica il file Project Object Model (POM) per il progetto. (Un POM file definisce le impostazioni di un progetto Maven.) Per effettuare questa operazione, dalla finestra Environment (Ambiente) apri il file my-app/pom.xml. Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file 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>

Il POM file precedente include le impostazioni del progetto che specificano dichiarazioni come le seguenti:

Installa Gradle nell'ambiente. Per vedere se Gradle è già installato, usando il terminale in AWS Cloud9 IDE, esegui Gradle con l'-versionopzione.

gradle -version

In caso di esito positivo, l'output includerà il numero di versione di Gradle. Se Gradle è già installato, passa alla fase 4 in questa procedura per utilizzare Gradle per generare un nuovo progetto Java nell'ambiente.

Installa Gradle utilizzando il terminale per eseguire i seguenti comandi. Questi comandi installano ed eseguono il file! SDKMAN strumento, e poi usaSDKMAN! per installare l'ultima versione di Gradle.

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

Per ulteriori informazioni sui comandi precedenti, consulta Installazione su! SDKMAN sito Web e Installa con un gestore di pacchetti sul sito Web Gradle.

Conferma l'installazione eseguendo Gradle con l'opzione -version .

gradle -version

Usa Gradle per generare un nuovo progetto Java nell'ambiente. Per effettuare questa operazione, usa il terminale per eseguire i seguenti comandi per creare una directory per il progetto, quindi passa a quella directory.

mkdir my-app
cd my-app

Esegui il comando seguente per fare in modo che Gradle generi un nuovo progetto di applicazione Java nella directory my-app dell'ambiente.

gradle init --type java-application

Il comando precedente crea la seguente struttura di directory per il progetto nell'ambiente.

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

Modifica AppTest.java per il progetto. Se non si effettua questa operazione, il progetto potrebbe non essere creato o eseguito come previsto. Per effettuare questa operazione, dalla finestra Environment (Ambiente) apri il file my-app/src/test/java/AppTest.java. Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file 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.");
    }
  }
}

Modifica il file build.gradle per il progetto. Un file build.gradle definisce le impostazioni di un progetto Gradle. Per effettuare questa operazione, dalla finestra Environment (Ambiente) apri il file my-app/build.gradle. Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file 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'

Il file build.gradle precedente include le impostazioni di progetto che specificano dichiarazioni come le seguenti: