Artikel
Start
Jetzt lernen
Jetzt lernen
CodeGym/Java-Blog/Random-DE/Erstellen einer einfachen Webanwendung mit Servlets und J...
John Squirrels
Level 41
San Francisco

Erstellen einer einfachen Webanwendung mit Servlets und JSPs (Teil 2)

Veröffentlicht in der Gruppe Random-DE
Erstellen einer einfachen Webanwendung mithilfe von Servlets und JSPs (Teil 1). Zum Verständnis des Artikels erforderliche Kenntnisse: Sie haben Java Core bereits mehr oder weniger verstanden und möchten sich mit JavaEE-Technologien und Webprogrammierung befassen. Am sinnvollsten wäre es für Sie, sich derzeit mit der Quest „Java-Sammlungen“ zu befassen, die sich mit Themen befasst, die dem Artikel nahe stehen.
Erstellen einer einfachen Webanwendung mit Servlets und JSPs (Teil 2) – 1

Entitäten erstellen

Im Entities- Paket erstellen wir eine UserKlasse mit zwei privaten String-Variablen: Name und Passwort . Erstellen Sie Konstruktoren (Standard und einen, der beide Werte annimmt) und Getter/Setter und überschreiben Sie toString()für alle Fälle die Methode zusammen mit den Methoden equals()und hashCode(). Mit anderen Worten: Wir werden beim Erstellen einer Klasse alles tun, was ein seriöser Java-Entwickler tut. 
public class User {
    private String name;
    private String password;

    public User() {
    }

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (name != null ? !name.equals(user.name) : user.name != null) return false;
        return password != null ? password.equals(user.password) : user.password == null;

    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + (password != null ? password.hashCode() : 0);
        return result;
    }
}
Jetzt können wir mit der Erstellung einer Benutzerliste beginnen. Wir fügen Benutzer hinzu und übernehmen Benutzer daraus, um sie anzuzeigen. Allerdings haben wir ein Problem. Wir erstellen unsere Servlet-Objekte nicht. Tomcat erledigt das für uns. Die Methoden, die wir darin überschreiben, sind bereits für uns definiert und wir können keine Parameter festlegen. Wie erstellen wir dann eine gemeinsame Liste, die in unseren beiden Servlets sichtbar ist? Wenn wir in jedem Servlet einfach ein Listenobjekt erstellen, fügen wir Benutzer zu einer Liste hinzu, zeigen jedoch Benutzer aus einer anderen Liste im ListServlet an. Wir benötigen also ein Objekt, das von beiden Servlets gemeinsam genutzt wird. Im Allgemeinen benötigen wir ein Objekt, das von allen Klassen in unserem Programm gemeinsam genutzt wird: ein Objekt für das gesamte Programm. Ich hoffe, Sie haben etwas über Designmuster gehört. Für einige Leute ist dies möglicherweise der erste wirkliche Bedarf für das Singleton- Muster in ihrem Programm. Sie könnten verrückt werden und ein paar nette Singletons mit doppelten Überprüfungen und Synchronisierungen herausbringen (ja, unsere Anwendung ist multithreaded, da Tomcat-Servlets auf separaten Threads laufen). Aber ich werde die frühe Initialisierungstechnik verwenden, weil sie für unsere Zwecke hier völlig ausreichend ist.

Ein Modell erstellen

Erstellen Sie eine Klasse (und implementieren Sie das Singleton- Muster) im Modellpaket und nennen Sie sie etwas Ungewöhnliches. Beispiel: Modell . Wir erstellen eine private Liste von Benutzern in unserer Klasse und implementieren zwei Methoden: eine zum Hinzufügen eines Benutzers und eine andere zum Zurückgeben einer Liste von Zeichenfolgen (Benutzernamen). Da unser Benutzerobjekt aus einem Benutzernamen und einem Passwort besteht und wir die Passwörter der Benutzer nicht preisgeben möchten, haben wir nur eine Liste mit Namen. 
public class Model {
    private static Model instance = new Model();

    private List<User> model;

    public static Model getInstance() {
        return instance;
    }

    private Model() {
        model = new ArrayList<>();
    }

    public void add(User user) {
        model.add(user);
    }

