R18_05.PDF

W niniejszym rozdziale:

• Wykorzystywanie JavaServer Pages

• Zasady działania

• Wyrażenia i deklaracje

• Instrukcje

• JSP i JavaBeans

• Dołączenia i przekazania

• Aplikacja „Narzędzia”

• Biblioteki własnych znaczników

Rozdział 18.

JavaServer Pages

JavaServer Pages, znana powszechnie jako JSP, to technologia utworzona przez Sun Microsystems, blisko

związana z serwletami. JSP była jedną z pierwszych prób utworzenia ogólno dostępnego systemu tworzenia

zawartości opartego na serwletach. Osoby od dawna zajmujące się serwletami mogą pamiętać, że JSP została

przedstawiona po raz pierwszy na wiosnę 1998 — na tyle wcześnie, by pierwsze wydanie niniejszej książki

mogło zawierać krótki samouczek testowej wersji 0.91 JSP. Oczywiście JSP zmieniła się bardzo od tego czasu.

W tym rozdziale opisana zostanie JSP 1.1, opierająca się na Servlet API 2.2.

Podobnie jak w przypadku serwletów, Sun udostępnia specyfikację JSP (utworzoną przez grupę ekspertów

składającą się z niezależnych producentów i osób), po czym inni producenci konkurują w swoich

implementacjach tego standardu. Różnica pomiędzy JSP i innymi technologiami opartymi bezpośrednio na

serwletach polega na tym, że JSP jest specyfikacją, nie produktem i wymaga wsparcia ze strony serwera.

Większość producentów kontenerów serwletów zapewnia tę obsługę, między innymi Tomcat, w którym

mechanizm JSP nosi nazwę Jasper. JSP jest podstawowym składnikiem Java 2, Enterprise Edition (J2EE).

Jednym z głoszonych celów JSP (cytat ze specyfikacji) jest „umożliwienie oddzielenia zawartości dynamicznej i

statycznej”. Innym celem jest „umożliwienie tworzenia stron WWW, które zawierają elementy dynamiczne w

łatwy sposób, ale z maksymalną mocą i elastycznością”. JSP spełnia dobrze oba te zadania. Jednak, zgodnie z

kwestią „maksymalnej mocy” przy tworzeniu JSP, autor strony JSP zawsze posiada całkowitą kontrolę nad

systemem, i w związku z tym można powiedzieć, że JSP umożliwia oddzielenie zawartości od grafiki, ale nie

wymusza jej ani nie narzuca , jak to się dzieje w przypadku jej alternatyw. Jest to zjawisko podobne do tego, że

C++ umożliwia projektowanie obiektowe, ale nie promuje tego doskonałego sposobu tak mocno, jak to się

dzieje w przypadku Javy.

JSP jest również technologią bardzo elastyczną, i istnieje wiele sposobów jej wykorzystania. Jednym z nich jest

„skrótowy” sposób tworzenia serwletów — programista serwletów, dobrze znający Javę, może umieścić kod

Javy bezpośrednio na stronie JSP, zamiast pisać kompletny serwlet — co daje ułatwienia takie jak

wyeliminowanie wywołań wyj.println() , umożliwienie bezpośredniego wskazywania na pliki JSP i

wykorzystanie własności autokompilacji JSP, Jednak poprzez tworzenie strony JSP zamiast serwletu

programista traci pełny kontakt z kodem oraz możliwość kontroli prawdziwego środowiska uruchomieniowego

(np. rozszerzanie com.oreilly.servlet.CacheHttpServlet lub tworzenie wyniku binarnego

(obrazka)). Z tego powodu najlepiej jest pozostawić prawdziwe kodowanie zwykłym serwletom, a strony JSP

wykorzystać przede wszystkim do tworzenia logiki prezentacyjnej.

Nawet podczas zastosowania stron JSP jedynie do logiki prezentacyjnej, można je wykorzystać na wiele

