Ćwiczenie — tworzenie prostej aplikacji internetowej Java tomcat

10 min

Aplikacje internetowe są powszechnie używane do obsługi rzeczywistych zadań, takich jak zarządzanie spisem, formularze online i portale przeznaczone dla klientów. W tym module dowiesz się, jak utworzyć i wdrożyć aplikację internetową Java przy użyciu serwera Apache Tomcat, popularnego serwera open source.

Załóżmy, że jesteś deweloperem pracującym nad projektem, aby utworzyć dynamiczną aplikację internetową, w której użytkownicy mogą wprowadzać dane i korzystać z platformy w czasie rzeczywistym. Twój klient chce, aby ta aplikacja była dostępna lokalnie do testowania i w chmurze, co ułatwia dostęp. Ta konfiguracja umożliwia najpierw przetestowanie na komputerze lokalnym, a następnie wdrożenie w środowisku produkcyjnym jako płynne przejście. Utworzenie tej konfiguracji od podstaw zapewnia elastyczność przyszłych aktualizacji i konfiguracji.

W tym module zapoznasz się z podstawowymi krokami tworzenia i wdrażania aplikacji internetowej Java przy użyciu serwera Tomcat. Dostępne są dwie opcje: sklonowanie istniejącego repozytorium projektu na potrzeby natychmiastowego wdrożenia lub utworzenie nowego projektu od podstaw za pomocą narzędzia Maven. W tym module opisano konfigurowanie projektu Maven, konfigurowanie serwera Tomcat, wdrażanie aplikacji lokalnie oraz używanie narzędzi takich jak Maven do zarządzania zależnościami i pakietami.

Po ukończeniu tego modułu będziesz w stanie tworzyć i wdrażać aplikacje internetowe oparte na języku Java na serwerze Tomcat, przygotowując cię do obsługi wdrażania aplikacji internetowych zarówno lokalnie, jak i w środowiskach hostowanych w chmurze.

Tworzenie aplikacji internetowej Java Tomcat

W tym ćwiczeniu utworzysz minimalną aplikację internetową Java, która pobiera dane wejściowe i wyświetla wynik na ekranie. Następnie wdrożysz aplikację internetową lokalnie na komputerze przy użyciu serwera Tomcat. Dostępne są następujące dwie opcje:

Opcja 1. Sklonuj przykładowe repozytorium i natychmiast wdróż aplikację internetową.
Opcja 2. Tworzenie projektu Maven Tomcat od podstaw.

Opcja 1. Sklonuj przykładowe repozytorium i natychmiast wdróż aplikację internetową

Aby sklonować repozytorium, wykonaj następujące czynności:

Sklonuj przykładowe repozytorium projektu przy użyciu następującego polecenia:
```
git clone https://github.com/MicrosoftDocs/simple-tomcat-maven-app.git
```
Przejdź do sklonowanego repozytorium projektu przy użyciu następującego polecenia:
```
cd simple-tomcat-app
```

Wykonaj następujące kroki, aby skonfigurować lokalny serwer Tomcat, aby można było wdrożyć go lokalnie w usłudze Tomcat:

Ostrzeżenie

Przechowywanie nazw użytkowników i haseł bezpośrednio w plikach konfiguracji, takich jak tomcat-users.xml i settings.xml maven w postaci zwykłego tekstu, nie jest uważane za bezpieczne i ogólnie nie zalecamy tej praktyki — zwłaszcza w środowiskach produkcyjnych. Jednak inne alternatywy wykraczają poza zakres tego modułu szkoleniowego. Nie używaj prawdziwej nazwy użytkownika i hasła!

Zmodyfikuj plik konfiguracji serwera Tomcat /tomcat-users.xml tak, aby wyglądał jak w poniższym przykładzie:

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

Dodaj poświadczenia do pliku maven ~/.m2/settings.xml , korzystając z poniższego przykładu, gdzie zastąpisz your-tomcat-username nazwą użytkownika i your-tomcat-password hasłem:

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

Użyj następującego polecenia, aby spakować i wdrożyć aplikację internetową:
```
mvn clean package cargo:deploy
```

