[JAVA] Erstellen Sie ein Tomcat-Projekt mit Eclipse

Einführung

Wir haben zusammengefasst, wie ein Tomcat-Projekt (Java Servlet) mit Eclipse erstellt wird.

Überblick

Java Servlet ist ein Programm, das dynamische WEB-Seiten in in Java implementierten WEB-Anwendungen generiert. Die WEB-Anwendung ist ein Server / Client-System. Wie in der folgenden Abbildung dargestellt, sendet der Client eine Anforderung an den Server und der Server gibt eine Antwort an den Client zurück, um zu arbeiten.
Java Servlet funktioniert nicht alleine, sondern mit einer Software, die als Servlet-Container bezeichnet wird. Tomcat entspricht diesem Servlet-Container. Wenn Sie eine Anfrage von Ihrem Webbrowser an Ihren Webserver senden, erhält Tomcat diese Anfrage. Das Servlet generiert eine dynamische WEB-Seite entsprechend der Art der Anforderung, und Tomcat sendet diese dynamische WEB-Seite als Antwort an den WEB-Browser. Der WEB-Browser zeigt diese dynamische WEB-Seite an.

Entwicklungsumgebung

Windows 10（64bit）
OpenJDK 11
Eclipse IDE for Java Developers（Version: 2020-06）
Tomcat 9

Konstruktion der Entwicklungsumgebung ①: Installation von OpenJDK 11

JRE (Java Runtime Environment) ist erforderlich, um Java Servlet, Eclipse und Tomcat auszuführen. Installieren Sie daher OpenJDK. Wenn Sie JRE nicht installiert haben, wird beim Starten von Eclipse eine Fehlermeldung angezeigt. Sie müssen dies daher tun, bevor Sie Eclipse installieren.

Gehen Sie zur offiziellen OpenJDK-Website unten und klicken Sie im Download-Bereich auf den Link jdk.java.net / 14. (Der Link für "jdk.java.net / 14" ändert sich jedes Mal, wenn das OpenJDK aktualisiert wird.) https://openjdk.java.net/
Klicken Sie links in der Liste der Links auf Java SE 11. (Wenn Sie die neueste Version von OpenJDK herunterladen möchten, können Sie OpenJDK von dieser Site herunterladen.) https://jdk.java.net/14/
Klicken Sie auf Windows / x64 Java Development Kit. https://jdk.java.net/java-se-ri/11
"openjdk-11 + 28_windows-x64_bin.zip" wird heruntergeladen.
Wenn der Download abgeschlossen ist, entpacken Sie ihn in einen beliebigen Ordner und fügen Sie den Systemumgebungsvariablen den absoluten Pfad "jdk-11 \ bin" hinzu. (Hier habe ich es in C: \ openjdk entpackt und den Systemumgebungsvariablen "C: \ openjdk \ jdk-11 \ bin" hinzugefügt.)

Starten Sie die Eingabeaufforderung und überprüfen Sie die Java-Version. (Wenn es openjdk 11 ist, ist es OK.)

>java --version
openjdk 11 2018-09-25
OpenJDK Runtime Environment 18.9 (build 11+28)
OpenJDK 64-Bit Server VM 18.9 (build 11+28, mixed mode)

Konstruktion der Entwicklungsumgebung (2): Eclipse-Installation

Laden Sie nach Abschluss der OpneJDK-Installation Eclipse herunter, starten Sie es und installieren Sie Tomcaat Plagin.

