Oefening: een eenvoudige Tomcat Java-web-app maken

10 minuten

Webtoepassingen worden veel gebruikt voor het afhandelen van echte taken, zoals voorraadbeheer, onlineformulieren en klantgerichte portals. In deze module leert u hoe u een Java-webtoepassing maakt en implementeert met behulp van Apache Tomcat, een populaire opensource-server.

Stel dat u een ontwikkelaar bent die aan een project werkt om een dynamische webtoepassing te bouwen waar gebruikers in realtime gegevens kunnen invoeren en met uw platform kunnen communiceren. Uw client wil dat deze app lokaal beschikbaar is voor testen en in de cloud voor eenvoudige toegang. Met deze installatie kunt u eerst testen op uw lokale computer en vervolgens als een naadloze overgang naar een live-omgeving implementeren. Door deze installatie helemaal opnieuw te bouwen, beschikt u over flexibiliteit voor toekomstige updates en configuraties.

In deze module verkent u de essentiële stappen voor het bouwen en implementeren van een Java-web-app met Tomcat. U hebt twee opties: kloon een bestaande projectopslagplaats voor onmiddellijke implementatie of bouw een volledig nieuw project met Maven. Deze module bevat informatie over het instellen van uw Maven-project, het configureren van Tomcat, het lokaal implementeren van de app en het gebruik van hulpprogramma's zoals Maven voor het beheren van afhankelijkheden en pakketten.

Aan het einde van deze module kunt u webtoepassingen op basis van Java maken en implementeren op Tomcat, zodat u de implementatie van webtoepassingen zowel lokaal als in in de cloud gehoste omgevingen kunt ondersteunen.

Een Java Tomcat-web-app maken

In deze oefening maakt u een minimale Java-webtoepassing die een invoer gebruikt en het resultaat op het scherm weergeeft. Vervolgens implementeert u de web-app lokaal op uw computer met behulp van Tomcat. U hebt de volgende twee opties:

Optie 1: Kloon de voorbeeldopslagplaats en implementeer onmiddellijk uw web-app.
Optie 2: Een Volledig nieuw Maven Tomcat-project maken.

Optie 1: Kloon de voorbeeldopslagplaats en implementeer onmiddellijk uw web-app

Voer de volgende stappen uit om de repository te klonen:

Kloon de voorbeeldprojectopslagplaats met behulp van de volgende opdracht:

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

Navigeer naar de gekloonde projectopslagplaats met behulp van de volgende opdracht:
```
cd simple-tomcat-app
```

Gebruik de volgende stappen om uw lokale Tomcat-server te configureren, zodat u lokaal kunt implementeren in Tomcat:

Waarschuwing

Het rechtstreeks opslaan van gebruikersnamen en wachtwoorden in configuratiebestanden, zoals tomcat-users.xml en maven'ssettings.xml in tekst zonder opmaak, wordt niet als veilig beschouwd en we raden deze procedure over het algemeen niet aan, met name voor productieomgevingen. Andere alternatieven vallen echter buiten het bereik van deze trainingsmodule. Gebruik uw echte gebruikersnaam en wachtwoord niet.

Bewerk het tomcat-configuratiebestand conf/tomcat-users.xml zodat het eruitziet als in het volgende voorbeeld:

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

Voeg uw referenties toe aan het Maven-bestand ~/.m2/settings.xml met behulp van het volgende voorbeeld, waarbij u your-tomcat-username vervangt door een gebruikersnaam en your-tomcat-password door een wachtwoord.
```
<servers>
    <server>
        <id>TomcatServer</id>
        <username>your-tomcat-username</username>
        <password>your-tomcat-password</password>
    </server>
</servers>
```
Gebruik de volgende opdracht om uw web-app te verpakken en te implementeren:
```
mvn clean package cargo:deploy
```

Na de implementatie hebt u toegang tot uw app op http://localhost:8080/simple-tomcat-app.

Optie 2: Een Volledig nieuw Maven Tomcat-project maken

