Was ist JSP? Einführung in JavaServer Pages

JavaServer Pages (JSP) ist eine Java-Standardtechnologie, mit der Sie dynamische, datengesteuerte Seiten für Ihre Java-Webanwendungen schreiben können. JSP basiert auf der Java-Servlet-Spezifikation. Die beiden Technologien arbeiten normalerweise zusammen, insbesondere in älteren Java-Webanwendungen. Aus Sicht der Codierung besteht der offensichtlichste Unterschied darin, dass Sie mit Servlets Java-Code schreiben und dann clientseitiges Markup (wie HTML) in diesen Code einbetten, während Sie mit JSP mit dem clientseitigen Skript oder Markup beginnen und dann einbetten JSP-Tags, um Ihre Seite mit dem Java-Backend zu verbinden.

JSP ist auch eng mit JSF (JavaServer Faces) verwandt, einer Java-Spezifikation zum Erstellen von MVC-Webanwendungen (Model-View-Controller). JSP ist eine relativ einfachere und ältere Technologie als JSF, der Standard für Java-Webframeworks wie Eclipse Mojarra, MyFaces und PrimeFaces. Während es nicht ungewöhnlich ist, dass JSP als Frontend für ältere JSF-Anwendungen verwendet wird, ist Facelets die bevorzugte Ansichtstechnologie für moderne JSF-Implementierungen.

Während JSP möglicherweise nicht Ihre erste Wahl für die Erstellung dynamischer Webseiten ist, handelt es sich um eine Java-Kerntechnologie. JSP-Seiten sind relativ schnell und einfach zu erstellen und interagieren nahtlos mit Java-Servlets in einem Servlet-Container wie Tomcat. Sie werden in älteren Java-Webanwendungen auf JSP stoßen und von Zeit zu Zeit nützlich sein, um einfache, dynamische Java-Webseiten zu erstellen. Als Java-Entwickler sollten Sie zumindest mit JSP vertraut sein.

Dieser Artikel bietet eine kurze Einführung in JavaServer Pages, einschließlich der JSP Standard Tag Library (JSTL). Beispiele zeigen, wie Sie eine einfache HTML-Seite schreiben, JSP-Tags einbetten, um eine Verbindung zu einem Java-Servlet herzustellen, und die Seite in einem Servlet-Container ausführen.

Weitere Informationen zu Java-Servlets und JavaServer-Gesichtern finden Sie in den vorherigen Artikeln dieser Reihe.

JSP in Jakarta EE

Nach der Veröffentlichung von Java EE 8 hat Oracle die Verwaltung von Java Enterprise Edition (Java EE) an die Eclipse Foundation übertragen. In Zukunft wurde die Java-Unternehmensplattform in Jakarta EE umbenannt. Neben den Java Servlet- und JSF-Spezifikationen ist JSP eine der Java-Webtechnologien, die für die fortlaufende Unterstützung und Aktualisierung in Jakarta EE enthalten sind.

JSP-Seiten schreiben

Eine einfache JSP-Seite (.jsp) besteht aus HTML-Markup, das in JSP-Tags eingebettet ist. Wenn die Datei auf dem Server verarbeitet wird, wird der HTML-Code als Anwendungsansicht, als Webseite, gerendert. Die eingebetteten JSP-Tags werden zum Aufrufen von serverseitigem Code und Daten verwendet. Das Diagramm in Abbildung 1 zeigt die Interaktion zwischen HTML, JSP und dem Webanwendungsserver.

Matthew Tyson

Listing 1 zeigt eine einfache JSP-Seite.

Listing 1. Eine einfache JSP-Seite

${2 * 2} should equal 4

In Listing 1 sehen Sie einen HTML-Block, der einen JSP-Ausdruck enthält. Dies ist eine Anweisung an den Java-Server, die mit Expression Language (EL) geschrieben wurde. Im Ausdruck " ${2 * 2}" ist " ${}" die JSP-Syntax zum Interpolieren von Code in HTML. Bei der Ausführung gibt die JSP die Ergebnisse der Ausführung aller im Ausdruck enthaltenen Elemente aus. In diesem Fall ist die Ausgabe die Nummer 4.