Gehen Sie zur Download-Site des Eclipse-Paketinstallationsprogramms und klicken Sie in der "Eclipse-IDE für Java-Entwickler" auf "Windows 64-Bit". https://www.eclipse.org/downloads/packages/
Wenn Sie sich auf der Download-Seite befinden, klicken Sie auf die Schaltfläche Herunterladen.
eclipse-java-2020-06-R-win32-x86_64.zip wird heruntergeladen.
Nachdem der Download abgeschlossen ist, entpacken Sie ihn in einen beliebigen Ordner und doppelklicken Sie auf "eclipse.exe", um Eclipse zu starten. (Sie müssen beim Start den Pfad des Arbeitsbereichsordners eingeben, aber die Standardeinstellungen beibehalten.)
Führen Sie das Eclipse-Hauptmenü "Hilfe"> "Eclipse-Marktplatz" aus, um das Dialogfeld "Eclipse-Marktplatz" zu öffnen.
Geben Sie im Suchfeld "Tomcat" ein und klicken Sie auf "Go".
Wählen Sie "Eclipse Tomcat Plugin 9.1.4" und klicken Sie auf "Installieren".
Wählen Sie "Ich akzeptiere die Bedingungen der Lizenzvereinbarung" und klicken Sie auf "Fertig stellen".
Nach dem Neustart von Eclipse werden im Menü das Tomcat-Symbol sowie das Eclipse-Hauptmenüsymbol angezeigt.

Bau der Entwicklungsumgebung ③: TOMCAT-Installation

Installieren Sie TOMCAT.

Rufen Sie die folgende Site auf und klicken Sie links im Element "Download" auf "Tomcat 9". http://tomcat.apache.org/download-80.cgi
Klicken Sie unter "Binärverteilungen" unter "Kern" auf "zip". https://tomcat.apache.org/download-90.cgi
"apache-tomcat-9.0.37.zip" wird heruntergeladen.
Wenn der Download abgeschlossen ist, entpacken Sie ihn in einen beliebigen Ordner. Entpacken Sie es hier in den folgenden Ordner. C:\apache\apache-tomcat-9.0.37
Fügen Sie die folgenden Systemumgebungsvariablen hinzu.

-CATALINA_HOME: Pfad des TOMCAT-Installationsordners ([Beispiel] C: \ apache \ apache-tomcat-9.0.37) -JAVA_HOME: Pfad des Java-Installationsordners ([Beispiel] C: \ openjdk \ jdk-11) ~~~

Eclipse-Grundeinstellungen

Initialisieren Sie Eclipse, bevor Sie ein Projekt erstellen. Wenn Sie es zu Beginn einmal einstellen, müssen Sie es beim nächsten Mal nicht mehr einstellen.

Führen Sie das Hauptmenü "Fenster"> "Einstellungen" aus, um das Dialogfeld "Einstellungen" zu öffnen.
Wählen Sie links in der Baumstruktur Allgemein> Darstellung> Farben und Schriftarten.
Wählen Sie "Java Editor Text-Font" und klicken Sie auf "Edit", um das Dialogfeld "Font" zu öffnen.
Um verstümmelte Zeichen in Eclipse zu vermeiden (wenn Sie unmittelbar nach dem Kommentar "//" Japanisch schreiben, werden die Zeichen verstümmelt), ändern Sie die Schriftart in MS Gothic und klicken Sie auf die Schaltfläche "Übernehmen".
Wählen Sie links in der Baumstruktur Allgemein> Arbeitsbereich.
Aktivieren Sie "Andere" in "Textdatei-Codierung" und wählen Sie "UTF-8". (Angenommen, die zu implementierende Umgebung ist Linux, setzen Sie sie auf UTF-8, damit sie unter Linux ausgeführt werden kann.)
Aktivieren Sie "Andere" unter "Zeilenbegrenzer für neue Textdateien", wählen Sie "Unix" und klicken Sie auf die Schaltfläche "Übernehmen".
Wählen Sie links in der Baumstruktur "Tomcat" aus und aktivieren Sie "9" für "Tomcat-Version".
Legen Sie den Tomcat-Ordner in "Tomcat Home" fest. ([Beispiel] C: \ apache \ apache-tomcat-9.0.37)
Überprüfen Sie "Server.xml" im "Kontextdeklarationsmodus" und legen Sie den Pfad von Server.xml im Feld "Einstellungsdatei" fest.
Klicken Sie auf die Schaltfläche Übernehmen.
Klicken Sie auf die Schaltfläche Übernehmen und schließen.

