Ihre erste Anwendung mit Java-Servlets

Hallo zusammen! In diesem Artikel machen Sie sich mit dem grundlegenden Webentwicklungskonzept von Servlets vertraut und können damit eine einfache Anwendung schreiben. Um unnötige Schritte zu vermeiden, werden wir nicht bei Null anfangen, sondern weiter an unserer Anwendung aus meinem vorherigen Artikel über Hibernate arbeiten . Da wir jedoch gerade erst mit Servlets beginnen, habe ich alles, was mit der Auto-Klasse zu tun hat, aus der Anwendung entfernt und nur die User-Klasse und ihre Aktionen übrig gelassen. Die Projektstruktur sieht folgendermaßen aus: Also, Servlets! Wikipedia sagt: „Ein Servlet ist eine Java-Schnittstelle, deren Implementierung die Funktionalität des Servers erweitert. Ein Servlet interagiert mit Clients über ein Anfrage-Antwort-Prinzip.“ Und das ist es tatsächlich. Hier stoßen wir zunächst auf das Konzept der „Client-Server-Anwendungsarchitektur“. Sein Wesen ist recht einfach und passt in ein Bild ( von hier ). Der Client kontaktiert den Server, indem er eine HTTP-Anfrage sendet. Der Server generiert die notwendigen Daten (erhält sie beispielsweise aus der Datenbank) und gibt sie an den Client zurück. Das einfachste Beispiel: In einem bestimmten sozialen Netzwerk klickt man auf den „Freunde“-Button und sendet damit eine Anfrage an den Server. Der Server prüft die Liste Ihrer Freunde in der Datenbank und sendet sie an Sie (den Client) zurück. Die Liste der HTTP-Anfragen ist ziemlich umfangreich, aber wenn Sie noch nie auf sie gestoßen sind, ist es zum besseren Verständnis besser, sie beispielsweise hier zu lesen . Unsere Aufgabe besteht darin: Eine CRUD-Anwendung mithilfe von Servlets zu erstellen. Die Anwendung muss in der Lage sein, mithilfe eines Servlets, das HTTP-Anfragen verarbeitet, Benutzer in der Datenbank zu erstellen, zu ändern und zu löschen. Unsere Anwendung aus dem Artikel über Hibernate wusste bereits, wie das geht, wurde aber direkt vom Java-Code gesteuert, genauer gesagt von der main()-Methode. Hier werden die Anfragen vom Client, also von Ihnen, gesendet :) Als Erstes müssen wir unserer pom.xml-Datei neue Abhängigkeiten hinzufügen

<xml version="1.0" encoding="UTF-8"?>
<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.itis4</groupId>
    <artifactId>UsersDaoProject</artifactId>
    <version>1.0-SNAPSHOT</version>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.6</version>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <!-- PostgreSQL  -->
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>9.4.1212.jre7</version>
        </dependency>

        <!-- Hibernate 5.2.6 Final -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.2.6.Final</version>
        </dependency>

        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.4.RELEASE</version>
        </dependency>

    </dependencies>

</project>

Wir haben 3 Abhängigkeiten hinzugefügt:

1. Die javax.servlet-api-Bibliothek selbst;
2. JSTL-Tag-Bibliothek. Es wird benötigt, um die Clientseite zu erstellen, nämlich JSP-Seiten;
3. Spring-WebMVC. Wir benötigen einen Frühlingskurs, über den wir etwas später sprechen werden.

Der Betrieb von Servlets wird vom Servlet-Container verwaltet. In unserem Fall verwenden wir Apache Tomcat. Eine ziemlich beliebte Sache, und Sie haben wahrscheinlich schon davon gehört :) Der Lebenszyklus eines Servlets besteht aus den folgenden Schritten:

1. Wenn sich kein Servlet im Container befindet.
   
   • Die Servlet-Klasse wird vom Container geladen.
   • Der Container erstellt eine Instanz der Servlet-Klasse.
   • Der Container ruft die Methode init() auf. Diese Methode initialisiert das Servlet und wird zuerst aufgerufen, bevor das Servlet Anfragen bearbeiten kann. Die init()-Methode wird während ihres gesamten Lebenszyklus nur einmal aufgerufen.
2. Bearbeitung einer Kundenanfrage. Jede Anfrage wird in einem eigenen Thread verarbeitet. Der Container ruft für jede Anfrage die Methode service() auf. Diese Methode ermittelt den Typ der eingehenden Anfrage und verteilt ihn an die diesem Typ entsprechende Methode zur Bearbeitung der Anfrage. Der Servlet-Entwickler muss Implementierungen für diese Methoden bereitstellen. Geht eine Anfrage ein, für die eine Methode nicht implementiert ist, wird die Methode der übergeordneten Klasse aufgerufen und endet in der Regel mit einer Fehlermeldung an den Anforderer.
3. Falls der Container ein Servlet löschen muss, ruft er die Methode destroy() auf, die das Servlet aus dem Dienst entfernt. Wie die init()-Methode wird auch diese Methode einmal während des gesamten Servlet-Zyklus aufgerufen.