Po wdrożeniu możesz uzyskać dostęp do aplikacji pod adresem http://localhost:8080/simple-tomcat-app.

Opcja 2. Tworzenie projektu Maven Tomcat od podstaw

Aby utworzyć projekt Maven Tomcat od podstaw, należy wykonać wiele procedur, począwszy od tworzenia projektu Maven i kończąc na wdrażaniu aplikacji internetowej w usłudze Tomcat.

Tworzenie projektu Maven

Aby utworzyć projekt Maven dla aplikacji internetowej Java, użyj następującego polecenia:

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

Następujące dane wyjściowe są typowe:

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

Masz teraz nowy projekt internetowy maven w folderze o nazwie simple-tomcat-app. Teraz dostępne są następujące pliki i katalogi:

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

Modyfikowanie pliku pom.xml projektu Maven

Zmodyfikuj plik pom.xml , wykonując następujące czynności:

Otwórz pom.xml i ustaw wersję java na 21, korzystając z następującego przykładu:

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

Dodaj wtyczki wdrażania serwera Tomcat i platformy Azure, korzystając z następującego przykładu:

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

Oto pełna zawartość pliku 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>

Tworzenie interfejsu internetowego

Aby dodać stronę internetową, zmodyfikuj plik src/main/webapp/index.jsp , korzystając z następującego przykładu:

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

Tworzenie serwletu

Serwlet to klasa programowania Java służąca do rozszerzania możliwości serwera przez obsługę żądań i generowanie zawartości dynamicznej. Serwlety działają po stronie serwera w kontenerze internetowym — takim jak Apache Tomcat — i są używane głównie do przetwarzania żądań HTTP w aplikacjach internetowych. Gdy klient — na przykład przeglądarka internetowa — wysyła żądanie do serwera internetowego, serwlet przetwarza żądanie. Serwlet wykonuje dowolną niezbędną logikę biznesową — na przykład uzyskiwanie dostępu do baz danych lub wywoływanie innych usług — a następnie generuje odpowiedź — często w postaci kodu HTML — w celu wysłania z powrotem do klienta. Serwlety umożliwiają deweloperom tworzenie dynamicznych, niezależnych od platformy aplikacji internetowych przy użyciu języka Java.

Aby utworzyć serwlet, wykonaj następujące kroki:

Zaktualizuj strukturę plików, aby dodać serwlet przy użyciu następującego polecenia:
```
mkdir -p src/main/java/com/example && touch src/main/java/com/example/HelloServlet.java
```

Zaktualizuj zawartość pliku HelloSeverlet.java przy użyciu następującego przykładu kodu:

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

Nowa struktura plików wygląda następująco:

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

Wdrażanie lokalnie do Tomcata

Wykonaj następujące kroki, aby skonfigurować lokalny serwer Tomcat, aby można było go wdrożyć:

Ostrzeżenie

Przechowywanie nazw użytkowników i haseł bezpośrednio w plikach konfiguracji, takich jak tomcat-users.xml i settings.xml maven w postaci zwykłego tekstu, nie jest bezpieczne i nie jest ogólnie zalecane, zwłaszcza w środowiskach produkcyjnych. Jednak inne alternatywy wykraczają poza zakres tego modułu szkoleniowego. Nie używaj prawdziwej nazwy użytkownika i hasła!

Edytuj plik konfiguracji tomcat conf/tomcat-users.xml , korzystając z następującego przykładu:

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

Dodaj swoje poświadczenia do pliku ~/.m2/settings.xml narzędzia Maven, korzystając z poniższego przykładu i zastępując your-tomcat-username nazwą użytkownika, a your-tomcat-password hasłem:
```
<servers>
    <server>
        <id>TomcatServer</id>
        <username>your-tomcat-username</username>
        <password>your-tomcat-password</password>
    </server>
</servers>
```

Wdrażanie aplikacji internetowej na Tomcat

Użyj następującego polecenia, aby spakować i wdrożyć aplikację internetową:

mvn clean package cargo:deploy

Po wdrożeniu aplikacja jest dostępna pod adresem http://localhost:8080/simple-tomcat-app.

Sprzężenie zwrotne

Czy ta strona była pomocna?