    public List<String> list() {
        return model.stream()
                .map(User::getName)
                .collect(Collectors.toList());
    }
}

Ein bisschen über MVC

Da Sie bereits von singleton gehört haben , haben Sie wahrscheinlich auch von einem anderen Designmuster Model-View-Controller (MVC) gehört. Sein Zweck besteht darin, die Geschäftslogik von der Ansicht zu trennen. Das heißt, den Code, der bestimmt, was zu tun ist, von dem Code zu trennen, der bestimmt, wie Dinge angezeigt werden. Die Ansicht ist für die Darstellung der Daten verantwortlich. In unserem Fall sind die Ansichten unsere JSP-Seiten . Genau aus diesem Grund habe ich sie in einem Ordner namens „views“ abgelegt . Das Modell sind die Daten, mit denen das Programm tatsächlich arbeitet. In unserem Fall sind dies die Benutzer (Liste der Benutzer). Und Controller sind das Bindeglied zwischen ihnen. Sie nehmen Daten aus dem Modell und geben sie an die Ansichten weiter (oder rufen einige Daten von Tomcat ab, verarbeiten und an das Modell übergeben). Sie definieren Ihre Geschäftslogik (was das Programm tun soll) in ihnen, nicht im Modell oder in der Ansicht. Somit erledigt jeder Teil sein eigenes Geschäft:
Java webinar
  • das Modell speichert Daten;
  • Ansichten liefern schöne Darstellungen der Daten;
  • Die Datenverarbeitung erfolgt durch die Verantwortlichen.
Dadurch ist das Programm recht einfach und wartbar und nicht ein monströser Haufen des gesamten Codes in einer Klasse. MVC eignet sich nicht nur für die Webprogrammierung, sondern wird in diesem Bereich besonders häufig (fast immer) eingesetzt. In unserem Fall fungieren die Servlets als Controller. Dies ist eine sehr oberflächliche und kurze Beschreibung des Musters, aber MVC ist nicht das Hauptthema dieses Artikels. Wenn jemand mehr erfahren möchte, ist Google Ihr Freund! Erstellen Sie ein Formular zum Hinzufügen eines Benutzers. Fügen Sie das Formular zu add.jsp hinzu . Es sollte aus zwei Texteingabefeldern (eines gewöhnlichen, das andere – einem Passwortfeld) und einer Schaltfläche zum Senden der Daten an den Server bestehen. 
<form method="post">
    <label>Name:
        <input type="text" name="name"><br />
    </label>

    <label>Password:
        <input type="password" name="pass"><br />
    </label>
    <button type="submit">Submit</button>
</form>
Hier hat das Formular ein Methodenattribut mit dem Wert post . Dies bedeutet, dass die Daten aus diesem Formular als POST-Anfrage an den Server gesendet werden . Das Aktionsattribut ist nicht angegeben, was bedeutet, dass die Anfrage an dieselbe Adresse gesendet wird, von der wir auf diese Seite gekommen sind ( /add ). Daher gibt unser an diese Adresse gebundenes Servlet beim Empfang einer GET-Anfrage die JSP mit dem Add-User-Formular zurück. Und wenn es eine POST-Anfrage erhält , wissen wir, dass das Formular seine Daten hierher gesendet hat (die wir aus dem Anforderungsobjekt in extrahieren).doPost()Methode, Prozess und Übergabe an das Modell zum Speichern). Es ist erwähnenswert, dass Eingabefelder einen Parameter namens „ Name“ haben (für Benutzernamen oder „Pass“ für Passwörter). Das ist ein sehr wichtiger Punkt. Um diese Daten (den Benutzernamen und das Passwort, die eingegeben werden) von der Anfrage (innerhalb des Servlets) zu erhalten, verwenden wir diese Namens- und Pass- Felder. Aber dazu später mehr. Mein Button zum Senden von Daten wurde wieder als Button gestaltet , nicht wie üblich als Ausgabefeld. Ich weiß nicht, wie weit verbreitet dieser Ansatz ist, aber er funktioniert bei mir (Chrome-Browser).

Servlet-Verarbeitung von POST-Anfragen

