TOC

Anleitung zu JavaServer Pages (JSP)

Inhaltsverzeichnis

  • Link: #Übersicht[ 1. Übersicht]

  • link: #jsp[ 2. JavaServer-Seiten]

  • link: #syntax[ 2.1. JSP-Syntax]

  • link: #contents[ 2.2. Statische und dynamische Inhalte]

  • link: #implicit[ 2.3. Implizite Objekte]

  • link: #implicit[ 2.4. Andere implizite Objekte]

  • link: #directives[ 2.5. Direktiven]

  • link: #page[ 2.6. Seitenanweisungen]

  • link: #threeExamples[ 3.0. Drei Beispiele]

  • link: #htmlRendered[ 3.1. In Servlet gerendertes HTML]

  • link: #staticJava[ 3.2. Java in einem statischen JSP-Inhalt]

  • link: #forwarding[ 3.3. JSP mit Weiterleitung]

  • link: #tryIt[ 3.4. Ausprobieren!]

  • link: #conclusion[ 4. Schlussfolgerung]

1. Überblick

  • JavaServer Pages (JSP) ermöglicht das Einfügen von dynamischen Inhalten in static -Inhalte mithilfe von Java und Java-Servlets . Wir können Anfragen an ein Java Servlet richten, relevante Logik ausführen und eine bestimmte Ansicht serverseitig so darstellen, dass sie clientseitig konsumiert wird ** . Dieser Artikel bietet einen umfassenden Überblick über JavaServer Pages mit Java 8 und Jave 7 EE.

Wir werden zunächst einige wichtige Konzepte untersuchen, die für JSP relevant sind: nämlich den Unterschied zwischen dynamic und static -Inhalten, den JSP-Lebenszyklus und die JSP-Syntax sowie Anweisungen und implizierte Objekte, die beim Kompilieren erstellt werden!

2. JavaServer-Seiten

JavaServer Pages (JSP) ermöglichte es, dass Java-spezifische Daten in eine .jsp-Ansicht übergeben oder dort platziert werden und clientseitig verwendet werden.

  • JSP-Dateien sind im Wesentlichen .html-Dateien ** mit zusätzlicher Syntax und einigen geringfügigen anfänglichen Unterschieden:

    1. Das Suffix .html wird durch .jsp ersetzt (es wird als .jsp betrachtet.)

Dateityp) und . Das folgende Tag wird oben in den HTML-Markup-Elementen hinzugefügt: 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

Gehen wir einige der wichtigsten Konzepte von JSP durch.

2.1. JSP-Syntax

Es gibt zwei Möglichkeiten, einem .jsp Java-Code hinzuzufügen. Erstens können wir die grundlegende Java Scriptlet-Syntax verwenden, bei der Java-Codeblöcke innerhalb von zwei Scriptlet-Tags platziert werden: 

<% Java code here %>

Die zweite Methode ist XML-spezifisch: 

<jsp:scriptlet>
    Java code here
</jsp:scriptlet>

Es ist wichtig, dass Sie mit JSP bedingte Logik-Clients verwenden können, indem Sie if -, then - und else -Klauseln verwenden und dann die relevanten Markup-Blöcke mit diesen Klammern umschließen. 

<% if (doodad) {%>
    <div>Doodad!</div>
<% } else { %>
    <p>Hello!</p>
<% } %>

Wenn doodad beispielsweise true ist, würden wir das erste div -Element anzeigen, ansonsten würden wir das zweite p -Element anzeigen!

2.2. Static und Dynamic Inhalt

Static -Webinhalte sind feste Assets, die unabhängig von RESTful-, SOAP-, HTTP-, HTTPS-Anforderungen oder anderen vom Benutzer übermittelten Informationen verwendet werden.

Static -Inhalt ist jedoch festgelegt und wird nicht durch Benutzereingaben geändert.

Dynamic -Webinhalte sind solche Assets, die auf Benutzeraktionen oder -informationen reagieren, von diesen modifiziert werden oder sich ändern.

Die JSP-Technologie ermöglicht die saubere Trennung der Verantwortlichkeiten zwischen dynamischen und statischen Inhalten.

Der Server (Servlet) verwaltet die dynamic -Inhalte und der Client (die aktuelle .jsp-Seite) ist der static -Kontext, in den dynamische Inhalte eingefügt werden.