sposobów. Jednym z nich jest użycie komponentów JavaBeans osadzonych na stronie. Innym tworzenie

własnych znaczników wyglądających jak HTML, ale będących tak naprawdę punktami zaczepienia do

wspomagającego kodu Javy. Jeszcze innym jest wysyłanie wszystkich żądań do serwletu, który wykonuje logikę

biznesową, po czym przesyła żądanie do JSP tworzącej stronę przy pomocy mechanizmu

RequestDispatcher . Technika ta jest często nazywana architekturą Model 2 , która to nazwa pochodzi od

specyfikacji JSP 0.92. Istnieją również inne mechanizmy noszące dziwne nazwy takie jak Model 1½ , Model 2½ ,

czy Model 2+1 . Niemożliwe jest wskazanie najlepszej techniki stosowania JSP.

W niniejszym rozdziale opisane zostaną różne sposoby wykorzystania JSP, począwszy od „skrótu do serwletu” a

skończywszy na własnych znacznikach. Opis będzie krótki, ale powinien dostarczyć podstaw do porównania JSP

z jej alternatywami. Nie zostaną opisane wszystkie opcje architektury, a zamiast tego nacisk zostanie położony

na szczegóły techniczne. Opcje architektury i większa ilość informacji na temat JavaServer Pages jest dostępna

na stronie głównej JSP pod adresem http://java.sun.com/products/jsp („ściąga” składni jest dostępna pod

adresem http://java.sun.com/products/jsp/syntax.pdf ) oraz w książce „JavaServer Pages” autorstwa Hansa

