Esercizio - Creare una semplice app Web Java Tomcat

10 minuti

Le applicazioni Web sono ampiamente usate per gestire attività reali, ad esempio la gestione dell'inventario, i moduli online e i portali rivolti ai clienti. In questo modulo si apprenderà come creare e distribuire un'applicazione Web Java usando Apache Tomcat, un server open source diffuso.

Si supponga di essere uno sviluppatore che lavora su un progetto per creare un'applicazione Web dinamica in cui gli utenti possono immettere dati e interagire con la piattaforma in tempo reale. Il client vuole che questa app sia disponibile in locale per i test e nel cloud per semplificare l'accesso. Questa configurazione consente di eseguire prima il test nel computer locale e quindi distribuirlo in un ambiente live come transizione senza problemi. La creazione di questa configurazione da zero offre flessibilità per gli aggiornamenti e le configurazioni futuri.

In questo modulo vengono esaminati i passaggi essenziali per la compilazione e la distribuzione di un'app Web Java con Tomcat. Sono disponibili due opzioni: clonare un repository di progetto esistente per la distribuzione immediata o compilare un nuovo progetto da zero con Maven. Questo modulo illustra la configurazione del progetto Maven, la configurazione di Tomcat, la distribuzione dell'app in locale e l'uso di strumenti come Maven per gestire dipendenze e pacchetti.

Al termine di questo modulo, si sarà in grado di creare e distribuire applicazioni Web basate su Java in Tomcat, preparando l'utente a supportare la distribuzione di applicazioni Web sia in locale che in ambienti ospitati nel cloud.

Creare un'app Web Java Tomcat

In questo esercizio si crea un'applicazione Web Java minima che accetta un input e visualizza il risultato sullo schermo. Distribuire quindi l'app Web in locale nel computer usando Tomcat. Sono disponibili le due opzioni seguenti:

Opzione 1: clonare il repository di esempio e distribuire immediatamente l'app Web.
Opzione 2: Creare un progetto Tomcat Maven da zero.

Opzione 1: Clonare il repository di esempio e distribuire immediatamente l'app Web

Per clonare il repository, seguire questa procedura:

Clonare il repository di progetto di esempio usando il comando seguente:

git clone https://github.com/MicrosoftDocs/simple-tomcat-maven-app.git

Passare al repository del progetto clonato usando il comando seguente:
```
cd simple-tomcat-app
```

Usare la procedura seguente per configurare il server Tomcat locale in modo che sia possibile eseguire la distribuzione in locale in Tomcat:

Avvertimento

L'archiviazione di nomi utente e password direttamente nei file di configurazione come tomcat-users.xml e settings.xml maven in testo normale non è considerata sicura e in genere non è consigliabile usare questa procedura, soprattutto per gli ambienti di produzione. Tuttavia, altre alternative non rientrano nell'ambito di questo modulo di training. Non usare il nome utente e la password reali.

Modificare il file di configurazione tomcat conf/tomcat-users.xmlin modo che sia simile all'esempio seguente:

<tomcat-users>
    <user username="your-tomcat-username" password="your-tomcat-password" roles="manager-script"/>
</tomcat-users>

Aggiungere le credenziali al file maven ~/.m2/settings.xml usando l'esempio seguente, in cui si sostituisce your-tomcat-username con un nome utente e your-tomcat-password con una password:
```
<servers>
    <server>
        <id>TomcatServer</id>
        <username>your-tomcat-username</username>
        <password>your-tomcat-password</password>
    </server>
</servers>
```
Usare il comando seguente per creare un pacchetto e distribuire l'app Web:
```
mvn clean package cargo:deploy
```

Dopo la distribuzione, è possibile accedere all'app all'indirizzo http://localhost:8080/simple-tomcat-app.

Opzione 2: Creare un progetto Tomcat Maven da zero

Per creare un progetto Tomcat Maven da zero, è necessario eseguire più procedure, a partire dalla creazione del progetto Maven e terminare con la distribuzione dell'app Web in Tomcat.