Als u een volledig nieuw Maven Tomcat-project wilt maken, voert u meerdere procedures uit, begint u met het maken van het Maven-project en eindigt u met het implementeren van uw web-app in Tomcat.

Een Maven-project maken

Gebruik de volgende opdracht om een Maven-project voor uw Java-webtoepassing te maken:

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

De volgende uitvoer is gebruikelijk:

[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] ------------------------------------------------------------------------

U hebt nu een nieuw Maven-webproject in een map met de naam simple-tomcat-app. De volgende bestanden en mappen zijn nu beschikbaar:

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

Het Maven-bestand pom.xml wijzigen

Wijzig het pom.xml bestand met behulp van de volgende stappen:

Open pom.xml en stel de Java-versie in op 21 met behulp van het volgende voorbeeld:

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

Voeg Tomcat- en Azure-implementatieinvoegtoepassingen toe met behulp van het volgende voorbeeld:

<!-- 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>

Hier volgt de volledige inhoud van het pom.xml-bestand :

<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>

Een webinterface maken

Als u een webpagina wilt toevoegen, bewerkt u het bestand src/main/webapp/index.jsp met behulp van het volgende voorbeeld:

<!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>

Een servlet maken

Een servlet is een Java-programmeerklasse die wordt gebruikt om de mogelijkheden van een server uit te breiden door aanvragen te verwerken en dynamische inhoud te genereren. Servlets worden uitgevoerd aan de serverzijde in een webcontainer, zoals Apache Tomcat, en worden voornamelijk gebruikt voor het verwerken van HTTP-aanvragen in webtoepassingen. Wanneer een client, bijvoorbeeld een webbrowser, een aanvraag naar een webserver verzendt, verwerkt de servlet de aanvraag. De servlet voert alle benodigde bedrijfslogica uit, bijvoorbeeld toegang tot databases of het aanroepen van andere services, en genereert vervolgens een antwoord ( vaak in de vorm van HTML ) om terug te sturen naar de client. Met Servlets kunnen ontwikkelaars dynamische, platformonafhankelijke webtoepassingen maken met behulp van Java.

Gebruik de volgende stappen om een servlet te maken:

Werk de bestandsstructuur bij om een servlet toe te voegen met behulp van de volgende opdracht:
```
mkdir -p src/main/java/com/example && touch src/main/java/com/example/HelloServlet.java
```

Werk de inhoud van het HelloSeverlet.java-bestand bij met behulp van het volgende codevoorbeeld:

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>");
    }
}

De nieuwe bestandsstructuur ziet er als volgt uit:

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

Lokaal implementeren in Tomcat

Gebruik de volgende stappen om uw lokale Tomcat-server te configureren, zodat u deze kunt implementeren:

Waarschuwing

Het rechtstreeks opslaan van gebruikersnamen en wachtwoorden in configuratiebestanden, zoals tomcat-users.xml en desettings.xml van Maven in tekst zonder opmaak, is niet veilig en wordt over het algemeen niet aanbevolen, met name voor productieomgevingen. Andere alternatieven vallen echter buiten het bereik van deze trainingsmodule. Gebruik uw echte gebruikersnaam en wachtwoord niet.

Bewerk het tomcat-configuratiebestand conf/tomcat-users.xml met behulp van het volgende voorbeeld:

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

Voeg uw referenties toe aan het bestand ~/.m2/settings.xml van Maven door het volgende voorbeeld te vervangen your-tomcat-username door een gebruikersnaam en your-tomcat-password een wachtwoord:
```
<servers>
    <server>
        <id>TomcatServer</id>
        <username>your-tomcat-username</username>
        <password>your-tomcat-password</password>
    </server>
</servers>
```

Uw web-app implementeren in Tomcat

Gebruik de volgende opdracht om uw web-app te verpakken en te implementeren:

mvn clean package cargo:deploy

Na de implementatie is uw app beschikbaar op http://localhost:8080/simple-tomcat-app.

Feedback

Is deze pagina nuttig?