Bergstena (O'Reilly).

Wykorzystywanie JavaServer Pages

Najbardziej podstawową funkcją JSP jest umożliwienie bezpośredniego umieszczenia kodu serwletu w

statycznym pliku HTML 1 . Każdy blok kodu serwletu (nazywany skryptletem ) jest ograniczany otwierającym

znacznikiem <% i zamykającym %> . Wykorzystywanie skryptletu ułatwia kilka predefiniowanych zmiennych.

Sześć najpopularniejszych to:

HttpServletRequest request

Żądanie serwletu.

HttpServletResponse response

Odpowiedź serwletu.

javax.servlet.jsp.JspWriter out

Urządzenie wyświetlające, stosowane podobnie jak PrintWriter , posiadające jednak inną

charakterystykę buforowania.

HttpSession session

Sesja użytkownika.

ServletContext application

Aplikacja WWW.

javax.servlet.jsp.PageContext pageContext

Obiekt wykorzystywany przede wszystkim do rozdzielania implementacji serwera, ale często

wykorzystywany bezpośrednio do współdzielenia zmiennych pomiędzy stronami JSP i wspomagającymi

elementami i znacznikami.

1 Przed rozpoczęciem opisu warto zauważyć, że umieszczanie kodu Javy na stronie JSP jest uważane za działanie w złym

stylu. Uważane za lepsze zaawansowane zastosowania JSP zostaną opisane w dalszej części rozdziału.

Można dostrzec, że klasy JSP umieszczone są w pakiecie javax.servlet.jsp .

Przykład 18.1 przedstawia prostą stronę JSP wyświetlającą spersonalizowane „Witaj” przy pomocy

predefiniowanych zmiennych request i out . Jeżeli posiada się serwer obsługujący JavaServer Pages i pragnie

się przetestować tę stronę, należy umieścić plik w podkatalogu katalogu macierzystego dokumentów serwera i

zapamiętać ją z rozszerzeniem . jsp . Zakładając, że strona została zapamiętana jako witaj1.jsp , dostęp do niej

można uzyskać pod URL-em http://serwer:port/witaj1.jsp lub, jeżeli plik zostanie umieszczony w ścieżce

kontekstowej jsp , URL będzie wynosił http://serwer:port/jsp/witaj1.jsp .

Przykład 18.1.

Powitanie przy pomocy JSP

<HTML>

<HEAD><TITLE>Witaj</TITLE></HEAD>

<BODY>

<H1>

if (request.getParameter("nazwa") == null) {

out.println("Witaj świecie");

}

else {

out.println("Witaj, " + request.getParameter("nazwa"));

}

</H1>

</BODY></HTML>

Przykładowy wynik uruchomienia powyższego programu przedstawiony jest na rysunku 18.1.

Rysunek 18.1.

Powitanie przy pomocy

JavaServer Pages

Zasady działania

Jak działa JSP? Poza obszarem widoczności serwer automatycznie tworzy, kompiluje, ładuje i uruchamia

specjalny serwlet tworzący zawartość strony, jak przedstawiono na rysunku 18.2. Można myśleć o tym

specjalnym serwlecie jak o serwlecie roboczym, działającym w tle. Statyczne części strony HTML są tworzone

przez serwlet roboczy przy pomocy ekwiwalentów wywołań wyj.println() , podczas gdy części

dynamiczne są dołączane bezpośrednio. Na przykład, serwlet przedstawiony w przykładzie 18.2 mógłby być

serwletem roboczym dla witaj1.jsp działającym na serwerze Tomcat 2 .

Rysunek 18.2.

Generowanie stron JavaServer Pages

Przykład 18.2.

Generowany automatycznie serwlet roboczy dla witaj1.jsp

import javax.servlet.*;

import javax.servlet.http.*;

import javax.servlet.jsp.*;

import javax.servlet.jsp.tagext.*;

import java.beans.*;

import java.io.*;

import java.util.*;

import org.apache.jasper.runtime.*;

import org.apache.jasper.*;

public class _0002fwitaj_00031_0002ejspwitaj1_jsp_0 extends HttpJspBase {

static {

}

public _0002fwitaj_00031_0002ejspwitaj1_jsp_0( ) {

}

2 Osoby zainteresowane zobaczeniem prawdziwego kodu źródłowego serwletu dla strony JSP, w większości przypadków

mogą odnaleźć go w tymczasowym katalogu określonym w atrybucie kontekstu javax.servlet.context.tempdir

(proszę zobaczyć rozdział 4, „Pobieranie informacji”. Kiedy odnajdzie się prawdziwe źródło serwletu można zobaczyć, że

jest ono o wiele bardziej skomplikowane niż to przedstawione w tym miejscu.

private static boolean _jspx_inited = false;

public final void _jspx_init() throws JasperException {

}

public void _jspService(HttpServletRequest request, HttpServletResponse response)

throws IOException, ServletException {

JspFactory _jspxFactory = null;

PageContext pageContext = null;

HttpSession session = null;

ServletContext application = null;

ServletConfig config = null;

JspWriter out = null;

Object page = this;

String _value = null;

try {

if (_jspx_inited == false) {

_jspx_init();

_jspx_inited = true;

}

_jspxFactory = JspFactory.getDefaultFactory();

response.setContentType("text/html;charset=ISO-8859-1");

pageContext = _jspxFactory.getPageContext(this, request, response,

"", true, 8192, true);

application = pageContext.getServletContext();

config = pageContext.getServletConfig();

session = pageContext.getSession();

out = pageContext.getOut();

// HTML // begin [file="C:\\ witaj1.jsp";from=(0,0);to=(4,0)]

out.write("<HTML>\r\n<HEAD><TITLE>Witaj</TITLE></HEAD>\r\n<BODY>\r\n<H1>\r\n");

// end

// begin [file="C:\\ witaj1.jsp";from=(4,2);to=(11,0)]

if (request.getParameter("nazwa") == null) {

out.println("Witaj œwiecie");

}

else {

out.println("Witaj, " + request.getParameter("nazwa"));

}

// end

// HTML // begin [file="C:\\ witaj1.jsp";from=(11,2);to=(14,0)]

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: