Co to jest JSP? Wprowadzenie do stron JavaServer

JavaServer Pages (JSP) to standardowa technologia Java, która umożliwia tworzenie dynamicznych, opartych na danych stron dla aplikacji internetowych Java. JSP jest oparty na specyfikacji Java Servlet. Te dwie technologie zazwyczaj współpracują ze sobą, szczególnie w starszych aplikacjach internetowych Java. Z punktu widzenia kodowania, najbardziej oczywistą różnicą między nimi jest to, że w przypadku serwletów piszesz kod Java, a następnie osadzasz znaczniki po stronie klienta (takie jak HTML) w tym kodzie, podczas gdy w przypadku JSP zaczynasz od skryptu lub znacznika po stronie klienta, a następnie osadzasz Tagi JSP, aby połączyć stronę z zapleczem Java.

JSP jest również ściśle powiązany z JSF (JavaServer Faces), specyfikacją języka Java do tworzenia aplikacji internetowych MVC (model-view-controller). JSP to stosunkowo prostsza i starsza technologia niż JSF, która jest standardem dla platform internetowych Java, takich jak Eclipse Mojarra, MyFaces i PrimeFaces. Chociaż nie jest rzadkością, że JSP jest używane jako nakładka na starsze aplikacje JSF, Facelets jest preferowaną technologią widoku dla nowoczesnych implementacji JSF.

Chociaż JSP może nie być pierwszym wyborem do tworzenia dynamicznych stron internetowych, jest to podstawowa technologia internetowa Java. Strony JSP są stosunkowo szybkie i łatwe do zbudowania oraz bezproblemowo współdziałają z serwletami Java w kontenerze serwletów, takim jak Tomcat. JSP można spotkać w starszych aplikacjach internetowych Java i od czasu do czasu może się przydać do tworzenia prostych, dynamicznych stron internetowych w języku Java. Jako programista Java powinieneś przynajmniej znać JSP.

Ten artykuł będzie krótkim wprowadzeniem do stron JavaServer, w tym do biblioteki JSP Standard Tag Library (JSTL). Przykłady pokazują, jak napisać prostą stronę HTML, osadzić znaczniki JSP w celu połączenia z serwletem Java i uruchomić stronę w kontenerze serwletów.

Zobacz poprzednie artykuły z tej serii, aby dowiedzieć się więcej o serwletach Java i twarzach JavaServer.

JSP w Dżakarcie EE

Po wydaniu Java EE 8 firma Oracle przeniosła zarządzanie Java Enterprise Edition (Java EE) do Eclipse Foundation. W przyszłości platforma korporacyjna Java została przemianowana na Jakarta EE. Wraz ze specyfikacjami Java Servlet i JSF, JSP jest jedną z technologii internetowych Java włączonych do stałego wsparcia i aktualizacji w Dżakarcie EE.

Pisanie stron JSP

Prosta strona JSP (.jsp) składa się ze znaczników HTML osadzonych w znacznikach JSP. Gdy plik jest przetwarzany na serwerze, kod HTML jest renderowany jako widok aplikacji, strona internetowa. Osadzone znaczniki JSP będą używane do wywoływania kodu i danych po stronie serwera. Diagram na rysunku 1 przedstawia interakcję między HTML, JSP i serwerem aplikacji WWW.

Matthew Tyson

Listing 1 przedstawia prostą stronę JSP.

Listing 1. Prosta strona JSP

${2 * 2} should equal 4

Na liście 1 zobaczysz blok kodu HTML zawierający wyrażenie JSP , które jest instrukcją dla serwera Java napisaną przy użyciu języka Expression Language (EL). W wyrażeniu „ ${2 * 2}”, „ ${}” to składnia JSP służąca do interpolacji kodu do HTML. Po wykonaniu strona JSP wyświetli wyniki wykonania tego, co znajduje się wewnątrz wyrażenia. W takim przypadku wynikiem będzie liczba 4.

JSP w kontenerze serwletów

Strony JSP należy wdrażać w kontenerze serwletów Java. Aby wdrożyć aplikację internetową Java opartą na JSP i serwletach, spakujesz swoje pliki .jsp, kod Java i metadane aplikacji w pliku .war, który jest prostym plikiem .zip o typowej strukturze dla aplikacji internetowych.

