Ihre erste Anwendung mit Java-Servlets

Hallo an alle! Sie werden mit Servlets als Grundkonzept der Webentwicklung vertraut gemacht und können eine einfache Anwendung schreiben, die sie verwendet. Um unnötige Aktionen zu vermeiden, fangen wir nicht bei Null an. Wir werden weiter an unserer Anwendung aus meinem vorherigen Artikel über Hibernate arbeiten . Aber da wir gerade erst anfangen, uns mit Servlets vertraut zu machen, habe ich alles, was mit der Auto-Klasse zusammenhängt, aus der Anwendung entfernt und nur die User-Klasse und die damit verbundenen Aktionen übrig gelassen. Das Projekt wird wie folgt aufgebaut sein: Also, Servlets! In Wikipedia heißt es: „Ein Java-Servlet ist eine Java-Softwarekomponente, die die Fähigkeiten eines Servers erweitert. Obwohl Servlets auf viele Arten von Anfragen reagieren können, implementieren sie am häufigsten Webcontainer zum Hosten von Webanwendungen auf Webservern und qualifizieren sich daher als Server.“ Seite Servlet-Web-API. Das ist genau richtig. Hier stoßen wir erstmals auf das Konzept einer „Client-Server-Anwendungsarchitektur“. Im Kern ist es ganz einfach. Der Client greift auf den Server zu, indem er eine HTTP-Anfrage sendet. Der Server generiert die notwendigen Daten (holt sie beispielsweise aus einer Datenbank) und gibt sie an den Client zurück. Das einfachste Beispiel ist, wenn Sie in einem bestimmten sozialen Netzwerk auf die Schaltfläche „Freunde“ klicken und dadurch eine Anfrage an den Server senden. Der Server aktualisiert die Liste Ihrer Freunde in der Datenbank und sendet sie an Sie (den Client) zurück. Die Liste der HTTP-Anfragen ist ziemlich umfangreich. Wenn Sie also noch nie zuvor auf sie gestoßen sind, lesen Sie am besten an anderer Stelle darüber, z. B.hier . Unser Ziel ist: Erstellen einer CRUD-Anwendung mithilfe von Servlets. Die Anwendung muss in der Lage sein, mithilfe eines Servlets, das HTTP-Anforderungen verarbeitet, Benutzer in der Datenbank zu erstellen, zu lesen, zu aktualisieren und zu löschen. Unsere Anwendung aus dem Hibernate-Artikel konnte dies bereits tun, wurde jedoch direkt aus Java-Code gesteuert, genauer gesagt aus der Methode main(). Diesmal ist es der Client, der die Anfragen sendet, also Sie :) 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. Die JSTL-Tag-Bibliothek. Es wird benötigt, um die Clientseite, nämlich die JSP-Seiten, zu erstellen
3. Spring-WebMVC. Wir benötigen einen Frühlingskurs, über den wir etwas später sprechen werden.

Die Servlet-Verwaltung erfolgt über den Servlet-Container. In unserem Fall verwenden wir Apache Tomcat. Es ist ziemlich beliebt – Sie haben wahrscheinlich schon davon gehört :) Der Servlet-Lebenszyklus besteht aus den folgenden Schritten:

1. Wenn sich im Container kein Servlet 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 bedienen kann. Über den gesamten Lebenszyklus hinweg wird die Methode init() nur einmal aufgerufen.
2. Bedienen Sie die Kundenanfrage. Jede Anfrage wird in einem eigenen separaten Thread verarbeitet. Der Container ruft für jede Anfrage die Methode service() auf. Diese Methode ermittelt den Typ der eingehenden Anfrage und sendet sie zur Verarbeitung an die entsprechende Methode. Der Servlet-Entwickler muss Implementierungen für diese Methoden bereitstellen. Wenn eine Anfrage für einen Handler eintrifft, der nicht implementiert ist, wird die Methode der übergeordneten Klasse aufgerufen und gibt normalerweise einen Fehler an den Anforderer zurück.


3. Wenn der Container das Servlet entfernen muss, ruft er die Methode destroy() auf, die das Servlet außer Betrieb setzt. Wie die init()-Methode wird auch diese Methode einmal während des gesamten Servlet-Zyklus aufgerufen.