Projekterstellung

Beim Erstellen eines neuen Projekts und Festlegen von Server.xml.

Führen Sie das Hauptmenü "Datei"> "Neu"> "Projekt" aus, um den Dialog "Neues Projekt" zu starten.
Klicken Sie in der Baumstruktur auf den Knoten Java> Tomcat Projects.
Geben Sie den "Projektnamen" ein und klicken Sie auf "Weiter".
Überprüfen Sie den Pfad im Feld "Kontextname" und klicken Sie auf "Fertig stellen". (Der Pfad im Feld "Kontextname" ist der Stammteil des URL-Pfads beim Zugriff auf den WEB-Server.) http: // localhost: 8080 / {Pfad im Feld" Kontextname "}
Stellen Sie sicher, dass die folgende Zeile zu "conf \ server.xml" im Tomcat-Installationsordner hinzugefügt wird. Wenn diese Zeile nicht in Server.xml registriert ist, wird der WEB-Bildschirm auch dann nicht angezeigt, wenn Sie auf den WEB-Server zugreifen. ([Beispiel] C: \ apache \ apache-tomcat-9.0.37 \ conf \ server.xml)

~~~

Standardmäßig wird Port 8080 verwendet. Wenn Sie einen anderen als Port 8080 einstellen möchten, ändern Sie den folgenden Teil.

<Connector port = "8080" protocol = "HTTP / 1.1" ★ Ändern Sie "8080" in die Portnummer, die Sie festlegen möchten connectionTimeout="20000" redirectPort="8443" useBodyEncodingForURI="true" /> ~~~

Servlet-Erstellung

Implementiert die Verarbeitung des Servlets.

Wählen Sie im Paket-Explorer den obersten Knoten in der Baumstruktur aus, klicken Sie mit der rechten Maustaste und klicken Sie im Popup-Menü auf Neu> Klasse.
Geben Sie den Klassennamen in das Feld "Nmae" und "javax.servlet.http.HttpServlet" in das Feld "Super class" ein und klicken Sie auf "Finish". (Geben Sie hier "SampleServlet" in das Feld "Nmae" ein und belassen Sie die Standardeinstellungen für die Einstellungen außer den Feldern "Nmae" und "Super class".)
Der Knoten "sample"> "WEB-INF / src"> "sample"> "SampleServlet.java" wird dem Baum im "Package Explorer" hinzugefügt.
```
package sample;

import javax.servlet.http.HttpServlet;

public class SampleServlet extends HttpServlet {

}
```
Wählen Sie im "Package Explorer" den Baumknoten "SampleServlet.java" aus und klicken Sie im Hauptmenü auf "Source"> "Override / Inplement Methods", um das Dialogfeld "Override / Inplement Methods" zu öffnen.

Aktivieren Sie "HttpServlet", "doGet" und "doPost" und klicken Sie auf die Schaltfläche "OK", um die doGet-Methode und die doPost-Methode zu generieren. Die doGet-Methode wird ausgeführt, wenn die Anforderung vom Client gesendet wird, z. B. wenn auf die URL zugegriffen wird. Die doPost-Methode wird auch ausgeführt, wenn eine Anforderung vom WEB-Server gesendet wird, z. B. wenn ein Formular auf dem WEB-Bildschirm ausgeführt wird.

package sample;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class SampleServlet extends HttpServlet {

	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		super.doGet(req, resp);
	}

	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		super.doPost(req, resp);
	}

}

Fügen Sie SampleServlet.java den folgenden Importvorgang hinzu.
```
package sample;

import java.io.IOException;
```

import java.io.PrintWriter; // Hinzufügen

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@SuppressWarnings ("serial") // Hinzugefügt public class SampleServlet extends HttpServlet { ~~~