Po załadowaniu strony JSP do kontenera serwletów zostanie ona skompilowana do postaci serwletu. Strony JSP i serwlety Java mają podobne cechy, w tym możliwość uzyskiwania dostępu do obiektów żądań i odpowiadania na nie. Apache Tomcat 9x jest implementacją referencyjną dla specyfikacji Servlet 4.0 i JSP 2.3. (Należy pamiętać, że aktualizacje między JSP 2.2 i 2.3 są stosunkowo niewielkie).

Kontener serwletów a serwer aplikacji

W świecie Java kontener serwletów , znany również jako serwer WWW, jest jak lite (piwo) wersja serwera aplikacji. Kontener serwletów obsługuje interakcje typu żądanie i odpowiedź i umożliwia tym interakcjom łączenie się z podzbiorem funkcji przedsiębiorstwa Java w aplikacjach internetowych. Serwer aplikacji Java zawiera kontener serwletów jako część pełnego stosu Java Enterprise, obejmującego EJB, JPA, JMS i inne.

Przykładowa aplikacja dla JSP

Użyjemy przykładowej aplikacji w Tomcat, aby rozpocząć pracę z JavaServer Pages. Jeśli nie masz jeszcze zainstalowanego Tomcata, przejdź do strony pobierania Tomcat i wybierz instalację Tomcat dla swojego systemu operacyjnego. W chwili pisania tego tekstu Tomcat 9 jest aktualną wersją, zgodną z Servlet 4.0 i JSP 2.3.

Możesz zainstalować Tomcat jako usługę systemu Windows lub uruchomić go z wiersza poleceń za pomocą /bin/catalina.sh startlub /bin/catalina.bat. Tak czy inaczej, uruchom Tomcat, a następnie przejdź do localhost:8080strony powitalnej Tomcat pokazanej na rysunku 2.

Matthew Tyson

Niejawne obiekty w Tomcat

Na stronie powitalnej Tomcat kliknij łącze Przykłady , a następnie kliknij opcję Przykłady JSP .

Następnie otwórz aplikację internetową Implicit Objects Execute . Rysunek 3 przedstawia dane wyjściowe dla tej aplikacji. Poświęć chwilę na przestudiowanie tego wyniku.

Matthew Tyson

Poproś o parametry

Obiekty niejawne to obiekty wbudowane, do których można uzyskać dostęp za pośrednictwem strony JSP. Jako twórca stron internetowych będziesz używać tych obiektów do tworzenia dostępu do takich rzeczy, jak parametry żądań , czyli dane przesyłane z przeglądarki podczas wysyłania żądania HTTP. Rozważ adres URL przeglądarki dla obiektów niejawnych:

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

Parametr to ?foo=bari możesz zobaczyć to odzwierciedlone w danych wyjściowych na stronie internetowej, gdzie tabela pokazuje „Wyrażenie EL”, a wartość to „bar”. Aby to przetestować, zmień adres URL na //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=zork , naciśnij Enter , a zobaczysz zmianę odzwierciedloną w wynikach.

Ten przykład jest bardzo prostym wprowadzeniem do używania znaczników JSP w celu uzyskania dostępu do parametrów żądania po stronie serwera. W tym przypadku strona JSP używa wbudowanego (niejawnego) obiektu wywoływanego w paramcelu uzyskania dostępu do parametrów żądania aplikacji WWW. paramObiekt jest dostępny wewnątrz składni wyrażeń JSP, które widzieliśmy w Listingu 1.

W tym przykładzie użyliśmy wyrażenia, aby wykonać obliczenia matematyczne:, ${2 * 2}które wyjście 4.

W tym przykładzie wyrażenie jest używane do dostępu do obiektu i pole tego obiektu ${param.foo}.

JSP w aplikacji internetowej

Na stronie Niejawne obiekty kliknij strzałkę wstecz, a następnie łącze Źródło . Spowoduje to przejście do kodu JSP dla aplikacji internetowej Implicit Objects, który jest pokazany na liście 2.

Listing 2. Kod JSP dla aplikacji WWW Implicit Objects

     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.

Powinieneś zobaczyć swoje aktualizacje odzwierciedlone w wynikach.