Unser Servlet wird ganz einfach aussehen:

package servlets;

import models.User;
import services.UserService;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

public class UserSimpleServlet extends HttpServlet {

    private UserService service = new UserService();

    public void init(ServletConfig servletConfig) {
        try {
            super.init(servletConfig);
        } catch (ServletException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        List<User> users = service.findAllUsers();
        req.setAttribute("users", users);
        RequestDispatcher dispatcher = req.getRequestDispatcher("/showUsers.jsp");
        dispatcher.forward(req, resp);

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {

        String name = req.getParameter("name");
        int age = Integer.parseInt(req.getParameter("age"));
        User user = new User(name, age);
        service.saveUser(user);
        resp.sendRedirect("/users");

    }

    @Override
    protected void  doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        int id = Integer.parseInt(req.getParameter("id"));
        User user = service.findUser(id);
        user.setName(req.getParameter("name"));
        user.setAge(Integer.parseInt(req.getParameter("age")));
        service.updateUser(user);
        resp.sendRedirect("/users");
    }

    @Override
    protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        int id = Integer.parseInt(req.getParameter("id"));
        service.deleteUser(service.findUser(id));
        resp.sendRedirect("/users");
    }
}

Wie Sie sehen können, enthält es die oben beschriebene init()-Methode und implementiert vier Methoden, die mit vier HTTP-Anfragen übereinstimmen – doGet(), doPost(), doPut() und doDelete(). Jeder von ihnen ermöglicht es uns, Benutzer zu empfangen, zu erstellen, zu bearbeiten und zu löschen. Die Methoden verwenden als Eingabeobjekte die Klassen javax.servlet.http.HttpServletRequest und javax.servlet.http.HttpServletResponse – also die an den Server gesendete Anfrage und die Antwort, die der Client erhält. Innerhalb der Methoden werden die notwendigen Methoden der UserService-Klasse ausgeführt, eine Antwort für den Client generiert und dann an die Adresse /users umgeleitet. Beispielsweise erhalten wir in der doGet()-Methode eine Liste aller Benutzer. Als Nächstes erstellen wir ein Objekt der RequestDispatcher-Klasse, das es uns ermöglicht, Objekte in eine HTTP-Anfrage einzuschließen und sie an eine bestimmte Ressource (z. B. eine Client-JSP-Seite) umzuleiten. In der doPut()-Methode (Aktualisierung der Benutzerdaten) verarbeiten wir die HTTP-Anfrage, extrahieren daraus die Parameter ID, Name und Alter, finden den Benutzer mit der angegebenen ID und weisen ihm den Namen und das Alter zu, die mit ihm geliefert wurden Anfrage und kehren Sie zur Seite /users zurück. Damit alle diese Methoden jedoch ordnungsgemäß funktionieren, müssen wir das Servlet konfigurieren. Hierzu verwenden wir die Datei web.xml im WEB-INF-Ordner.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.1"
         xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

    <servlet>
        <servlet-name>UserSimpleServlet</servlet-name>
        <servlet-class>servlets.UserSimpleServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>UserSimpleServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>hiddenHttpMethodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>hiddenHttpMethodFilter</filter-name>
        <servlet-name>UserSimpleServlet</servlet-name>
    </filter-mapping>

</web-app>

Alle Tags in dieser Datei sind im Prinzip intuitiv, aber gehen wir sie der Reihe nach durch. <welcome-file-list> – die JSP-Startseite wird angegeben, die beim Start der Anwendung zuerst geöffnet wird. In unserem Fall ist dies die Seite index.jsp. <servlet> – Registrieren unserer UserSimpleServlet-Klasse als Servlet. <servlet-mapping> ist ein sehr wichtiges Tag. Es definiert die URLs, die vom Servlet verarbeitet werden. In unserem Fall sind das alles URLs, daher geben wir einfach „/“ an. Wenn wir jedoch beispielsweise eine Anwendung mit Benutzern und ihren Computern hätten, könnten wir ein zweites Servlet erstellen – SimpleAutoServlet. Dann wäre die Zuordnung für das Benutzer-Servlet „/users“ (d. h. Anfragen im Zusammenhang mit der Verarbeitung von Benutzern) und für das Auto-Servlet wäre sie „/autos“. Und schließlich <filter>. Es definiert intern ein Objekt der Klasse org.springframework.web.filter.HiddenHttpMethodFilter. Der Artikel betrifft nicht den Frühling, daher werde ich nicht im Detail darauf eingehen. Lassen Sie mich nur sagen, dass es unserer Anwendung nur als zusätzliches Feature beigefügt ist. Der Punkt ist, dass wir JSP-Seiten verwenden werden, um die Clientseite zu erstellen. Unsere Daten werden auf der Seite als Tabelle mit einer Benutzerliste angezeigt. Innerhalb von JSP-Seiten werden HTML-<form/>-Tags verwendet. Und nur HTTP-GET- und POST-Anfragen können zum Senden von Daten von <form/> verwendet werden. Das heißt, für alle drei Vorgänge – Aktualisieren, Löschen und Erstellen eines Benutzers – müssten wir nur POST-Anfragen verwenden. Die Verwendung von PUT- und DELETE-Anfragen wäre für uns nicht möglich. Und im Prinzip ist das ganz normal und einfach zu implementieren, aber die HiddenHttpMethodFilter-Klasse ermöglicht uns ihre Verwendung. Dadurch werden dem Leser die Unterschiede zwischen den Vorgängen in der Anwendung klarer. Kommen wir abschließend zur Clientseite. Es wird durch fünf JSP-Seiten dargestellt. index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Здравствуйте!</title>
</head>
<body>
Если вы хотите начать работу с базой данных пользователей - <br>
нажмите кнопку ниже:

<form action = "users" method="get">
    <input type="submit" value="Начать работу с базой данных">
</form>
</body>
</html>

addUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Добавить нового пользователя</title>
</head>
<body>
<form action = "/users" method="post">
    <input required type="text" name="name" placeholder="Name">
    <input required type="text" name="age" placeholder="Возраст">
    <input type="submit" value="Сохранить">
</form>
</body>
</html>

deleteUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Удалить пользователя</title>
</head>
<body>

Вы действительно хотите удалить пользователя ${param.id}?

&lform action="/users/${param.id}" method="post">
    <input type="hidden" name="id" value="${param.id}">
    <input type="hidden" name="_method" value="delete">
    <input type="submit" value="Удалить">
</form>

</body>
</html>

showUsers.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Список пользователей</title>
</head>
<body>
<table border="2">
    <tr>
        <td>ID</td>
        <td>Name</td>
        <td>Возраст</td>
        <td>Действия</td>
    </tr>
    <c:forEach items="${users}" var = "user">
        <tr>
            <td>${user.getId()}</td>
            <td>${user.getName()}</td>
            <td>${user.getAge()}</td>
            <td>
                <form action = "updateUser.jsp" method="post">
                    <input type="hidden" name="id" value="${user.getId()}">
                    <input type="hidden" name="name" value="${user.getName()}">
                    <input type="hidden" name="age" value="${user.getAge()}">
                    <input type="submit" value="Изменить" style="float:left">
                </form>
                <form action="deleteUser.jsp" method="post">
                    <input type="hidden" name="id" value="${user.getId()}">
                    <input type="submit" value="Удалить" style="float:left">
                </form></td>
        </tr>
    </c:forEach>
</table>

<form action = "addUser.jsp">
    <input type="submit" value="Добавить нового пользователя">
</form>
</body>
</html>

updateUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Изменить данные пользователя</title>
</head>
<body>

Редактировать пользователя

<form action="/users/${param.id}" method="post">
    <input type="hidden" name = "id" value="${param.id}">
    <input type="text" name="name" value="${param.name}" placeholder=${param.name}>
    <input type="text" name="age" value="${param.age}" placeholder=${param.age}>
    <input type="hidden" name="_method" value="put">
    <input type="submit" value="Обновить">
</form>

</body>
</html>