Kehren wir zum AddServlet zurück . Ich erinnere Sie daran, dass wir die Methode in der HttpServlet- Klasse überschrieben haben, damit unser Servlet GET-Anfragen „abfangen“ kann . Um unserem Servlet beizubringen, auch POST-Anfragen abzufangen , müssen wir auch die Methode überschreiben . Tomcat übergibt ihm ähnliche Anforderungs- und Antwortobjekte, mit denen wir arbeiten werden. Extrahieren Sie zunächst den Namen der Anfrage und übergeben Sie die vom Formular gesendeten Parameter (wenn Sie im Formular andere Namen angegeben haben, verwenden Sie diese Namen). Erstellen Sie anschließend ein Benutzerobjekt mit den empfangenen Daten. Dann holen wir uns das Modellobjekt und fügen den erstellten Benutzer zum Modell hinzu. doGet()doPost() 
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    String name = req.getParameter("name");
    String password = req.getParameter("pass");
    User user = new User(name, password);
    Model model = Model.getInstance();
    model.add(user);
}

Übergeben von Daten an die Ansicht

Fahren wir mit dem ListServlet fort . Die doGet()Methode ist bereits implementiert. Es überträgt einfach die Kontrolle an die Ansicht ( list.jsp ). Wenn Sie dies noch nicht haben, erstellen Sie es analog zur Methode im AddServlet . Jetzt wäre es schön, die Liste der Benutzernamen vom Modell abzurufen und sie an die Ansicht zu übergeben, die sie empfängt und schön anzeigt. Dazu verwenden wir wieder das Request-Objekt, das wir von Tomcat erhalten haben . Wir können diesem Objekt ein Attribut hinzufügen und ihm einen Namen geben. Tatsächlich können wir der Ansicht das Objekt hinzufügen, das wir übergeben möchten. Aufgrund der Tatsache, dass wir bei der Übertragung der Kontrolle vom Servlet an die Ansicht der Ansicht dieselben Anforderungs- und Antwortobjekte übergeben, die das Servlet erhalten hat, können wir unsere Namensliste zum Anforderungsobjekt hinzufügen und dann unsere Liste der Benutzernamen aus der Anforderung abrufen Objekt in der Ansicht. Da wir mit der ListServlet- Klasse fertig sind , präsentiere ich hier den Code der gesamten Klasse: 
package app.servlets;

import app.model.Model;

import javax.servlet.RequestDispatcher;
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 ListServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Model model = Model.getInstance();
        List<String> names = model.list();
        req.setAttribute("userNames", names);

        RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/list.jsp");
        requestDispatcher.forward(req, resp);
    }
}

Ausführen von Java-Code in JSP-Dateien

Es ist Zeit, einen Blick auf list.jsp zu werfen . Es wird nur ausgeführt, wenn ListServlet ihm die Kontrolle übergibt. Darüber hinaus haben wir die Liste der Benutzernamen bereits aus dem Modell im Servlet vorbereitet und hier im Anforderungsobjekt übergeben. Da wir die Liste der Namen haben, können wir sie mithilfe einer Schleife durchlaufen forund jeden Namen anzeigen. Wie ich bereits sagte, können JSP-Dateien Java-Code ausführen (was sie von statischen HTML-Seiten unterscheidet). Um Code auszuführen, müssen wir lediglich das folgende Konstrukt an der entsprechenden Stelle einfügen: 
<!-- html code -->
<%
    // Java code
%>
<!-- html code -->
Innerhalb dieses Konstrukts erhalten wir Zugriff auf mehrere Variablen:
  • request – unser Anfrageobjekt, das wir vom Servlet übergeben haben, wo es einfach req hieß ;
  • Antwort – das Antwortobjekt ( im Servlet resp genannt);
  • out – ein JspWriter- Objekt (das einen gewöhnlichen Writer erbt), mit dem wir etwas direkt in die HTML-Seite selbst „schreiben“ können . Die Anweisung out.println("Hello, World!") ist System.out.println("Hello, World!") sehr ähnlich , aber verwechseln Sie sie nicht!
  • out.println() „schreibt“ auf eine HTML-Seite , während System.out.println in den Systemausgabestream schreibt . Wenn Sie System.out.println() innerhalb eines JSP- Abschnitts mit Java-Code aufrufen , werden die Ergebnisse in der Tomcat- Konsole angezeigt, jedoch nicht auf der Seite.
