Übung – Erstellen einer einfachen Tomcat-Java-Web-App
Webanwendungen werden häufig verwendet, um reale Aufgaben wie Bestandsverwaltung, Onlineformulare und kundenorientierte Portale zu verarbeiten. In diesem Modul erfahren Sie, wie Sie eine Java-Webanwendung mit Apache Tomcat, einem beliebten Open-Source-Server, erstellen und bereitstellen.
Angenommen, Sie sind Entwickler, die an einem Projekt arbeiten, um eine dynamische Webanwendung zu erstellen, in der Benutzer Daten eingeben und mit Ihrer Plattform in Echtzeit interagieren können. Ihr Client möchte, dass diese App lokal zum Testen und in der Cloud für einfachen Zugriff verfügbar ist. Mit diesem Setup können Sie zuerst auf Ihrem lokalen Computer testen und dann als nahtlosen Übergang in einer Liveumgebung bereitstellen. Das Erstellen dieses Setups bietet Ihnen Flexibilität für zukünftige Updates und Konfigurationen.
In diesem Modul untersuchen Sie die wesentlichen Schritte zum Erstellen und Bereitstellen einer Java-Web-App mit Tomcat. Sie haben zwei Optionen: Entweder klonen Sie ein vorhandenes Projekt-Repository für die sofortige Bereitstellung, oder erstellen Sie ein neues Projekt von Grund auf neu mit Maven. Dieses Modul behandelt das Einrichten Ihres Maven-Projekts, das Konfigurieren von Tomcat, die lokale Bereitstellung der App und die Verwendung von Tools wie Maven zum Verwalten von Abhängigkeiten und Paketen.
Am Ende dieses Moduls können Sie Java-basierte Webanwendungen auf Tomcat erstellen und bereitstellen, die Sie vorbereiten, um die Bereitstellung von Webanwendungen sowohl lokal als auch in in cloudgehosteten Umgebungen zu unterstützen.
Erstellen einer Java Tomcat-Web-App
In dieser Übung erstellen Sie eine minimale Java-Webanwendung, die eine Eingabe akzeptiert und das Ergebnis auf dem Bildschirm anzeigt. Anschließend stellen Sie die Web-App lokal auf Ihrem Computer mithilfe von Tomcat bereit. Sie haben die folgenden beiden Optionen:
- Option 1: Klonen Sie das Beispiel-Repository, und stellen Sie Ihre Web-App sofort bereit.
- Option 2: Erstellen Sie ein Maven Tomcat-Projekt von Grund auf neu.
Option 1: Klonen des Beispiel-Repositorys und sofortiges Bereitstellen Ihrer Web-App
Führen Sie zum Klonen des Repositorys die folgenden Schritte aus:
Klonen Sie das Beispielprojekt-Repository mithilfe des folgenden Befehls:
git clone https://github.com/MicrosoftDocs/simple-tomcat-maven-app.gitNavigieren Sie mithilfe des folgenden Befehls zum geklonten Projekt-Repository:
cd simple-tomcat-app
Führen Sie die folgenden Schritte aus, um Ihren lokalen Tomcat-Server so zu konfigurieren, dass Sie lokal auf Tomcat bereitstellen können:
Warnung
Das direkte Speichern von Benutzernamen und Kennwörtern in Konfigurationsdateien wie tomcat-users.xml und mavens settings.xml im Nur-Text-Format wird nicht als sicher angesehen, und im Allgemeinen wird diese Vorgehensweise nicht empfohlen – insbesondere für Produktionsumgebungen. Andere Alternativen liegen jedoch außerhalb des Umfangs dieses Schulungsmoduls. Verwenden Sie nicht Ihren echten Benutzernamen und Ihr Kennwort!
Bearbeiten Sie die Konfigurationsdatei "Tomcat conf/tomcat-users.xml ", damit sie wie im folgenden Beispiel aussieht:
<tomcat-users> <user username="your-tomcat-username" password="your-tomcat-password" roles="manager-script"/> </tomcat-users>Fügen Sie Ihre Anmeldeinformationen zur Maven-Datei ~/.m2/settings.xml hinzu, indem Sie das folgende Beispiel verwenden, bei dem Sie
your-tomcat-usernamedurch einen Benutzernamen undyour-tomcat-passworddurch ein Kennwort ersetzen.<servers> <server> <id>TomcatServer</id> <username>your-tomcat-username</username> <password>your-tomcat-password</password> </server> </servers>Verwenden Sie den folgenden Befehl, um Ihre Web-App zu packen und bereitzustellen:
mvn clean package cargo:deploy
Nach der Bereitstellung können Sie auf Ihre App zugreifen unter http://localhost:8080/simple-tomcat-app.
Option 2: Erstellen eines Maven Tomcat-Projekts von Grund auf neu
Um ein Maven Tomcat-Projekt von Grund auf neu zu erstellen, arbeiten Sie durch mehrere Prozeduren, angefangen beim Erstellen des Maven-Projekts und enden mit der Bereitstellung Ihrer Web-App in Tomcat.
Erstellen eines Maven-Projekts
Verwenden Sie den folgenden Befehl, um ein Maven-Projekt für Ihre Java-Webanwendung zu erstellen:
mvn archetype:generate \
-DgroupId=com.example \
-DartifactId=simple-tomcat-app \
-DarchetypeArtifactId=maven-archetype-webapp \
-DinteractiveMode=false
Die folgende Ausgabe ist typisch:
[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] ------------------------------------------------------------------------
Sie haben jetzt ein neues Maven-Webprojekt in einem Ordner mit dem Namen "simple-tomcat-app". Die folgenden Dateien und Verzeichnisse sind jetzt verfügbar:
└── simple-tomcat-app
├── pom.xml
└── src
├── main
│ ├── java
│ ├── resources
│ └── webapp
│ ├── index.jsp
│ └── WEB-INF
│ └── web.xml
└── test
├── java
└── resources
Ändern der Maven-Datei „pom.xml“
Ändern Sie die pom.xml Datei mithilfe der folgenden Schritte:
Öffnen Sie pom.xml , und legen Sie die Java-Version mithilfe des folgenden Beispiels auf 21 fest:
<java.version>21</java.version> <maven.compiler.source>21</maven.compiler.source> <maven.compiler.target>21</maven.compiler.target>Fügen Sie Tomcat- und Azure-Bereitstellungs-Plug-Ins mithilfe des folgenden Beispiels hinzu:
<!-- 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 sehen Sie den vollständigen Inhalt der Dateipom.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>
Erstellen einer Weboberfläche
Um eine Webseite hinzuzufügen, bearbeiten Sie die Datei "src/main/webapp/index.jsp " mithilfe des folgenden Beispiels:
<!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>
Erstellen eines Servlets
Ein Servlet ist eine Java-Programmierklasse, die zum Erweitern der Funktionen eines Servers verwendet wird, indem Anforderungen verarbeitet und dynamische Inhalte generiert werden. Servlets werden auf der Serverseite in einem Webcontainer ( z. B. Apache Tomcat ) ausgeführt und werden in erster Linie zum Verarbeiten von HTTP-Anforderungen in Webanwendungen verwendet. Wenn ein Client – z. B. ein Webbrowser – eine Anforderung an einen Webserver sendet, verarbeitet das Servlet die Anforderung. Das Servlet führt eine erforderliche Geschäftslogik aus , z. B. beim Zugriff auf Datenbanken oder beim Aufrufen anderer Dienste – und generiert dann eine Antwort - häufig in Form von HTML -, um an den Client zurückzusenden. Mit Servlets können Entwickler dynamische, plattformunabhängige Webanwendungen mit Java erstellen.
Führen Sie die folgenden Schritte aus, um ein Servlet zu erstellen:
Aktualisieren Sie die Dateistruktur, um ein Servlet mithilfe des folgenden Befehls hinzuzufügen:
mkdir -p src/main/java/com/example && touch src/main/java/com/example/HelloServlet.javaAktualisieren Sie den Inhalt der HelloSeverlet.java-Datei mithilfe des folgenden Codebeispiels:
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>"); } }
Die neue Dateistruktur sieht wie folgt aus:
└── simple-tomcat-app
├── pom.xml
└── src
├── main
│ ├── java
│ │ └── com
│ │ └── example
│ │ └── HelloServlet.java
│ ├── resources
│ └── webapp
│ ├── index.jsp
│ └── WEB-INF
│ └── web.xml
└── test
├── java
└── resources
Lokal auf einem Tomcat-Server bereitstellen.
Führen Sie die folgenden Schritte aus, um Ihren lokalen Tomcat-Server so zu konfigurieren, dass Sie ihn bereitstellen können:
Warnung
Das direkte Speichern von Benutzernamen und Kennwörtern in Konfigurationsdateien wie tomcat-users.xml und mavens settings.xml im Nur-Text-Format ist nicht sicher und wird im Allgemeinen nicht empfohlen, insbesondere für Produktionsumgebungen. Andere Alternativen liegen jedoch außerhalb des Umfangs dieses Schulungsmoduls. Verwenden Sie nicht Ihren echten Benutzernamen und Ihr Kennwort!
Bearbeiten Sie die Tomcat-Konfigurationsdatei konf/tomcat-users.xml mithilfe des folgenden Beispiels:
<tomcat-users> <user username="your-tomcat-username" password="your-tomcat-password" roles="manager-script"/> </tomcat-users>Fügen Sie Ihre Anmeldeinformationen zur Datei "~/.m2/settings.xml" von Maven hinzu, indem Sie das folgende Beispiel verwenden und
your-tomcat-usernamedurch einen Benutzernamen undyour-tomcat-passworddurch ein Kennwort ersetzen:<servers> <server> <id>TomcatServer</id> <username>your-tomcat-username</username> <password>your-tomcat-password</password> </server> </servers>
Bereitstellen Ihrer Web-App in Tomcat
Verwenden Sie den folgenden Befehl, um Ihre Web-App zu packen und bereitzustellen:
mvn clean package cargo:deploy
Nach der Bereitstellung ist Ihre App unter http://localhost:8080/simple-tomcat-app verfügbar.