JSP im Servlet-Container

JSP-Seiten müssen in einem Java-Servlet-Container bereitgestellt werden. Um eine Java-Webanwendung basierend auf JSP und Servlets bereitzustellen, packen Sie Ihre .jsp-Dateien, Java-Code und Anwendungsmetadaten in eine .war-Datei, eine einfache .zip-Datei mit einer herkömmlichen Struktur für Webanwendungen.

Sobald Sie die JSP in Ihren Servlet-Container geladen haben, wird sie zu einem Servlet kompiliert. JSPs und Java-Servlets weisen ähnliche Merkmale auf, einschließlich der Möglichkeit, auf Anforderungsobjekte zuzugreifen und darauf zu antworten. Apache Tomcat 9x ist die Referenzimplementierung für die Servlet 4.0- und JSP 2.3-Spezifikationen. (Beachten Sie, dass Aktualisierungen zwischen JSP 2.2 und 2.3 relativ geringfügig sind.)

Servlet-Container vs. Anwendungsserver

In der Java-Welt ähnelt ein Servlet-Container , auch als Webserver bezeichnet, einer Lite-Version (Bierversion) eines Anwendungsservers. Ein Servlet-Container verarbeitet Anforderungs- und Antwortinteraktionen und ermöglicht die Interaktion dieser Interaktionen mit einer Teilmenge der Java-Unternehmensfunktionen für Webanwendungen. Ein Java-Anwendungsserver enthält den Servlet-Container als Teil des vollständigen Java-Enterprise-Stacks, einschließlich EJB, JPA, JMS und mehr.

Beispiel-App für JSP

Wir verwenden eine Beispielanwendung in Tomcat, um Ihnen den Einstieg in JavaServer Pages zu erleichtern. Wenn Sie Tomcat noch nicht installiert haben, navigieren Sie zur Tomcat-Downloadseite und wählen Sie die Tomcat-Installation für Ihr Betriebssystem aus. Zum jetzigen Zeitpunkt ist Tomcat 9 die aktuelle Version, die mit Servlet 4.0 und JSP 2.3 kompatibel ist.

Sie können Tomcat als Windows-Dienst installieren oder über die Befehlszeile mit /bin/catalina.sh startoder ausführen /bin/catalina.bat. Starten Sie in beiden Fällen localhost:8080Tomcat und rufen Sie die in Abbildung 2 gezeigte Tomcat-Begrüßungsseite auf.

Matthew Tyson

Implizite Objekte in Tomcat

Klicken Sie auf der Tomcat-Begrüßungsseite auf den Link Beispiele und dann auf JSP-Beispiele .

Öffnen Sie als Nächstes die Webanwendung Implizite Objekte ausführen . Abbildung 3 zeigt die Ausgabe für diese Anwendung. Nehmen Sie sich eine Minute Zeit, um diese Ausgabe zu studieren.

Matthew Tyson

Parameter anfordern

Implicit objects are built-in objects accessible via a JSP page. As a web page developer, you will use these objects to create access to things like request parameters, which are the data sent over from the browser when issuing an HTTP request. Consider the browser URL for Implicit Objects:

 //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=bar 

The param is ?foo=bar, and you can see it reflected in the output on the web page, where the table shows "EL Expression" and the value is "bar." To test this out, change the URL to //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=zork, hit Enter, and you'll see the change reflected in the output.

This example is a very simple introduction to using JSP tags to access server-side request parameters. In this case, the JSP page uses the built-in (implicit) object called param to access the web application's request parameters. The param object is available inside the JSP expression syntax that you saw in Listing 1.

In that example, we used an expression to do some math: ${2 * 2}, which output 4.

In this example, the expression is used to access an object and a field on that object: ${param.foo}.

JSP in a web application

