SERVLETI SI PAGINI JSP

Tehnologia bazat pe servleti Java

Un server Web dirijeaz fiecare cerere HTTP ctre o secvent de cod (PHP, Java, etc).
Primul pas n trecerea de la tehnologia CGI la o tehnologie bazat pe limbajul Java a fost
introducerea de clase servlet simultan cu extinderea programelor server astfel ca s poat
recunoaste si trata servleti.
Un servlet este o clas Java care primeste si interpreteaz cererile HTTP primite de la
browser, dup care transmite un rspuns sub forma unei pagini HTML ctre browser.
O cerere HTTP contine :
- numele metodei HTTP: GET, POST,PUT,DELETE, OPTIONS,HEAD
- adresa URL a serverului si numele (contextul) aplicatiei, de forma:
http://host:port/context-root/
- calea ctre componenta (componentele) care va trata cererea si numele componentei
(dac nu este specificat numele componentei atunci se consider un nume implicit, cum ar fi
index.html sau index.jsp, functie de server, care se adaug automat unei cereri partiale). Exemplu:
http://localhost:8080/app1 devine: http://localhost:8080/app1/index.jsp
- versiunea HTTP
- parametrii prin care se transmit date ctre server
Rspunsul de la server la o cerere HTTP contine versiunea HTTP, un cod numeric de rspuns
si un document (de obicei HTML), dac nu au fost erori. Codul de rspuns 200 corespunde primirii
unui rspuns valid, 401= eroare (cerere nepermis), 402= eroare (URI inexistent), 500=eroare
intern de server.
Metoda GET este folosit pentru interogarea aplicatiei din server si poate contine un numr
redus de date: adresa URL a unei resurse si, eventual o serie de parametri (nume si valoare).
Metoda POST este folosit pentru actualizarea (modificarea) unei resurse si poate contine mai
multe date dect metoda GET (date folosite n actualizarea resursei).
Un servlet este o componenta Web scris n Java, care genereaz continut dinamic si este
gestionat de un container (de servleti). Un container (numit si servlet engine) este o extensie a
unui server Web care asigur functiile cerute de servleti. Un servlet interactioneaz cu clientii Web
conform modelului cerere/rspuns implementat de ctre containerul de servleti.
Un container de servleti transform cererea HTTP de la client ntr-un obiect de tip
HTTPServletRequest , transmis la un servlet (sau pagina JSP) care genereaz un obiect de tip
HTTPServletResponse sau transmite cererea unei alte componente Web. Containerul de servleti
transforma acest obiect ntr-un raspuns HTTP, transmis la client.
HTTP Request HttpServletRequest

Client web

Servlet
HTTP Response HttpServletResponse

Cele mai folosite servere care au si container de servleti sunt Tomcat (Apache) si Jetty. Ele stau
la baza multor servere de aplicatii comerciale sau gratuite. Un server de aplicatii ofer n plus si
alte functii comune aplicatiilor Web: securitatea si controlul accesului la aplicatii, gestiunea
tranzactiilor, servicii de nume si directoare (JNDI) s.a.
La primirea unei cereri containerul de servleti realizeaz urmtoarele actiuni:
1. Dac nu exist un obiect servlet n memorie atunci ncarc clasa servlet, instantiaz clasa (se
creeaz un obiect servlet) si apeleaz metoda init din servlet pentru initializri.
2. Apeleaz metoda service (doGet,doPost) din servlet transmitnd ca argumente un obiect
cerere si un obiect raspuns (obiectul rspuns va fi completat de metoda service).
Functiile unui servlet sunt realizate n metodele service, doGet, doPost s.a. Aceste metode
extrag informatii din obiectul cerere, acceseaz resurse externe si completeaz rspunsul cu
informatiile obtinute din resurse externe (cum ar fi baze de date). Parametrii unei cereri apar n
sirul de cereri (Query String), separat de calea la componenta prin ?. Numele si valorile
parametrilor unei cereri sunt preluate de obicei dintr-un formular (transmis de server si completat

de utilizatorul client al aplicatiei) si sunt adugate la URL prin click pe butonul Submit dintr-un
formular HTML (sau la apsarea tastei Enter).
Clasa HttpServletRequest are metode pentru extragerea parametrilor dintr-o cerere de ctre
servlet:
String getParameter (String name)
Enumeration getParameterNames()