Hier können Sie nach anderen in einer JSP verfügbaren Objekten suchen . Wir können das Anforderungsobjekt verwenden , um die Liste der vom Servlet übergebenen Namen abzurufen (wir haben das entsprechende Attribut an dieses Objekt angehängt), und wir können das Out- Objekt verwenden, um diese Namen anzuzeigen. Lassen Sie uns sie anzeigen (vorerst als einfache HTML-Liste): 
<ul>
    <%
        List<String> names = (List<String>) request.getAttribute("userNames");

        if (names != null && !names.isEmpty()) {
            for (String s : names) {
                out.println("<li>" + s + "</li>");
            }
        }
    %>
</ul>
Wenn wir die Liste nur anzeigen müssen, wenn Benutzer vorhanden sind, und andernfalls eine Warnung anzeigen müssen, dass noch keine Benutzer vorhanden sind, können wir diesen Abschnitt ein wenig umschreiben: 
<%
    List<String> names = (List<String>) request.getAttribute("userNames");

    if (names != null && !names.isEmpty()) {
        out.println("<ui>");
        for (String s : names) {
            out.println("<li>" + s + "</li>");
        }
        out.println("</ui>");
    } else out.println("<p>There are no users yet!</p>");
%>
Da wir nun wissen, wie Daten von Servlets an Ansichten übergeben werden, können wir unser AddServlet so verbessern, dass es eine Benachrichtigung über das erfolgreiche Hinzufügen eines Benutzers anzeigt. Dazu doPost()können wir in der Methode nach dem Hinzufügen eines neuen Benutzers zum Modell diesen Benutzernamen zu den Attributen des req- Objekts hinzufügen und die Kontrolle an eine Ansicht ( add.jsp ) zurückgeben . Und jetzt fügen wir einen Abschnitt mit Java-Code hinzu, in dem wir prüfen, ob die Anfrage ein solches Attribut hat, und wenn ja, zeigen wir eine Meldung an, dass der Benutzer erfolgreich hinzugefügt wurde. Nach diesen Änderungen sieht der vollständige Code von AddServlet etwa so aus: 
package app.servlets;

import app.entities.User;
import app.model.Model;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class AddServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/add.jsp");
        requestDispatcher.forward(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String name = req.getParameter("name");
        String password = req.getParameter("pass");
        User user = new User(name, password);
        Model model = Model.getInstance();
        model.add(user);

        req.setAttribute("userName", name);
        doGet(req, resp);
    }
}
Hier erstellen wir am Ende der doPost()Methode ein Attribut mit dem Namen des Benutzers, der dem Modell hinzugefügt wurde, und rufen dann die doGet()Methode auf, an die wir die aktuelle Anfrage und Antwort übergeben. Die doGet()Methode übergibt nun die Kontrolle an den View, der zusätzlich das Request-Objekt mit dem Namen des hinzugefügten Benutzers als Attribut angehängt erhält. Was uns noch bleibt, ist, add.jsp so zu korrigieren, dass es die Benachrichtigung anzeigt, wenn kein solches Attribut vorhanden ist. Hier ist die endgültige Version von add.jsp : 
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Add new user</title>
    </head>

    <body>
        <div>
            <h1>Super app!</h1>
        </div>

        <div>
            <%
                if (request.getAttribute("userName") != null) {
                    out.println("<p>User '" + request.getAttribute("userName") + "' added!</p>");
                }
            %>
            <div>
                <div>
                    <h2>Add user</h2>
                </div>

                <form method="post">
                    <label>Name:
                        <input type="text" name="name"><br />
                    </label>
                    <label>Password:
                        <input type="password" name="pass"><br />
                    </label>
                    <button type="submit">Submit</button>
                </form>
            </div>
        </div>

        <div>
            <button onclick="location.href='/'">Back to main</button>
        </div>
    </body>
</html>
Der Seitentext besteht aus Folgendem:
  • ein Div mit einem Header;
  • ein div-Container für Inhalte, der eine Prüfung beinhaltet, ob ein Attribut mit einem Benutzernamen vorhanden ist;
  • ein div mit dem Add-User-Formular;
  • und unten eine Fußzeile mit einer Schaltfläche, um zur Startseite zurückzukehren.