Unser Servlet sieht ganz einfach aus:

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 Methode init() und implementiert vier Methoden, die mit vier HTTP-Anfragen übereinstimmen: doPost(), doGet(), doPut() und doDelete(). Sie ermöglichen uns das Erstellen, Lesen, Aktualisieren und Löschen von Benutzern. Die Methoden akzeptieren Instanzen der Klassen javax.servlet.http.HttpServletRequest und javax.servlet.http.HttpServletResponse als Eingabe, dh an den Server gesendete Anforderungen und vom Client empfangene Antworten. Intern rufen die Methoden die relevanten Methoden der UserService-Klasse auf, und eine Antwort für den Client wird generiert und an die URL /users weitergeleitet. Beispielsweise erhalten wir in der doGet()-Methode eine Liste aller Benutzer. Als Nächstes erstellen wir ein RequestDispatcher-Objekt, mit dem wir Objekte in eine HTTP-Anfrage einschließen und diese an eine bestimmte Ressource umleiten können (z. B. an eine Client-JSP-Seite). In der doPut()-Methode (die Benutzerdaten aktualisiert) verarbeiten wir eine HTTP-Anfrage, extrahieren die Parameter ID, Name und Alter, suchen den Benutzer mit der angegebenen ID, weisen ihm den Namen und das Alter zu, die in der Anfrage angegeben sind, und kehren zurück zur Seite /users. Damit alle diese Methoden jedoch ordnungsgemäß funktionieren, müssen wir das Servlet konfigurieren. Dazu nutzen 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 ziemlich intuitiv, aber gehen wir sie der Reihe nach durch. <welcome-file-list> – Es wird die JSP-Startseite angegeben, die beim Start der Anwendung zuerst geöffnet wird. In unserem Fall ist dies index.jsp. <servlet> – Registrierung unserer UserSimpleServlet-Klasse als Servlet. <servlet-mapping> – ein sehr wichtiges Tag. Es definiert die URLs, die vom Servlet verarbeitet werden. In unserem Fall handelt es sich ausschließlich um URLs, daher geben wir einfach „/“ an. Aber wenn wir eine Anwendung hätten, die Benutzer und ihre Autos (Autos) einbezieht, könnten wir ein zweites Servlet (SimpleAutoServlet) erstellen. Dann wäre die Zuordnung des Benutzer-Servlets „/users“ (dh Anfragen zu Benutzern) und die Zuordnung des Auto-Servlets wäre „/autos“. Und schließlich <filter>. Intern definiert es eine Instanz der Organisation. springframework.web.filter.HiddenHttpMethodFilter-Klasse. In diesem Artikel geht es nicht um den Frühling, daher werde ich ihn nicht im Detail beschreiben. Ich möchte nur sagen, dass es nur als zusätzliche Funktion in unsere Anwendung integriert ist. Die Sache ist, dass wir JSP-Seiten verwenden werden, um die Client-Seite zu erstellen. Unsere Daten werden auf der Seite als Tabelle mit einer Benutzerliste angezeigt. Innerhalb der JSP-Seiten werden <form/> HTML-Tags verwendet. Zum Senden von Daten aus einem <form/> können jedoch nur HTTP-GET- und POST-Anfragen verwendet werden. Mit anderen Worten: 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 keine Option. Im Prinzip ist dies ganz normal und einfach zu implementieren, aber die HiddenHttpMethodFilter-Klasse ermöglicht es uns, sie zu verwenden. Auf diese Weise, Der Leser wird den Unterschied zwischen den Vorgängen in der Anwendung deutlicher erkennen. Kommen wir abschließend zur Client-Seite. Es wird durch fünf JSP-Seiten dargestellt. index.jsp.

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello!</title>
</head>
<body>
If you want to start working with the user database,<br>
click the button below:

<form action = "users" method="get">
    <input type="submit" value="Start working with database">
</form>
</body>
</html>

addUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Add new user</title>
</head>
<body>
<form action = "/users" method="post">
    <input required type="text" name="name" placeholder="Name">
    <input required type="text" name="age" placeholder="Age">
    <input type="submit" value="Save">
</form>
</body>
</html>

deleteUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Delete user</title>
</head>
<body>