Schauen wir uns die implicit objects an, die von JSP erstellt werden und die den Zugriff auf JSP-relevante Daten serverseitig ermöglichen!

2.3. Implizite Objekte

Implicit Objekte werden während der Kompilierung automatisch von der JSP-Engine generiert.

Implicit objects enthalten die HttpRequest - und HttpResponse -Objekte und stellen verschiedene serverseitige Funktionen zur Verwendung in Ihrem Servlet und für die Interaktion mit Ihrem .jsp bereit! Hier ist die Liste der implicit Objekte , die erstellt werden:

  • request ** + request gehört zur Klasse javax.servlet.http.HttpServletRequest .

Das __request-Objekt macht alle Benutzereingabedaten verfügbar und macht sie serverseitig verfügbar.

  • response ** response gehört zur Klasse javax.servlet.http.HttpServletResponse und legt fest, was nach einer request clientseitig zurückgegeben wird.

Schauen wir uns die impliziten request - und response -Objekte genauer an, da es sich um die wichtigsten und am häufigsten verwendeten Objekte handelt.

Das folgende Beispiel zeigt eine sehr einfache, unvollständige Servlet-Methode zur Verarbeitung von GET-Anforderungen. Ich habe die meisten Details weggelassen, damit wir uns auf die Verwendung der request - und response -Objekte konzentrieren können: 

protected void doGet(HttpServletRequest request,
  HttpServletResponse response) throws ServletException, IOException {
    String message = request.getParameter("message");
    response.setContentType("text/html");
    . . .
}

Zunächst sehen wir, dass die request - und response -Objekte als Parameter an die Methode übergeben werden, wodurch sie innerhalb ihres Gültigkeitsbereichs verfügbar werden.

Mit der Funktion .getParameter () können wir auf Anforderungsparameter zugreifen.

Oben greifen wir den message -Parameter auf und initialisieren eine String-Variable, damit wir sie in unserer serverseitigen Logik verwenden können. Wir können auch auf das response -Objekt zugreifen, das bestimmt, was und wie die in die Ansicht übergebenen Daten sein werden.

Oben setzen wir den Inhaltstyp darauf. Das response -Objekt muss nicht zurückgegeben werden, damit die Payload auf der JSP-Seite beim Rendern angezeigt wird.

  • out ** out gehört zur Klasse javax.servlet.jsp.JspWriter und wird verwendet, um Inhalte auf den Client zu schreiben.

Es gibt mindestens zwei Möglichkeiten, auf Ihrer JSP-Seite zu drucken, und beide sollten hier diskutiert werden. out wird automatisch erstellt und ermöglicht das Schreiben in den Speicher und dann in das Response -Objekt: 

out.print(“hello”);
out.println(“world”);

Das ist es!

Der zweite Ansatz kann performanter sein, da Sie direkt in das response -Objekt schreiben können! Hier verwenden wir PrintWriter : 

PrintWriter out = response.getWriter();
out.println("Hello World");

2.4. Andere implizite Objekte

Hier sind einige andere __Implicit-Objekte, die auch gut zu wissen sind!

  • session ** session gehört zur Klasse javax.servlet.http.HttpSession verwaltet Benutzerdaten für die Dauer der Sitzung.

  • application ** application gehört zur Klasse javax.servlet.ServletContext speichert anwendungsweite Parameter, die bei der Initialisierung gesetzt wurden oder auf die anwendungsweit zugegriffen werden muss.

  • exception ** exception gehört zur Klasse javax.servlet.jsp.JspException wird zur Anzeige von Fehlernachrichten auf JSP-Seiten verwendet, die das Tag <% @ page isErrorPage = "true"%> enthalten.

  • page ** page gehört zur Klasse java.lang.Object , mit der auf aktuelle Servlet-Informationen zugegriffen werden kann.

  • pageContext ** + pageContext gehört zur Klasse javax.servlet.jsp.PageContext standardmäßig auf page scope, kann aber für den Zugriff auf request , application und session attributes verwendet werden.

  • config ** + config gehört zur Klasse javax.servlet.ServletConfig ist das Servlet-Konfigurationsobjekt, über das der Servlet-Kontext, der Name und die Konfigurationsparameter abgerufen werden können.

Nun, da wir uns mit den von JSP bereitgestellten implicit objects befasst haben, wenden wir uns directives zu, mit denen .jsp-Seiten (indirekt) auf einige dieser Objekte zugreifen können.