On the Implicit Objects page, click the back arrow, followed by the Source link. This will lead you to the JSP code for the Implicit Objects web app, which is shown in Listing 2.

Listing 2. JSP code for the Implicit Objects web app

     JSP 2.0 Expression Language - Implicit Objects   
    
This example illustrates some of the implicit objects available in the Expression Language. The following implicit objects are available (not all illustrated here):
  • pageContext - the PageContext object
  • pageScope - a Map that maps page-scoped attribute names to their values
  • requestScope - a Map that maps request-scoped attribute names to their values
  • sessionScope - a Map that maps session-scoped attribute names to their values
  • applicationScope - a Map that maps application-scoped attribute names to their values
  • param - a Map that maps parameter names to a single String parameter value
  • paramValues - a Map that maps parameter names to a String[] of all values for that parameter
  • header - a Map that maps header names to a single String header value
  • headerValues - a Map that maps header names to a String[] of all values for that header
  • initParam - a Map that maps context initialization parameter names to their String parameter value
  • cookie - a Map that maps cookie names to a single Cookie object.
Change Parameter foo =

EL Expression Result
\${param.foo} ${fn:escapeXml(param["foo"])}
\${param["foo"]} ${fn:escapeXml(param["foo"])}
\${header["host"]} ${fn:escapeXml(header["host"])}
\${header["accept"]} ${fn:escapeXml(header["accept"])}
\${header["user-agent"]} ${fn:escapeXml(header["user-agent"])}

JSP functions

If you're familiar with HTML, then Listing 2 should look pretty familiar. You have the expected HTML elements, followed by the ${ } JSP expression syntax introduced in Listing 1. But notice the value for param.foo: ${fn:escapeXml(param["foo"])} . The "fn:escapeXML()" is a JSP function.

A JSP function encapsulates a chunk of reusable functionality. In this case, the functionality is to escape XML. JSP offers a variety of functions, and you can also create functions yourself. To use a function, you import its library into your JSP page, then call the function.

In Listing 2, the escapeXML function is included with the line:

The syntax is pretty clear: it imports the required functions and assigns them a prefix (in this case "fn") that can be used in all following expressions.

The JSP Standard Tag Library (JSTL)

The import line in Listing 2 calls taglib, which is short for tag library, or (in this case) JSP Standard Tag Library (JSTL). Tag libraries define reusable bits of functionality for JSP. JSTL is the standard tag library, containing a collection of taglibs that ship with every servlet and JSP implementation, including Tomcat.

The "functions" library is just one of the taglibs included with JSTL. Another common taglib is the core library, which you import by calling:

Like "fn", the "c" designation is conventional, and you will see it across most JSP pages.

Securing JSP pages

An example tag from the core library is


    

which outputs the tag with the XML already escaped. This function is important because outputting content directly to a web page via ${variable} opens the door to script injection attacks. This simple function is used to protect web pages from such attacks.

The core library also includes various tags for iteration and flow control (like IF/ELSE handling).

JSTL tag classifications

There are five sets of tags included in JSTL, each designed for a specific area of web application functionality:

  • JSTL core: Dealing with logic and execution flow; conventional tag: "c"
  • JSTL formatting: Dealing with formatting (like dates) and internationalization; conventional tag: "fmt".
  • JSTL SQL: Dealing with querying SQL databases (this is usually discouraged in the view layer); conventional tag: "sql".
  • JSTL XML: Dealing with working with XML documents; conventional tag: "x".
  • JSTL functions: Dealing primarily with String manipulations; conventional tag: "fn".

Calling taglibs in JSP pages

Now that you've got a handle on JSP basics, let's make a change to the example application. To start, locate the Implicit Object app in your Tomcat installation. The path is: apache-tomcat-8.5.33/webapps/examples/jsp/jsp2/el.

Open this file and locate the functions include:

just below this line, add a new line:

Hit Return and add another new line:

Now reload the page at //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=bar.

Sie sollten Ihre Updates in der Ausgabe sehen.