// valoare parametru cu nume cunoscut

// iterator pe lista cu numele tuturor parametrilor din cerere

Exemplu de extragere a parametrului cu numele user dintr-o cerere de forma:

http://localhost:8080/hello?user=me
out.print (<h1>Hello );
out.print (request.getParameter(user));
out.println (</h1>);

Un exemplu simplu de servlet care afiseaz ca rspuns un mesaj de salut:

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println ( <html>);
out.println (<body> );
out.println (<h1>Hello World! </h1> );
out.println (</body>);
out.println (</html>);
}

Mai multi servleti dintr-o aplicatie pot folosi date (atribute) din patru obiecte comune, numite
Scope Objects:
Web Context : accesibil tuturor componentelor dintr-un context (aplicatie)
Session: accesibil componentelor dintr-o sesiune client
Request: accesibil componentelor care trateaz o cerere
Page: accesibil paginii JSP care a creat obiectul
Intr-o schem simpl MVC un servlet are rolul de controller. De fapt aplicatiile reale contin mai
multi servleti, fiecare serveste o pagin diferit din aplicatie. Cererile de la clienti sunt primite de
un servlet cu rol de dispecer, care selecteaz un alt servlet din aplicatie n functie de parametrii
cererii HTTP.

Aplicatiile Web cu servleti mai pot folosi filtre interpuse ntre servleti si cereri/rspunsuri HTTP,
precum si clase auxiliare (helpers) astfel c schema complet MVC a unei aplicatii Web arat
astfel:

Un filtru atasat unui servlet este folosit fie pentru prelucrarea unei cereri de la client nainte de a
ajunge la servlet, fie pentru prelucrarea rspunsului transmis de servlet. Se folosesc filtre pentru
autentificarea clientului, pentru compresia continutului sau pentru jurnalizare (logging).
O alt facilitate este atasarea unor asculttori la evenimente din viata unui servlet.
O aplicatie Web contine n general: componente Web, resurse statice (imagini, de ex.), clase
si biblioteci auxiliare (helper), biblioteci de tag-uri, precum si un descriptor de instalare pentru
configurarea (adaptarea) aplicatiei la instalarea pe serverul de productie.
Dezvoltarea unei aplicatii Web necesit urmtoarele etape:
- Scrierea codului pentru componentele Web
- Scrierea descriptorului de instalare (fisier XML)
- Compilarea componentelor si claselor auxiliare folosite de ele
- Impachetarea fisierelor aplicatiei ntr-o arhiv war (optional)
- Instalarea aplicatiei pe server (copiere fisier war in directorul din server pentru aplicatii Web)
Instalarea unui servlet pe un server Web (servlet deployment) poate fi static (nainte de a
porni/reporni un server) sau dinamic (n timp ce un server deserveste alte aplicatii) si se poate
face n mai multe feluri:
- Se copiaz directorul aplicatiei (cu o structur impus) sau o arhiv war cu continutul acestui
director n folderul din server destinat acestui scop (webapps pentru Apache Tomcat);
- Se foloseste programul ant (cu un fisier build.xml) si pentru operatia de instalare (nu numai
pentru compilarea surselor si alte operatii de creare a directorului aplicatiei)
- Se foloseste un utilitar, care poate fi o aplicatie Web de pe server-ul unde se va face instalarea
pentru deployment (de ex. Tomcat6 Manager)
Directorul aplicatiei are o structur de subdirectoare impus de specificatiile 2.2 pentru servleti,
iar arhivele cu acest format sunt fisiere cu extensia war (Web Archive). Structura general a unui
asemenea director este o structur ierarhic, cu cteva subdirectoare si fisiere obligatorii, si cu
altele ce depind de complexitatea aplicatiei. Numele directorului este asociat la instalare pe server
cu un nume de cale (context path), nume folosit n identificatorul resursei (URI) pentru acces la
aplicatia din server.
webapp
fisiere HTML,JSP
WEB-INF
classes
fisiere cu clase Java
lib
fisiere jar cu biblioteci folosite de aplicatie
web-xml
Atunci cnd se arhiveaz acest director se mai adaug si un subdirector META-INF cu un fisier
manifest (de tip mf) si eventual cu un fisier context.xml cu optiuni de configurare pentru