Creare un progetto Maven

Per creare un progetto Maven per l'applicazione Web Java, usare il comando seguente:

mvn archetype:generate \
    -DgroupId=com.example \
    -DartifactId=simple-tomcat-app \
    -DarchetypeArtifactId=maven-archetype-webapp \
    -DinteractiveMode=false

L'output seguente è tipico:

[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: basedir, Value: /home/XXXXXXXX/LearnProjects/simple-tomcat-maven-app
[INFO] Parameter: package, Value: com.microsoft.azure.samples
[INFO] Parameter: groupId, Value: com.microsoft.azure.samples
[INFO] Parameter: artifactId, Value: azure-javaweb-app-simple
[INFO] Parameter: packageName, Value: com.microsoft.azure.samples
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: /private/tmp/TMP/azure-javaweb-app
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  1.657 s
[INFO] Finished at: 2024-10-18T12:39:41-07:00
[INFO] ------------------------------------------------------------------------

È ora disponibile un nuovo progetto Web Maven in una cartella denominata simple-tomcat-app. Sono ora disponibili i file e le directory seguenti:

└── simple-tomcat-app
    ├── pom.xml
    └── src
        ├── main
        │   ├── java
        │   ├── resources
        │   └── webapp
        │       ├── index.jsp
        │       └── WEB-INF
        │           └── web.xml
        └── test
            ├── java
            └── resources

Modificare il file pom.xml di Maven

Modificare il filepom.xml attenendosi alla procedura seguente:

Aprire pom.xml e impostare la versione Java su 21 usando l'esempio seguente:

<java.version>21</java.version>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>

Aggiungere plug-in di distribuzione Tomcat e Azure usando l'esempio seguente:

<!-- Tomcat 10 Maven Plugin -->
<plugin>
  <groupId>org.codehaus.cargo</groupId>
  <artifactId>cargo-maven3-plugin</artifactId>
  <version>1.9.9</version>
  <configuration>
    <!-- Container Configuration -->
    <container>
      <containerId>tomcat10x</containerId>
      <type>remote</type>
    </container>
    <!-- Configuration for Remote Deployment -->
    <configuration>
      <type>runtime</type>
      <properties>
        <cargo.remote.uri>http://localhost:8080/manager/text</cargo.remote.uri>
        <cargo.remote.username>cargo</cargo.remote.username>
        <cargo.remote.password>your-cargo-password</cargo.remote.password>
      </properties>
    </configuration>
    <!-- Deployable Artifact Configuration -->
    <deployables>
      <deployable>
        <groupId>${project.groupId}</groupId>
        <artifactId>${project.artifactId}</artifactId>
        <type>war</type>
        <properties>
          <context>${project.artifactId}</context>
        </properties>
      </deployable>
    </deployables>
  </configuration>
</plugin>

Ecco il contenuto completo del 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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>simple-tomcat-app</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>simple-tomcat-app</name>
  <properties>
    <java.version>21</java.version>
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>jakarta.servlet</groupId>
      <artifactId>jakarta.servlet-api</artifactId>
      <version>6.0.0</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
  <build>
    <finalName>simple-tomcat-app</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.10.1</version>
        <configuration>
          <source>${java.version}</source>
          <target>${java.version}</target>
        </configuration>
      </plugin>
      <!-- Tomcat 10 Maven Plugin -->
      <plugin>
        <groupId>org.codehaus.cargo</groupId>
        <artifactId>cargo-maven3-plugin</artifactId>
        <version>1.9.9</version>
        <configuration>
          <!-- Container Configuration -->
          <container>
            <containerId>tomcat10x</containerId>
            <type>remote</type>
          </container>
          <!-- Configuration for Remote Deployment -->
          <configuration>
            <type>runtime</type>
            <properties>
              <cargo.remote.uri>http://localhost:8080/manager/text</cargo.remote.uri>
              <cargo.remote.username>cargo</cargo.remote.username>
              <cargo.remote.password>your-cargo-password</cargo.remote.password>
            </properties>
          </configuration>
          <!-- Deployable Artifact Configuration -->
          <deployables>
            <deployable>
              <groupId>${project.groupId}</groupId>
              <artifactId>${project.artifactId}</artifactId>
              <type>war</type>
              <properties>
                <context>${project.artifactId}</context>
              </properties>
            </deployable>
          </deployables>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Creare un'interfaccia Web

Per aggiungere una pagina Web, modificare il file src/main/webapp/index.jsp usando l'esempio seguente:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Simple Tomcat App</title>
</head>
<body>
    <h1>Welcome to the Simple Tomcat App</h1>
    <form action="hello" method="get">
        <label for="name">Enter your name:</label>
        <input type="text" id="name" name="name">
        <button type="submit">Submit</button>
    </form>
</body>
</html>

Creare un servlet

Un servlet è una classe di programmazione Java usata per estendere le funzionalità di un server gestendo le richieste e generando contenuto dinamico. I Servlet vengono eseguiti sul lato server all'interno di un contenitore Web, ad esempio Apache Tomcat, e vengono usati principalmente per elaborare le richieste HTTP nelle applicazioni Web. Quando un client, ad esempio un Web browser, invia una richiesta a un server Web, il servlet elabora la richiesta. Il servlet esegue qualsiasi logica di business necessaria, ad esempio l'accesso ai database o la chiamata ad altri servizi, e quindi genera una risposta, spesso sotto forma di HTML, da inviare al client. I Servlet consentono agli sviluppatori di creare applicazioni Web dinamiche indipendenti dalla piattaforma usando Java.

Per creare un servlet, seguire questa procedura:

Aggiornare la struttura di file per aggiungere un servlet usando il comando seguente:

mkdir -p src/main/java/com/example && touch src/main/java/com/example/HelloServlet.java

Aggiornare il contenuto del file HelloSeverlet.java usando l'esempio di codice seguente:

package com.example;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String name = request.getParameter("name");
        response.setContentType("text/html");
        response.getWriter().write("<h1>Hello, " + name + "!</h1>");
    }
}