Are you sure you want to delete the user ${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="Delete">
</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>User list</title>
</head>
<body>
<table border="2">
    <tr>
        <td>ID</td>
        <td>Name</td>
        <td>Age</td>
        <td>Actions</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="Modify" style="float:left">
                </form>
                <form action="deleteUser.jsp" method="post">
                    <input type="hidden" name="id" value="${user.getId()}">
                    <input type="submit" value="Delete" style="float:left">
                </form></td>
        </tr>
    </c:forEach>
</table>

<form action = "addUser.jsp">
    <input type="submit" value="Add new user">
</form>
</body>
</html>

updateUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Modify user data</title>
</head>
<body>

Edit user

<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="Update">
</form>

</body>
</html>

Eine JSP-Seite (JavaServer Page) enthält zwei Arten von Text: statische Quelldaten, die als Text formatiert werden können (HTML, SVG, WML oder XML), und JSP-Elemente, die zum Erstellen dynamischer Inhalte verwendet werden. Um Ihnen zu helfen, zu verstehen, was eine JSP-Seite ist, habe ich eine Passage aus einem sehr guten Artikel kopiert. „Grundsätzlich wird eine JSP, wenn sie zum ersten Mal angefordert wird, zu einem Servlet und fungiert als Servlet. Das ist sehr wichtig zu verstehen. Eine JSP-Seite ist NICHT wie eine HTML-Seite – ein beginnender Programmierer muss klar verstehen, dass es sich um ein weiteres Servlet handelt. “ – Sie müssen nur nicht schreiben und programmieren, wie sie angezeigt wird. Sie können sie einfach zeichnen. Und bei Bedarf Daten hinzufügen. Aber da eine JSP-Seite an HTML erinnert, wird es einem Designer offensichtlich leichter fallen. Und noch einmal Betonen Sie STARK für Anfänger,Eine JSP-Seite ist ein SERVLET. Die Generierung inklusive aller Daten erfolgt auf dem Server. Hier werden alle Daten eingefügt. Und im Browser erhält der Benutzer die fertige HTML-Seite, die keine Anzeichen von Java aufweist.“ Sie können sicher sein, dass eine JSP-Seite tatsächlich ein Servlet ist, da jede Seite über eine Methode verfügt, die ausgeführt werden muss. Zum Beispiel Index .jsp gibt an, dass beim Klicken auf die Schaltfläche „Arbeiten mit der Datenbank beginnen“ die Get-Methode ausgeführt wird (Methode = „get“). Die Seite addUser.jsp, die für das Erstellen neuer Benutzer verantwortlich ist, führt die Post-Methode aus (method = „post“), wenn Sie auf die Schaltfläche „Speichern“ klicken. Der Rest der JSP-Seite besteht aus regulärem statischem HTML-Markup, daher werden wir nicht näher darauf eingehen. Das ist ein Thema für einen anderen Artikel und es gibt viele dazu Thema im Internet. Also, wir' Wir haben unsere Anwendung erstellt! Jetzt müssen wir es in Aktion testen! Dazu benötigen wir den oben erwähnten Apache Tomcat Servlet-Container. Sie können den Container herunterladenvon der offiziellen Website (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 die Registerkarte „Konfigurationen bearbeiten“, erstellen Sie eine neue Konfiguration und wählen Sie „Tomcat Server Local“. Geben Sie auf der Registerkarte „Anwendungsserver“ den Pfad zum Tomcat-Ordner an . Wechseln Sie anschließend zur Registerkarte „Bereitstellung“. Hier konfigurieren wir die Bereitstellung unserer Anwendung auf dem lokalen Server. Drücken Sie „+“, wählen Sie „Artefakt“ -> YourProjectName:war (wir erstellen die Anwendung in einer WAR-Datei). Und das bringt es auf den Punkt! Auf der Seite „Server“ können Sie sehen, dass unsere Anwendung unter http://localhost:8080/ ausgeführt wird. Speichern Sie die Konfiguration und geben Sie ihr einen Namen (ich nenne meine Konfiguration „Tommy“). Als nächstes verwenden wir auf der Registerkarte „Maven“ in IDEA (auf der rechten Seite) das War-Plugin, um unser Projekt in eine War-Datei zu erstellen (Plugins -> War -> War: War). Nachdem der Build abgeschlossen ist, führen Sie die Anwendung aus und warten Sie. Erfolg! Die Startseite wurde gestartet. Jetzt klicken wir auf die Schaltfläche „Mit der Datenbank arbeiten beginnen“. Unsere 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 (vorausgesetzt natürlich, dass Benutzer in der Datenbank vorhanden sind). Und da sind sie! Da haben Sie es! Sie haben Ihre erste Anwendung mit Java-Servlets geschrieben. Das war doch nicht so schlimm, oder? :) Als Hausaufgabe könnten Sie die Funktionalität des Autos aus dem vorherigen Artikel wiederherstellen. Mit anderen Worten: Erstellen Sie ein separates Servlet und JSP-Seiten für Autos und bringen Sie der Anwendung bei, wie sie die Autos eines Benutzers auflistet, einem Benutzer neue Autos hinzufügt und sie bearbeitet und löscht. PS-Servlets und JavaServer Pages sind eher alte Technologien. Im Internet findet man oft Kommentare wie „Wer braucht diesen alten Müll?“ Die Antwort ist ganz einfach: Hauptsächlich Leute, die an echten Projekten arbeiten, bei denen sie möglicherweise auf viel Code stoßen, der diese Technologien verwendet. Und selbst ohne zu verstehen, wie es funktioniert, macht es immer noch Spaß, „alten Müll“ in etwas Neues zu zerlegen :) Für eine gründlichere Untersuchung von JSP und Servlets können Sie sich das Buch „Head First Servlets and JSP“ ansehen .. Es wurde von denselben Autoren geschrieben wie das berühmte Superbuch „Head First Java“, was viele als Qualitätsgarantie ansehen :) Ich hoffe, dieser Artikel war hilfreich! Vielen Dank für Ihre Aufmerksamkeit und viel Glück beim Lernen!