Tomcat. Atunci cnd se folosesc fisiere imagine, de stil (css) sau altele, cerute de fisierele HTML,
acestea e bine s fie grupate n subdirectoare cu nume sugestive
(images de ex.). Fisierele HTML si JSP sunt cele direct accesibile clientilor aplicatiei.
Respectarea acestei structuri simplific referintele ntre componentele aplicatiei Web pentru c
fisierele din subdirectoarele classes si lib sunt vizibile celorlalte fisiere din aplicatie, fr alte
Exemplu simplu de director minimal hello cu o singur clas servlet:
hello
WEB-INF
classes
HelloServlet.class
web.xml

Fisierul web-xml poate contine :

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns=http://java.sun.com/xml/ns/j2ee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">
<servlet>
<servlet-name>HelloServlet</servlet-name>
<servlet-class>HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloServlet</servlet-name>
<url-pattern>/hello/url-pattern>
</servlet-mapping>
</web-app>

Directorul care contine sursele aplicatiei si folosit n dezvoltarea aplicatiei poate avea (si are de
obicei) o structur diferit de directorul necesar pentru arhiva war sau pentru instalare pe server.
De aceea, se folosesc programe de gestiune a proiectelor sofware (Ant, Maven ) sau medii IDE
pentru automatizarea secventei de operatii care produce directorul final pornind de la directorul cu
surse (creare/stergere de foldere temporare, creare/stergere de fisiere, compilare, copiere de
fisiere dintr-un folder n altul, s.a.)
Intr-o aplicatie mare este preferabil s avem mai multi servleti, cu roluri bine definite, n locul
unui singur servlet mare. Transmiterea obiectelor cerere si rspuns ntre servleti se face prin
intermediul unui servlet dispecer. Exemplu:
public class Servlet1 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response) throws Exception {

RequestDispetcher rd= request.getRequestDispetcher (/Servlet2);

Rd.forward(request,response);
// catre Servlet2

Tehnologia JSP (Java Server Page)

Extinderea exemplului anterior cu includerea n mesajul de salut a numelui introdus de utilizator
necesit trimiterea la client a unui formular, care va fi completat de utilizator cu numele su si va
trimis napoi la server. Asta nseamn c n servlet vor fi mult mai multe linii pentru scriere n fluxul
de rspuns (out) a unor linii HTML (cu taguri si text).
Atunci cnd documentul HTML trimis de servlet la client este mult mai mare dect partea de
logic din aplicatie (realizat prin instructiuni Java) este preferabil s se includ fragmentele de
cod Java n documentul HTML si nu invers, asa cum se ntmpl ntr-un servlet (care contine cod
Java pentru prelucrare cereri si scriere de fragmente de HTML n pagina de rspuns).
Tehnologia JSP permite crearea de continut Web cu elemente statice si dinamice. Ea

extinde tehnologia bazat pe servleti Java (ptr crearea de continut dinamic) dar permite
un mod mai natural de a specifica continutul static (HTML/XHTML).
Ideia paginilor JSP este de a extinde paginile HTML cu fragmente de cod Java incluse ntre
tag-uri delimitate de <% si %>. Paginile JSP sunt transformate (compilate) automat n servleti
de ctre un motor JSP (JSP Engine).
Codul Java folosit de o pagin JSP are forma unor componente JavaBean, adic foloseste
metode de tip get si set pentru acces la propriettile clasei (la datele dintr-un obiect). Tag-ul
<jsp: useBean ../> instantiaz o clas JavaBean si atribuie un identificator acestui obiect, care va fi
folosit n alte taguri de acces la proprietti: <jsp:setProperty ../>, <jsp:getProperty .. />.
Exist un numr relativ mare de taguri predefinite (ntr-o bibliotec de taguri de baz) si se pot
defini alte biblioteci de taguri.
Exemplu de fisier JSP
<%@ page import="hello.NameHandler" %>
<jsp:useBean id="mybean" scope="page" class="hello.NameHandler" />
<jsp:setProperty name="mybean" property="*" />
<html>
<head><title>Hello, User</title></head>
<table border="0" width="700">
<tr>
<td width="150"> &nbsp; </td>
<td width="550">
<h1>My name is Duke. What's yours?</h1>
</td>
</tr>
<tr>
<td width="150" &nbsp; </td>
<td width="550">
<form method="get">
<input type="text" name="username" size="25">
<br>
<input type="submit" value="Submit">
</td>
</tr>
</form>
</table>
<%
if ( request.getParameter("username") != null ) {
%>
<%@ include file="response.jsp" %>
<%
}
%>
</body>
</html>

Fisierul response.jsp poate arta astfel:

<table border="0" width="700">
<tr>
<td width="150"> &nbsp; </td>
<td width="550">
<h1>Hello, <jsp:getProperty name="mybean" property="username" />!
</h1>
</td>
</tr>
</table>

Clasa Java folosit de pagina JSP este banal n acest exemplu:

package hello;
public class NameHandler {
private String username;
public NameHandler() { username = null; }
public void setUsername( String name ) { username = name; }
public String getUsername() { return username; }
}

Codul Java anterior ar fi mai complex dac s-ar cere autentificarea utilizatorilor care acceseaz
aplicatia, prin cutarea numelor acestora ntr-un tabel dintr-o baz de date.
Exemplul urmtor, care nsoteste server-ul Tomcat, este un joc de ghicire de ctre utilizatorul
aplicatiei a unui numr generat aleator n server si are o logic a aplicatiei ceva mai complex.
<%@ page import = "num.NumberGuessBean" %>
<jsp:useBean id="numguess" class="num.NumberGuessBean" scope="session"/>
<jsp:setProperty name="numguess" property="*"/>
<html>
<head><title>Number Guess</title></head>
<body>
<% if (numguess.getSuccess()) { %>
You got it after <%= numguess.getNumGuesses() %> tries.
<p>
<% numguess.reset(); %>
<a href="numguess.jsp">try again</a>?
<% } else if (numguess.getNumGuesses() == 0) { %>
Welcome to the Number Guess game.<p>
Enter a number between 1 and 100.<p>
<form method=get>
<input type=text name=guess>
<input type=submit value="Submit">
</form>
<% } else { %>
Try <b><%= numguess.getHint() %></b>.
You have made <%= numguess.getNumGuesses() %> guesses.<p>
Enter a number between 1 and 100.<p>
<form method=get>
<input type=text name=guess>
<input type=submit value="Submit">
</form>
<% } %>
</body>
</html>

Clasa JavaBean, fr comentariile initiale, arat astfel:

package num;
import java.util.*;
public class NumberGuessBean {
int answer;
boolean success;
String hint;
int numGuesses;
public NumberGuessBean() { reset(); }
public void reset() {
answer = Math.abs(new Random().nextInt() % 10) + 1;
success = false;
numGuesses = 0;
}

public void setGuess(String guess) {

numGuesses++;
int g;
try { g = Integer.parseInt(guess); }
catch (NumberFormatException e) { g = -1; }
if (g == answer) success = true;
else if (g == -1) hint = "a number next time";
else if (g < answer) hint = "higher";
else if (g > answer) hint = "lower";
}
public boolean getSuccess() { return success; }
public String getHint() { return "" + hint; }
public int getNumGuesses() { return numGuesses; }
}

Intercalarea de cod Java si de taguri HTML nu este o practic recomandat, iar aplicatiile
realizate dup schema MVC separ partea de logic n clase controler si partea de prezentare n
pagini HTML sau JSP (componenta de View).
Orice pagin JSP este tradus ntr-un servlet care scrie textul HTML din pagin.
Ciclul de viat al unei pagini JSP:
1. Dac nu exist un obiect servlet pentru pagina JSP, atunci
a. Se ncarc clasa servlet asociat paginii
b. Se instantiaz clasa servlet
c. Se fac initializri prin apelul metodei jspInit
2. Containerul apeleaz metoda _jspService (corespondentul metodei service dintr-un servlet)
transmitndu-i ca parametri obiectul cerere (HTTP) si obiectul raspuns.
JSP pune la dispozitie:
- O serie de marcaje predefinite (taguri JSP) pentru legare la secvente Java dintr-un document
HTML
- Posibilitatea de a defini noi marcaje utilizabile n pagini JSP (ustom tags
- Un limbaj cu expresii (EL=Expression Language) pentru acces la obiecte Java
Elementele componente ale unei pagini JSP:
- Directive, care controleazmodul ncare containerul traduce si executpagini JSP. Exemple:
<%@ page contentType="text/html; charset=UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="/functions" prefix="f" %>

- Secvente de cod Java inserate n pagin (Scriptlets). Exemple:

<% for (int i=0;i<5;i++) {%> Hello <br> <% } %>

- Expresii EL. Exemple:

${localeString}
<c:set var="selectedLocaleString" value="${param.locale}" />
<c:forEach var="localeString" items="${locales.localeName s}"> ... </c:forEach>

- Marcaje standard JSP. Exemple:

Marcaje de forma <jsp:useBean ../> pentru instantiere de clase JavaBeans
Ex: <jsp:useBean id="date" class="mypkg.MyDate"/>

Marcaje de forma <jsp:getProperty>, <jsp:setProperty> pentru apel de metode din clase

JavaBeans. Ex:
<jsp:setProperty name="date" property="locale" value="${locales.selectedLocale}"/>

- Marcaje de forma <jsp:include >, <jsp:forward > pentru apeluri de metode din Servlet API

- Marcaje definite de programatori (custom tags)

Notatia "${var}" este utilizata frecvent in paginile JSP pentru a include intr-o constanta sir
valoarea unei variabile cu numele 'var'. Aceste expresii pot apare in textul static (HTML) si in
atribute ale marcajelor standard sau definite de utilizatori.
De asemenea este permis notatia ${expr} pentru a obtine valoarea unei expresii (n vederea
includerii ei ntr-un text static sau n atribute de marcaje).
In paginile JSP se pot folosi o serie de obiecte implicite:
servletContext = contextul servlet si al altor componente din aplicatie
session = sesiune servlet
request = cerere primita de servlet
response = raspuns trimis de servlet

Alte obiecte implicite accesibile ntr-o pagin JSP sunt de tip dictionar (Map) si permit
memorarea numelor si valorilor unor variabile pe o durat determinat:
pageScope = valabile pentru pagina curenta
requestScope = valabile pentru o cerere
sessionScope = valabile pentru sesiunea curenta
applicationScope = valabile pentru intreaga aplicatie

Reutilizarea unor pagini complete sau unor fragmente de pagini JSP n alte pagini JSP se
face prin directiva <%@ include file="filename"%>
Aceste directive se pot folosi numai la nceput sau la sfrsit de pagin.
Pentru reutilizarea de fragmente in interiorul paginilor JSP se foloseste o biblioteca de
marcaje "template" (Template Tag Library).
Un template permite separarea partilor comune mai multor pagini dintr-o aplicatie Web
(antet,note de subsol, s.a.) de elementele specifice fiecarei pagini. Un template este o pagina JSP
cu parametrii (placeholders=jaloane)