Fügen Sie die folgenden Felder in die SampleServlet-Klasse von SampleServlet.java ein.
```
public class SampleServlet extends HttpServlet {
```

// ↓ Von hier aus hinzufügen static final String head = "sample"; static final String msg = "

Schreiben Sie den Text hier. </ Div>"; static final String form = "";

	static String result = "";

// ↑ Addiere hier ~~~

Ändern Sie doGet () in SampleServlet.java in die folgende Implementierung. Wenn über den WEB-Browser auf den WEB-Server zugegriffen wird, wird die HTML-Datei der WEB-Seite gelesen und im Antworttext festgelegt, sodass sie antwortet.
```
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
	// TODO Auto-generated method stub
```

//super.doGet (req, resp); // Auskommentieren

// ↓ Von hier aus hinzufügen // Zeichenkodierung durchführen, um verstümmelte japanische Zeichen zu vermeiden resp.setContentType("text/html; charset=UTF-8");

// Erstellen Sie einen WEB-Bildschirm, der im WEB-Browser des Clients angezeigt wird PrintWriter out = resp.getWriter(); out.println(""); out.println(head); out.println(""); out.println(msg); out.println(form); out.println(""); out.println(""); out.close(); // ↑ Addiere hier } ~~~

Ändern Sie doPost () in SampleServlet.java in die folgende Implementierung. Wenn Daten aus der Form des WEB-Browsers an den WEB-Server gesendet werden, wird der Anforderungsparameter (vom Client gesendete Daten) erfasst und im Antworttext als Antwort festgelegt.
```
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
	// TODO Auto-generated method stub
```

//super.doPost (req, resp); // Auskommentieren