Das mag wie zu viele Divs erscheinen, aber wir werden sie später verwenden, wenn wir Stile hinzufügen. Hier ist die endgültige Version von list.jsp : 
<%@ page import="java.util.List" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Users</title>
    </head>

    <body>
        <div>
            <h1>Super app!</h1>
        </div>

        <div>
            <div>
                <div>
                    <h2>Users</h2>
                </div>
                <%
                    List<String> names = (List<String>) request.getAttribute("userNames");

                    if (names != null && !names.isEmpty()) {
                        out.println("<ui>");
                        for (String s : names) {
                            out.println("<li>" + s + "</li>");
                        }
                        out.println("</ui>");
                    } else out.println("<p>There are no users yet!</p>");
                %>
            </div>
        </div>

        <div>
            <button onclick="location.href='/'">Back to main</button>
        </div>
    </body>
</html>
Somit verfügen wir über eine voll funktionsfähige Webanwendung, die Benutzer speichern und hinzufügen sowie eine Liste ihrer Namen anzeigen kann. Jetzt müssen wir es nur noch hübsch machen... :) Erstellen einer einfachen Webanwendung mit Servlets und JSPs (Teil 2) – 2

Stile hinzufügen. Wir verwenden das W3.CSS-Framework

Im Moment funktioniert unsere Anwendung, aber sie sieht absolut unverschämt aus. Fügen wir also einen Hintergrund hinzu, färben den Text und die Schaltflächen ein, fügen Stil zu den Listen hinzu, richten Elemente aus, fügen Einzüge hinzu und so weiter. Manuelle Schreibstile können viel Zeit in Anspruch nehmen und unsere Nerven belasten. Daher schlage ich die Verwendung des W3.CSS- Frameworks vor. Es verfügt bereits über gebrauchsfertige Klassen mit Stilen. Wir müssen nur die CSS-Klassen, die wir verwenden möchten, an den richtigen Stellen anordnen. Um sie zu unseren Seiten hinzuzufügen, verbinden wir zunächst die Style-Datei. Hierzu gibt es zwei Möglichkeiten:

  1. Gehen Sie unsere Seiten durch und fügen Sie im Kopfbereich einen direkten Link zur Style-Datei ein

    <link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css">

    Diese Option eignet sich, wenn Sie über eine dauerhafte Internetverbindung verfügen. Wenn Sie Ihre Seiten auf dem lokalen Server öffnen, werden die Stile aus dem Internet abgerufen.

  2. Wenn Sie jedoch alle Stile lokal haben möchten und nicht auf eine Internetverbindung angewiesen sind, laden Sie die Stildatei herunter und legen Sie sie irgendwo im Webordner ab ( z. B. web/styles/w3.css ). Gehen Sie dann alle unsere Seiten durch ( index.html, add.jsp, list.jsp ) und fügen Sie den folgenden Link zur Style-Datei im Head- Bereich hinzu:

    <link rel="stylesheet" href="styles/w3.css">

    Gehen Sie danach einfach die Tags durch und fügen Sie die Stile hinzu, die Ihnen gefallen. Ich werde hierauf nicht näher eingehen. Stattdessen stelle ich einfach gebrauchsfertige Versionen von drei meiner Dateien mit Klassen im Rasterstil bereit.

index.html 
<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Super app!</title>
        <link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css">
    </head>

    <body class="w3-light-grey">
        <div class="w3-container w3-blue-grey w3-opacity w3-right-align">
            <h1>Super app!</h1>
        </div>

        <div class="w3-container w3-center">
            <div class="w3-bar w3-padding-large w3-padding-24">
                <button class="w3-btn w3-hover-light-blue w3-round-large" onclick="location.href='/list'">List users</button>
                <button class="w3-btn w3-hover-green w3-round-large" onclick="location.href='/add'">Add user</button>
            </div>
        </div>
    </body>