2.5. Richtlinien

JSP stellt Direktanweisungen bereit, mit denen Kernfunktionalitäten für unsere JSP-Dateien festgelegt werden können. JSP-Direktiven bestehen aus zwei Teilen: (1) der Direktive selbst und (2) dem Attribut dieser Direktive, dem ein Wert zugewiesen ist.

Die drei Arten von Anweisungen, auf die mithilfe von Direktive-Tags verwiesen werden kann, sind <% @ page …​%> , wobei Abhängigkeiten und Attribute der JSP definiert werden, darunter content type und language , <% @ include …​%> which gibt einen Import oder eine zu verwendende Datei an, und <% @ taglib …​%> gibt eine Tag-Bibliothek an, die benutzerdefinierte Aktionen definiert, die von einer Seite verwendet werden sollen.

Eine Seitenanweisung würde beispielsweise mit JSP-Tags folgendermaßen angegeben: <% @ Seitenattribut = "Wert"%>

Wir können dies mit XML wie folgt tun: <jsp: direct.page attribute = "value"/>

2.6. Seitenrichtlinienattribute

Innerhalb einer Seitenanweisung können viele Attribute deklariert werden:

  • autoFlush _ <% @ page autoFlush = "false"%> _ **

autoFlush steuert die Pufferausgabe und löscht sie, wenn die Puffergröße erreicht ist. Der Standardwert ist true .

  • buffer _ <% @ page buffer = ”19kb”%> _ **

buffer legt die Größe des von unserer JSP-Seite verwendeten Puffers fest. Der Standardwert ist 8kb.

  • errorPage _ <% @ page errorPage = "errHandler.jsp"%> _ + **

errorPage gibt eine JSP-Seite als Fehlerseite an.

  • erweitert _ <% @ page extended = ”org.apache.jasper.runtime.HttpJspBase”%> _ **

extends gibt die Oberklasse des entsprechenden Servlet-Codes an.

  • info ** <% @ page info = ”Dies ist meine JSP!”%>

info wird verwendet, um eine textbasierte Beschreibung für die JSP festzulegen.

  • isELIgnored ** <% @ page isELIgnored = "true"%>

isELIgnored gibt an, ob die Seite Expression Language (EL) in JSP ignoriert. EL ermöglicht es der Präsentationsschicht, mit verwalteten Java-Beans zu kommunizieren, und zwar unter Verwendung der $ \ {…​} -Syntax, und obwohl wir hier nicht auf die Kleinigkeiten von EL eingehen, gibt es unten einige Beispiele, die ausreichen um unsere Beispiel-JSP-App zu erstellen! Der Standardwert für isELIgnored ist false .

  • isErrorPage ** <% @ page isErrorPage = "true"%>

isErrorPage gibt an, ob eine Seite eine Fehlerseite ist oder nicht. Wir müssen eine Fehlerseite angeben, wenn wir einen Fehlerbehandler für unsere Seite in der Anwendung erstellen.

  • isThreadSafe ** <% @ page isThreadSafe = "false"%>

isThreadSafe hat einen Standardwert von true . isThreadSafe legt fest, ob die JSP Servlet-Multithreading verwenden kann. Im Allgemeinen möchten Sie diese Funktion niemals deaktivieren.

  • language ** <% @ page language = "java"%>

language bestimmt, welche Skriptsprache in der JSP verwendet werden soll. Der Standardwert ist Java .

  • session ** <% @ page session = ”Wert”%>

session legt fest, ob die HTTP-Sitzung beibehalten werden soll. Der Standardwert ist true und akzeptiert Werte von true oder false .

  • trimDirectiveWhitespaces ** <% @ page trimDirectiveWhitespaces = "true"%>

trimDirectiveWhitespaces entfernt Leerzeichen auf der JSP-Seite und komprimiert den Code zur Kompilierzeit in einen kompakteren Block. Wenn Sie diesen Wert auf true setzen, kann dies dazu beitragen, die Größe des JSP-Codes zu reduzieren. Der Standardwert ist false .

3. Drei Beispiele

Nachdem wir nun die Konzepte für JSP zentral überprüft haben, wenden wir diese Konzepte auf einige grundlegende Beispiele an, die Ihnen helfen, Ihr erstes JSP-Servlet in Betrieb zu nehmen!