// ↓ Von hier aus hinzufügen req.setCharacterEncoding ("UTF-8"); // Zeichenkodierung (Maßnahmen gegen verstümmelte japanische Zeichen) resp.setContentType ("text / html; charset = UTF-8"); // Zeichenkodierung (Maßnahmen gegen verstümmelte japanische Zeichen)

	try{

// Den geschriebenen Text abrufen, wenn die Schaltfläche "Schreiben" gedrückt wird if(req.getParameter("send").equalsIgnoreCase("write")){ result += "

" + req.getParameter("name") + "
"; } }catch(Exception e){ e.printStackTrace(); result = "Schreibfehler
" + e.getMessage (); }

// Erstellen Sie einen WEB-Bildschirm, der im WEB-Browser des Clients angezeigt wird PrintWriter out = resp.getWriter(); out.println(""); out.println(head); out.println(""); out.println(msg); out.println(form); out.println(result); out.println(""); out.println(""); out.close(); // ↑ Addiere hier } ~~~

web.xml Erstellung

Erstellen Sie die Datei web.xml. web.xml ist eine Datei, die den Servlet-Container konfiguriert.

Wählen Sie im "Paket-Explorer" den Baumknoten "WEB-INF" aus, klicken Sie mit der rechten Maustaste und klicken Sie auf das Einblendmenü "Neu"> "Andere", um das Dialogfeld "Neu" zu öffnen.
Klicken Sie auf XML> XML-Datei, um das Dialogfeld Neue XML-Datei zu öffnen.
Geben Sie "web.xml" in das Feld "Dateiname" ein und klicken Sie auf "Fertig stellen", um den Baumknoten "web.xml" im "Paket-Explorer" hinzuzufügen.
Wählen Sie im "Paket-Explorer" den Baumknoten "web.xml" aus, klicken Sie mit der rechten Maustaste und klicken Sie auf das Einblendmenü "Öffnen mit"> "Generischer Texteditor".
```
<?xml version="1.0" encoding="UTF-8"?>
```
Fügen Sie web.xml den folgenden Code hinzu.
```
<?xml version="1.0" encoding="UTF-8"?>
```

<! - ↓ Von hier hinzufügen-> sample sample.SampleServlet

	<servlet-mapping>
		<servlet-name>sample</servlet-name>					<!-- Servlet name -->
		<url-pattern>/servlet</url-pattern>					<!-- URL pattern -->
	</servlet-mapping>
</web-app>

<! - ↑ Addiere bis hier-> ~~~

Bauen

Aktivieren Sie für Builds automatische Builds, damit diese automatisch erstellt werden.

Wählen Sie den oberen Knoten des Baums im "Paket-Explorer" aus, klicken Sie mit der rechten Maustaste und klicken Sie auf das Popup-Menü "Reflesh", um die Dateistruktur des Baums im "Paket-Explorer" automatisch auf den aktuellen Status zu aktualisieren. ..
Aktivieren Sie im Hauptmenü Projekt> Automatisch erstellen, um automatische Builds zu aktivieren. (Wenn der Build nicht ausgeführt wird, klicken Sie im Hauptmenü auf "Projekt"> "Bereinigen".)

Lauf

Führen Sie es aus, wenn Sie es erstellen können. Verwenden Sie zunächst Eclipse, um einen WEB-Server unter Windows zu starten und über einen WEB-Browser darauf zuzugreifen.

Klicken Sie im Hauptmenü auf das Symbol "Tomcat neu starten".
Wenn Sie den WEB-Browser starten und auf die folgende URL zugreifen, wird die GET-Methode vom Client an den Server gesendet und die folgende WEB-Seite wird angezeigt. http://localhost:8080/sample/servlet
Geben Sie den Text ein und klicken Sie auf "Schreiben". Die POST-Methode wird vom Client an den Server gesendet und die folgende WEB-Seite wird angezeigt.

Projekt exportieren

Erstellen Sie eine Sicherungskopie Ihres Projekts, bevor Sie es löschen.

Stoppen Sie Tomcat.
Wählen Sie im "Paket-Explorer" den obersten Knoten der Baumstruktur aus, klicken Sie mit der rechten Maustaste und klicken Sie auf das Einblendmenü "Exportieren", um das Dialogfeld "Exportieren" zu öffnen.
Wählen Sie Allgemein> Dateisystem und klicken Sie auf Weiter.
Aktivieren Sie das Kontrollkästchen des Projekts.
Geben Sie den Exportzielpfad in das Feld "In Verzeichnis" ein und klicken Sie auf "Fertig stellen".

Projekt importieren

Wenn Sie das Projekt neu starten möchten, importieren Sie das gesicherte Projekt.

Erstellen Sie ein Projekt gemäß dem Element "Projekt erstellen".
Wählen Sie im "Paket-Explorer" den obersten Knoten der Baumstruktur aus, klicken Sie mit der rechten Maustaste und klicken Sie auf das Einblendmenü "Importieren", um das Dialogfeld "Importieren" zu öffnen.
Wählen Sie Allgemein> Dateisystem und klicken Sie auf Weiter.
Aktivieren Sie das Kontrollkästchen des Projekts.
Geben Sie den Importzielpfad in das Feld "In Ordner" ein und klicken Sie auf "Fertig stellen".
Wenn Sie gefragt werden, ob der Klassenpfad im Ordner {Projektname} überschrieben werden soll, wählen Sie "Nicht an alle".

Erstellung einer WAR-Datei

Erstellen Sie eine WAR-Datei (eine Sammlung von Dateien, die für den Betrieb der WEB-Anwendung erforderlich sind), um sie bereitzustellen (verfügbar zu machen).

Klicken Sie im Hauptmenü auf Projekt> Eigenschaften, um das Dialogfeld Eigenschaften zu öffnen.
Wählen Sie den Baumknoten "Tomcat" aus, öffnen Sie die Registerkarte "WAR-Exporteinstellungen" und klicken Sie auf die Schaltfläche "Durchsuchen", um das Dialogfeld "Öffnen" zu öffnen.
Geben Sie den zu speichernden WAR-Dateinamen in das Feld "Dateiname" ein und klicken Sie auf die Schaltfläche "Öffnen".
Wenn der Pfad der zu speichernden WAR-Datei im Feld "WAR-Datei exportieren" angezeigt wird, klicken Sie auf die Schaltfläche "Übernehmen und schließen".
Wählen Sie im "Paket-Explorer" den obersten Knoten der Baumstruktur aus, klicken Sie mit der rechten Maustaste und führen Sie "Tomcat-Projekt"> "WAR-Datei gemäß Projekteinstellungen erstellen" aus.
Eine WAR-Datei wird in dem Pfad generiert, der im Feld "Zu exportierende WAR-Datei" festgelegt ist.

Bereitstellungsumgebung

Bereiten Sie sich von hier aus auf die Bereitstellung vor. Hier werden wir auf Ubuntu bereitstellen.

Ubuntu 20.04 LTS
OpenJDK 11
Tomcat 9

Aufbau der Bereitstellungsumgebung ①: OpenJDK 11-Installation

Installieren Sie zunächst Java.

Installieren Sie OpenJDK 11.
```
$ sudo apt-get install openjdk-11-jdk
```
Überprüfen Sie die installierte Java-Version.

$ java --version openjdk 11.0.8 2020-07-14 OpenJDK Runtime Environment (build 11.0.8+10-post-Ubuntu-0ubuntu120.04) OpenJDK 64-Bit Server VM (build 11.0.8+10-post-Ubuntu-0ubuntu120.04, mixed mode, sharing) ~~~

Aufbau der Bereitstellungsumgebung (2): TOMCAT-Installation

Installieren Sie dann TOMCAT.

Rufen Sie die folgende Site auf und klicken Sie links im Element "Download" auf "Tomcat 9". http://tomcat.apache.org/download-80.cgi
Klicken Sie unter "Core" unter "Binary Distributions" auf "tar.gz". ⇒ "apache-tomcat-9.0.37.zip" wird heruntergeladen. https://tomcat.apache.org/download-90.cgi
Wenn der Download abgeschlossen ist, entpacken Sie ihn in ein beliebiges Verzeichnis. Hier entpacken Sie nach / opt.
```
$ sudo tar zxvf apache-tomcat-9.0.37.tar.gz -C /opt
```

Stellen Sie sicher, dass es nach / opt entpackt ist.

$ ls /opt/apache-tomcat-9.0.37/
BUILDING.txt  CONTRIBUTING.md  LICENSE  NOTICE  README.md  RELEASE-NOTES  RUNNING.txt  bin  conf  lib  logs  temp  webapps  work

Bereitstellen

Wenn die Bereitstellungsumgebung bereit ist, stellen Sie sie bereit.

Die Standardeinstellung von Tomcat ist Root-Benutzer, da kein anderer Benutzer als Root-Benutzer über die Ausführungsberechtigung verfügt.
```
$ sudo su
```
Kopieren Sie die erstellte WAR-Datei in einen Ordner unter den Webanwendungen von TOMCAT.
```
# mv sample.war /opt/apache-tomcat-9.0.37/webapps
```

Starten Sie TOMCAT.

# cd /opt/apache-tomcat-9.0.37/bin
# sh startup.sh

Wenn Sie den WEB-Browser starten und auf die folgende URL zugreifen, wird die GET-Methode vom Client an den Server gesendet und die folgende WEB-Seite angezeigt. http: // {IP-Adresse des bereitgestellten PCs}: 8080 / sample / servlet
Geben Sie den Text ein und klicken Sie auf die Schaltfläche "Schreiben". Die POST-Methode wird vom Client an den Server gesendet und die folgende WEB-Seite wird angezeigt.
Beenden Sie TOMCAT.
```
# sh shutdown.sh
```