Eine JSP-Seite (Java Server Page) enthält zwei Arten von Text: statische Quelldaten, die in einem der Textformate (HTML, SVG, WML oder XML) vorliegen können, und JSP-Elemente, die dynamische Inhalte erstellen. Um zu verstehen, was JSP ist, erlaube ich mir, einen Teil eines sehr guten Artikels eines Autors ( von hier ) zu kopieren und einzufügen. „Im Wesentlichen wird JSP beim ersten Zugriff in ein Servlet umgewandelt und funktioniert als Servlet. Das ist sehr wichtig zu verstehen. JSP IST KEINE Seite wie eine HTML-Seite – es ist wichtig, dass ein unerfahrener Programmierer dies klar versteht.“ ist ein weiteres Servlet – Sie müssen seine Ausgabe einfach nicht programmieren. Sie können es einfach zeichnen. Und die Daten an den richtigen Stellen ersetzen. Aber da die JSP-Seite zumindest irgendwie HTML ähnelt, wird es für den Designer offensichtlich einfacher sein. Und ich sage Anfängern noch einmal DRINGEND: JSP ist ein SERVLET . Es wird mit allen Daten auf dem Server vorbereitet. Hier werden alle Daten eingefügt. Und der Benutzer erhält eine vorgefertigte HTML-Seite im Browser, was nicht der Fall ist Anzeichen von JAVA aufweisen. Sie können selbst sehen, dass es sich bei der JSP-Seite tatsächlich um ein Servlet handelt, da jede Seite eine Methode enthält, die ausgeführt werden muss. Beispielsweise steht auf der Startseite index.jsp, dass beim Klicken auf die Schaltfläche „Arbeiten mit der Datenbank beginnen“ die Methode „get“ ausgeführt wird. Wenn Sie auf der Seite addUser.jsp, die für die Erstellung eines neuen Benutzers verantwortlich ist, auf die Schaltfläche „Speichern“ klicken, wird method="post" ausgeführt. Der Rest der JSP besteht aus gewöhnlichem statischem HTML-Markup, daher werden wir nicht näher darauf eingehen – dies ist das Thema eines separaten Artikels, von dem es viele im Internet gibt. Wir haben also unsere Anwendung erstellt und müssen sie nur noch in Aktion testen! Dazu benötigen wir den oben erwähnten Apache Tomcat Servlet-Container. Sie können die Katze von der offiziellen Website herunterladen (ich verwende Version 8). Als nächstes müssen wir in IDEA eine Konfiguration erstellen, um unsere Anwendung über Tomcat auszuführen. Öffnen Sie dazu den Reiter „Konfigurationen bearbeiten“, erstellen Sie eine neue Konfiguration und wählen Sie Tomcat Server Local aus. Geben Sie auf der Registerkarte „Anwendungsserver“ den Pfad zu dem Ordner an, in dem sich Tomcat befindet. Wechseln Sie anschließend zur Registerkarte „Bereitstellung“. Hier konfigurieren wir die Bereitstellung unserer Anwendung auf einem lokalen Server. Klicken Sie auf „+“, wählen Sie „Artefakt“ -> Ihr Projektname: war (wir werden die Anwendung in einer WAR-Datei zusammenstellen). Das ist es im Grunde! Auf der Seite „Server“ können Sie sehen, dass dieselbe Anwendung unter „http://localhost:8080/“ ausgeführt wird. Speichern Sie diese Konfiguration und benennen Sie sie (mein Konfigurationsname ist „Tommy“). Als nächstes werden wir auf der Registerkarte „Maven“ in IDEA (auf der rechten Seite) das War-Plugin verwenden, um unser Projekt in eine War-Datei zu erstellen (Plugins -> Krieg -> Krieg: Krieg). Erfolg! Die Startseite wurde gestartet. Klicken Sie nun auf die Schaltfläche „Arbeiten mit der Datenbank beginnen“. Unsere JSP-Seite index.jsp generiert eine GET-Anfrage, die vom Server verarbeitet wird. Der Server generiert eine Antwort und sendet sie in Form einer Liste aller vorhandenen Benutzer an uns zurück (sofern diese natürlich in der Datenbank vorhanden sind). Und hier sind sie! Versuchen wir, einen der Benutzer zu löschen: Es funktioniert auch! Also haben wir unsere erste Anwendung mit Servlets geschrieben. Wie Sie sehen, war alles gar nicht so schwierig :) Als Hausaufgabe können Sie beispielsweise die Funktionalität der Arbeit mit Autos aus dem vorherigen Artikel in die Anwendung zurückgeben. Diese. Erstellen Sie separate Servlet- und JSP-Seiten für Autos und bringen Sie unserer Anwendung bei, eine Liste der Autos des Benutzers anzuzeigen, ihm neue Autos hinzuzufügen sowie sie zu bearbeiten und zu löschen. PS-Servlets und JSP sind ziemlich alte Technologien, und im Internet findet man oft Kommentare im Sinne von „Wer braucht diesen Müll?“ Die Antwort ist ganz einfach: Sie werden vor allem von denen benötigt, die an echten Projekten arbeiten, bei denen es durchaus möglich ist, dass viel Code mit ihnen geschrieben wird. Und „altes Zeug“ in etwas Neues zu zersägen, ohne zu verstehen, wie es funktioniert, ist immer noch ein Vergnügen :) Für eine gründlichere Beschäftigung mit dem Thema JSP und Servlets können Sie das Buch „Head First Servlets and JSP“ (in Nur Englisch). Es wurde von denselben Autoren geschrieben wie das berühmte Superbuch „Head First Java“, was für viele ein Garant für Qualität sein kann :) Ich hoffe, dieser Artikel war für die Leser nützlich! Wenn Sie neue Artikel sehen möchten, vergessen Sie nicht, den Autor im Wettbewerb zu unterstützen, indem Sie ihn mit „Gefällt mir“ markieren. Oder noch besser: „Es gefällt mir sehr gut“ :) Vielen Dank für Ihre Aufmerksamkeit und viel Erfolg beim Lernen!