</html>
add.jsp
Java university 
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Add new user</title>
        <link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css">
    </head>

    <body class="w3-light-grey">
        <div class="w3-container w3-blue-grey w3-opacity w3-right-align">
            <h1>Super app!</h1>
        </div>

        <div class="w3-container w3-padding">
            <%
                if (request.getAttribute("userName") != null) {
                    out.println("<div class=\"w3-panel w3-green w3-display-container w3-card-4 w3-round\">\n" +
                            "   <span onclick=\"this.parentElement.style.display='none'\"\n" +
                            "   class=\"w3-button w3-margin-right w3-display-right w3-round-large w3-hover-green w3-border w3-border-green w3-hover-border-grey\">×</span>\n" +
                            "   <h5>User '" + request.getAttribute("userName") + "' added!</h5>\n" +
                            "</div>");
                }
            %>
            <div class="w3-card-4">
                <div class="w3-container w3-center w3-green">
                    <h2>Add user</h2>
                </div>
                <form method="post" class="w3-selection w3-light-grey w3-padding">
                    <label>Name:
                        <input type="text" name="name" class="w3-input w3-animate-input w3-border w3-round-large" style="width: 30%"><br />
                    </label>
                    <label>Password:
                        <input type="password" name="pass" class="w3-input w3-animate-input w3-border w3-round-large" style="width: 30%"><br />
                    </label>
                    <button type="submit" class="w3-btn w3-green w3-round-large w3-margin-bottom">Submit</button>
                </form>
            </div>
        </div>

        <div class="w3-container w3-grey w3-opacity w3-right-align w3-padding">
            <button class="w3-btn w3-round-large" onclick="location.href='/'">Back to main</button>
        </div>
    </body>
</html>
list.jsp 
<%@ page import="java.util.List" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Users list</title>
        <link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css">
    </head>

    <body class="w3-light-grey">
        <div class="w3-container w3-blue-grey w3-opacity w3-right-align">
            <h1>Super app!</h1>
        </div>

        <div class="w3-container w3-center w3-margin-bottom w3-padding">
            <div class="w3-card-4">
                <div class="w3-container w3-light-blue">
                    <h2>Users</h2>
                </div>
                <%
                    List<String> names = (List<String>) request.getAttribute("userNames");

                    if (names != null && !names.isEmpty()) {
                        out.println("<ul class=\"w3-ul\">");
                        for (String s : names) {
                            out.println("<li class=\"w3-hover-sand\">" + s + "</li>");
                        }
                        out.println("</ul>");

                    } else out.println("<div class=\"w3-panel w3-red w3-display-container w3-card-4 w3-round\">\n"
+
                            "   <span onclick=\"this.parentElement.style.display='none'\"\n" +
                            "   class=\"w3-button w3-margin-right w3-display-right w3-round-large w3-hover-red w3-border w3-border-red w3-hover-border-grey\">×</span>\n" +
                            "   <h5>There are no users yet!</h5>\n" +
                            "</div>");
                %>
            </div>
        </div>

        <div class="w3-container w3-grey w3-opacity w3-right-align w3-padding">
            <button class="w3-btn w3-round-large" onclick="location.href='/'">Back to main</button>
        </div>
    </body>
</html>
Und das ist es. :) Wenn Sie noch Fragen oder Kommentare haben oder etwas nicht klappen sollte, hinterlassen Sie bitte einen Kommentar. Und ich füge ein paar Screenshots bei, die zeigen, wie alles ausgegangen ist.
Erstellen einer einfachen Webanwendung mit Servlets und JSPs (Teil 2) – 3
Erstellen einer einfachen Webanwendung mit Servlets und JSPs (Teil 2) – 4
Erstellen einer einfachen Webanwendung mit Servlets und JSPs (Teil 2) – 5
Und schließlich , wenn Sie mit diesem Projekt üben möchten, können Sie Folgendes versuchen:
  • Erstellen Sie ein Servlet und eine JSP, um einen Benutzer zu löschen, und fügen Sie ein weiteres Paar hinzu, um einen vorhandenen Benutzer zu bearbeiten. Das Ergebnis wird eine echte CRUD-Webanwendung sein, die mithilfe von Servlets erstellt wird. ;)
  • Ersetzen Sie die Liste durch eine Datenbank, damit die hinzugefügten Benutzer nach dem Neustart des Servers nicht verschwinden. :) :)
Viel Glück!

Mehr Lektüre:
Kommentare
  • Beliebt
  • Neu
  • Alt
Du musst angemeldet sein, um einen Kommentar schreiben zu können
Auf dieser Seite gibt es noch keine Kommentare