La nuova struttura di file è simile alla seguente:

└── simple-tomcat-app
    ├── pom.xml
    └── src
        ├── main
        │   ├── java
        │   │   └── com
        │   │       └── example
        │   │           └── HelloServlet.java
        │   ├── resources
        │   └── webapp
        │       ├── index.jsp
        │       └── WEB-INF
        │           └── web.xml
        └── test
            ├── java
            └── resources

Distribuire localmente su Tomcat

Usare la procedura seguente per configurare il server Tomcat locale in modo che sia possibile distribuirlo:

Avvertimento

L'archiviazione di nomi utente e password direttamente nei file di configurazione come tomcat-users.xml e settings.xml di Maven in testo normale non è sicura e non è in genere consigliata, soprattutto per gli ambienti di produzione. Tuttavia, altre alternative non rientrano nell'ambito di questo modulo di training. Non usare il nome utente e la password reali.

Modificare il file di configurazione tomcat conf/tomcat-users.xml usando l'esempio seguente:

<tomcat-users>
    <user username="your-tomcat-username" password="your-tomcat-password" roles="manager-script"/>
</tomcat-users>

Aggiungere le credenziali al file ~/.m2/ di Mavensettings.xml usando l'esempio seguente, sostituendo your-tomcat-username con un nome utente e your-tomcat-password con una password:

<servers>
    <server>
        <id>TomcatServer</id>
        <username>your-tomcat-username</username>
        <password>your-tomcat-password</password>
    </server>
</servers>

Distribuire l'applicazione web su Tomcat

Usare il comando seguente per creare un pacchetto e distribuire l'app Web:

mvn clean package cargo:deploy

Dopo la distribuzione, l'app è disponibile all'indirizzo http://localhost:8080/simple-tomcat-app.

Commenti e suggerimenti

Questa pagina è stata utile?