Es gibt drei Hauptmethoden, um Java in eine .jsp-Datei einzufügen. Wir werden jede dieser Möglichkeiten unter Verwendung nativer Funktionen in Java 8 und Java EE untersuchen.

Zuerst werden wir unsere Markup-Server-Seite so darstellen, dass sie clientseitig angezeigt wird.

Zweitens wird beschrieben, wie Sie Java-Code direkt in unsere JSP-Datei einfügen, unabhängig von den request - und response -Objekten von javax.servlet.http .

Drittens wird gezeigt, wie ein HttpServletRequest an ein bestimmtes .jsp weitergeleitet und serverseitig verarbeitetes Java daran gebunden wird.

Lassen Sie uns unser Projekt in Eclipse mit dem Typ File/New/Project/Web/Dynamic/ einrichten, der in Tomcat gehostet wird!

Sie sollten nach dem Erstellen des Projekts Folgendes sehen: 

|-project
  |- WebContent
    |- META-INF
      |- MANIFEST.MF
    |- WEB-INF
      |- lib
      |- src

Wir werden der Anwendungsstruktur einige Dateien hinzufügen, so dass wir am Ende Folgendes erhalten: 

|-project
  |- WebContent
    |- META-INF
      |- MANIFEST.MF
    |- WEB-INF
      |-lib
      ** -web.xml
        |- ExampleTree.jsp
        |- ExampleTwo.jsp
        ** - index.jsp
      |- src
        |- com
          |- baeldung
            ** - ExampleOne.java
            ** - ExampleThree.java

Lassen Sie uns index.jsp einrichten, das beim Zugriff auf den URL-Kontext in Tomcat 8 angezeigt wird: 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>JSP Examples</title>
    </head>
    <body>
        <h1>Simple JSP Examples</h1>
        <p>Invoke HTML rendered by Servlet: <a href="ExampleOne" target="__blank">here</a></p>
        <p>Java in static page: <a href="ExampleTwo.jsp" target="__blank">here</a></p>
        <p>Java injected by Servlet: <a href="ExampleThree?message=hello!" target="__blank">here</a></p>
    </body>
</html>

Es gibt drei a , von denen jedes mit einem der Beispiele verbunden ist, die wir in den Abschnitten 4.1 bis 4.4 durchlaufen.

Wir müssen auch sicherstellen, dass wir web.xml eingerichtet haben: 

<welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<servlet>
    <servlet-name>ExampleOne</servlet-name>
    <servlet-class>com.baeldung.ExampleOne</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>ExampleOne</servlet-name>
    <url-pattern>/ExampleOne</url-pattern>
</servlet-mapping>

Ein wichtiger Hinweis hier ist, wie Sie jedes unserer Servlets einem bestimmten Servlet-Mapping richtig zuordnen. Dadurch wird jedem Servlet ein bestimmter Endpunkt zugeordnet, an dem es konsumiert werden kann. Jetzt gehen wir alle anderen Dateien durch!

3.1. In Servlet gerendertes HTML

In diesem Beispiel überspringen wir tatsächlich die Erstellung einer .jsp-Datei!

Stattdessen erstellen wir eine Zeichenfolgendarstellung unseres Markups und schreiben diese dann mit PrintWriter in die GET-Antwort, nachdem ExampleOne Servlet eine GET-Anforderung erhält: 

public class ExampleOne extends HttpServlet {
  @Override
  protected void doGet(HttpServletRequest request,
    HttpServletResponse response) throws ServletException, IOException {
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();
      out.println(
    "<!DOCTYPE html><html>" +
    "<head>" +
    "<meta charset=\"UTF-8\"/>" +
    "<title>HTML Rendered by Servlet</title>" +
    "</head>" +
    "<body>" +
    "<h1>HTML Rendered by Servlet</h1></br>" +
    "<p>This page was rendered by the ExampleOne Servlet!</p>" +
    "</body>" +
    "</html>"
     );
   }
}

Was wir hier tun, ist das direkte Einfügen unserer Markups durch die Bearbeitung der Servlet-Anforderungen. Anstelle eines JSP-Tags generieren wir unseren HTML-Code zusammen mit allen Java-spezifischen Daten, die rein serverseitig ohne statische JSP eingefügt werden müssen!

Zuvor haben wir das out -Objekt überprüft, das eine Funktion von JspWriter ist.

Oben habe ich stattdessen das PrintWriter -Objekt verwendet, das direkt in das response -Objekt schreibt.

JspWriter puffert tatsächlich den String, der in den Speicher geschrieben werden soll, der dann in die response -Objekte geschrieben wird, nachdem der Puffer im Speicher gelöscht wurde.

PrintWriter ist bereits an das response -Objekt angehängt. Aus diesen Gründen habe ich es vorgezogen, direkt in das response -Objekt in den Beispielen oben und unten zu schreiben.

3.2. Java in einem statischen JSP-Inhalt

Hier erstellen wir eine JSP-Datei mit dem Namen ExampleTwo.jsp mit einem JSP-Tag. Wie oben gezeigt, kann Java direkt in unser Markup eingefügt werden. Hier drucken wir zufällig ein Element eines String[] : 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
    <head>
        <title>Java in Static Page Example</title>
    </head>
    <body>
        <h1>Java in Static Page Example</h1>
        <%
              String[]arr = {"What's up?", "Hello", "It's a nice day today!"};
          String greetings = arr[(int)(Math.random() **  arr.length)];
            %>
        <p><%= greetings %></p>
    </body>
</html>

Oben sehen Sie diese Variablendeklaration in JSP-Tag-Objekten:

type variableName und eine initialization genau wie normales Java.

Ich habe das obige Beispiel eingefügt, um zu zeigen, wie Sie Java zu einer statischen Seite hinzufügen können, ohne auf ein bestimmtes Servlet zurückzugreifen. Hier wird Java einfach zu einer Seite hinzugefügt, und der JSP-Lebenszyklus erledigt den Rest.

3.3. JSP mit Weiterleitung

Nun zu unserem letzten und ausführlichsten Beispiel! Hier verwenden wir die Annotation @ WebServlet für ExampleThree, wodurch Servlet-Zuordnungen in server.xml nicht erforderlich sind. 

@WebServlet(
  name = "ExampleThree",
  description = "JSP Servlet With Annotations",
  urlPatterns = {"/ExampleThree"}
)
public class ExampleThree extends HttpServlet {
  @Override
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
      String message = request.getParameter("message");
      request.setAttribute("text", message);
      request.getRequestDispatcher("/ExampleThree.jsp").forward(request, response);
   }
}

ExampleThree übernimmt einen als message übergebenen URL-Parameter, bindet diesen Parameter an das request -Objekt und leitet dieses request -Objekt anschließend an ExampleThree.jsp weiter.

So haben wir nicht nur ein wirklich dynamisches Web-Erlebnis, sondern auch eine Anwendung mit mehreren .jsp-Dateien.

getRequestDispatcher (). forward () ist eine einfache Methode, um sicherzustellen, dass die richtige .jsp-Seite gerendert wird.

Alle Daten, die an das request -Objekt gebunden sind, werden dann (die .jsp-Datei) angezeigt. So gehen wir mit dem letzten Teil um: 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
    <head>
        <title>Java Binding Example</title>
    </head>
    <body>
        <h1>Bound Value</h1>
        <p>You said: ${text}</p>
    </body>
</html>

Beachten Sie das JSP-Tag, das oben in ExampleThree.jsp hinzugefügt wurde. Sie werden feststellen, dass ich die JSP-Tags hier gewechselt habe. Ich benutze die Ausdruckssprache (die ich bereits erwähnt habe), um unseren Set-Parameter (der an $ \ {text} gebunden ist) wiederzugeben.

3.4. Versuch es!

Jetzt exportieren wir unsere Anwendung in eine .war-Datei, die in Tomcat 8 gestartet und gehostet werden kann! Finden Sie Ihren server.xml und wir aktualisieren unseren Context auf: 

<Context path="/spring-mvc-xml" docBase="${catalina.home}/webapps/spring-mvc-xml">
</Context>

Damit können wir auf unsere Servlets und JSPs unter localhost zugreifen: 8080/spring-mvc-xml/jsp/index.jsp ! Holen Sie sich eine Arbeitskopie bei:

GitHub .

Glückwunsch!

4. Fazit

Wir haben ziemlich viel Boden hinter uns gebracht. Wir haben gelernt, was JavaServer Pages sind, was sie eingeführt haben, wie sie erstellt werden, wie sie erstellt werden, und schließlich einige verschiedene Möglichkeiten, sie zu implementieren!

Damit ist die Einführung in JSP abgeschlossen! Sei gut und Code weiter!

Related