Jsp Comunicare Intre Pagini Web

Capitolul I. Introducere.

Scopul lucrării.

Lucrarea de față își propune descrierea tehnologiilor Java pentru Internet (JSP, servleturi), structura și funcționalitatea lor, modul de comunicare între ele, avantajele utilizării JSP-ului față de servlet-uri, iar în ultima parte implementarea unei aplicații Web care să folosească aceste tehnologii.

Java Server Pages (JSP) este una din cele mai puternice tehnologii Web, un limbaj unic care schimbă rapid modul de dezvoltare al aplicațiilor Web. De-acum toată lumea a auzit de Java, un limbaj de dezvoltare foarte portabil, orientat spre obiecte, creat de Sun Microsystems. În scurt timp Java a devenit un limbaj de dezvoltare robust și fiabil, care poate fii utilizat pentru crearea de aplicații complete de la desktop până la server sau utilizat ca bază pentru aplicațiile Web. El oferă un foarte bun suport pentru realizarea de aplicații complexe Web, fiind deseori preferat pentru ușurința dezvoltării, întreținerii și actualizării aplicațiilor. De neglijat este și independența față de platformă, mulțimea de unelte gratuite pentru dezvoltare, reutilizarea facilă a codului, precum și documentațiile disponibile pe Internet.

Faptul ca Java este un limbaj atât de puternic și popular nu înseamnă că e și simplu, cel puțin nu la fel de simplu ca limbajele de scriptare ASP, Perl. De aceea puși să aleagă între forța oferită de Java și simplitatea unui limbaj de scriptare, programatorii optează pentru a doua.

Motivația alegerii temei: JSP – Comunicare între pagini Web.

JSP aduce o schimbare. JSP reprezintă o noua interfață Java, el combină cele două atuuri: forța brută a limbajului Java și simplitatea specifică limbajelor de scriptare. JSP combină HTML și XML, cu servleturile și tehnologia JavaBeans, bazată pe etichete, oferind acces la întreaga gamă de clase și funcții Java. JSP este o extensie a servleturilor. În loc să se scrie cod Java care să genereze pagini Web, se creează pagini Web care să conțină elemente dinamice. Atunci când se primește o cerere de pagină JSP, se creează un servlet din respectiva pagină și este executat, iar răspunsul este trimis la cererea făcută. De asemenea este avantajos să se folosească JSP în locul servleturilor, pentru că JSP separă conținutul HTML static de cel dinamic. În cazul servleturilor, orice modificare legată de designul paginii Web presupune recompilarea servletului. În paginile JSP, partea de generare a conținutului dinamic este separată de cea statică prin utilizarea componentelor JavaBeans.

Rolul aplicației.

Aplicația realizată în această lucrare este un magazin virtual marca BMW care va conține elementele des întâlnite în aplicațiile Web existente: autentificare utilizatori, conectare la baza de date, catalog de produse, coș de cumpărături, efectuare comandă, administrare magazin, căutare după diferite criterii, un top vânzare.

Site-ul pune în evidență modul de utilizare a tehnologiilor Web: JSP, Java, MySQL, HTML, CSS. Se iau pe rând elementele enumerate mai sus și se propune o soluție de implementare a lor, cât mai eficientă și rapidă. Exemplele de cod pun în evidență modul de folosire a tehnologiilor Web utilizate.

Aplicația implementează un magazin online deoarece în ultimi anii o dată cu răspândirea spațiului WWW a crescut considerabil și numărul utilizatorilor Web, aceștia putând deveni foarte ușor potențiali clienți. Oricine poate fi clientul acestui magazin, este suficientă o conexiune la Internet și un browser pentru navigare. Astfel realizând un magazin online se oferă clienților o multitudine de servicii și facilități, în special economisire de timp. Site-ul se adresează în special amatorilor și pasionaților de mașini BMW, precum și tuturor utilizatorilor Web care doresc achiziționarea online foarte rapidă a unei astfel mașini.

Structura lucrării.

Lucrarea este împărțită în patru capitole.

Primul capitol este scurtă trecere în revistă a importanței limbajului Java și a avantajelor utilizării tehnologiilor sale pentru Internet: JSP și servleturi. Se prezintă scopul lucrării de față, motivația alegerii temei, rolul aplicației implementate și motivația alegerii implementării unui magazin virtual.

Capitolul doi este împărțit în două mari subcapitole. Primul subcapitol este dedicat servleturilor: structura, tipuri de servlete, modul de funcționare, execuția și durata de viață a unui servlet, comunicarea dintre ele, gestionarea stărilor sesiune. Al doilea subcapitol prezintă pe scurt: noțiuni de bază JSP, avantajele JSP-urilor față de servleturi și legătura dintre cele două tehnologii Java, structura și execuția unei pagini JSP, elemente specifice JSP (directive, elemente de scriptare, obiecte disponibile), acțiuni standard JSP, componente JavaBeans, interacțiunea cu bazele de date.

Capitolul trei prezintă modul de implementare a magazinului virtual. Site-ul a fost dezvoltat având în vedere două interfețe: una adresată unui utilizator obișnuit și cealaltă administratorului magazinului. Aplicația este divizată în mai multe module: autentificare utilizatori, catalog de produse, coș de cumpărături, efectuare comandă, administrare magazin, căutare după diferite criterii, un top vânzare. Se explică modul de interacționare al acestora ilustrând secvențe de cod și capturi-ecran.

Capitolul patru reprezintă concluziile.

Capitolul 2. Tehnologii Java pentru Internet.

2.1. Protocolul HTTP ( Hypertext Transfer Protocol )

Transmiterea de date între navigatoarele și serverele Web se realizează prin intermediul protocolului HTTP. Aceasta are la bază paradigma cerere-răspuns. Navigatorul Web inițiază comunicarea prin trimiterea unei cereri la care serverul trimite un răspuns. Acest răspuns conține un cod de stare format din trei cifre care indică starea mesajului de răspuns, fiind însoțit și de un text explicativ în limba engleză. Cele mai des întâlnite coduri de stare sunt 200 Ok pentru cererile rezolvate cu succes si 404 Not Found atunci când serverul nu găsește resursa specificată.

2.2. Servlete.

2.2.1 Definire servlet.

Un servlet este o componentă software pe partea de server, scrisă în Java și care extinde dinamic funcționalitatea unui server (de obicei HTTP). Spre deosebire de appleturi, servlet-urile nu afișează o interfață grafică către utilizator, ci returnează doar rezultatele către client sub forma unui document HTML.

Servlet-urile sunt de fapt clase Java care se conformează unei interfețe specifice ce poate fi apelată de un către Web server, acesta numindu-se servlet container. Funcționalitatea furnizată de un servlet nu privește numai serverele Web, ci se poate extinde la orice sever care suporta Java si Servlet API (cum ar fi : FTP, Telnet, mail, servere de știri). Servlet API este o specificare dezvoltată de Sun Microsystems și alții care definește clasele si interfețele necesare pentru crearea si execuția servlet-urilor. Servlet-urile furnizează un cadru pentru crearea de aplicații care implementează paradigma cerere-răspuns. Când un navigator trimite o cerere către server, serverul o trimite mai departe unui servlet. Servletul procesează cererea, eventual accesând o bază de date, și construiește un răspuns convenabil (de obicei în HTML) care este returnat clientului. Servlet-urile funcționează asemănător CGI-urilor.

Cerere HTTP

Răspuns HTTP

Fig 2.1 Procesare cerere HTTP.

Servlet API ( Application Programming Interface) este o extensie Java standard a platformei Java 2, ediția standard. Toate extensiile Java sunt conținute în pachetul javax. Pachetele pentru servleturi sunt javax.servlet si javax.servlet.http. Servlet API este disponibil gratuit ca :

o biblioteca de sine stătătoare Java (http://java.sun.com/products/servlet);

parte componentă a proiectului Apache Tomcat (http://jakarta.apache.org/tomcat).

2.2.2. Structura de bază a unui servlet.

Servlet-urile se definesc prin extinderea uneia din clasele de bază : GenericServlet si HttpServlet. Nu este obligatorie moștenirea acestor clase, este suficientă implementarea interfeței Servlet. Toate servlet-urile suprascriu cel puțin o metodă necesară funcționalității lor. Metodele utilizate sunt : init(), service(), destroy(). Pentru clasa GenericServlet metoda service() este abstractă și trebuie implementată de programator. Init() se apelează o singură dată când este încărcat servletul (analog unui constructor). Cele mai uzuale acțiuni executate în metoda init() sunt:

Citirea unor parametri de inițializare a servletului.

Deschiderea unor fișiere.

Realizarea unor conexiuni la baze de date.

Realizarea unor conexiuni în rețea.

Dacă apare o eroare la realizarea acestor operațiuni care compromite capacitatea servletului de a satisface cererile clienților trebuie aruncată o excepție de tipul UnavailableException.

Metoda destroy() este apelată când servletul este descărcat, eliberând resursele servletului. Uzual, în această metodă vor fi închise fișierele sau conexiunile deschise în metoda init(). Metoda destroy() este apelată doar după ce firele de execuție service() s-au terminat sau o anumită perioadă de timp specificată în parametrii de configurare ai serverului s-a scurs. Metoda este executată o singură dată și după apelul ei nu va mai fi realizat nici un apel al metodei service().

Structura generală a unui servlet este următoarea:

Structura unui servlet generic este următoarea :

Structura unui servlet HTTP este următoarea :

2.2.3. Servleturi HTTP

Atunci când se dorește crearea unui servlet pentru protocolul HTTP, este recomandată extinderea clasei HttpServlet. Clasa HttpServlet extinde clasa GenericServlet, deci moștenește toate funcționalitățile acesteia. În plus, HttpServlet adaugă funcționalitatea specifică protocolului HTTP și furnizează un cadru în care putem construi aplicații HTTP.

Clasa HttpServlet este o clasă abstractă prezentă în pachetul javax.servlet.http. Fiind abstractă ea nu poate fi instanțiată. Structura unui servlet HTTP a fost dată mai sus în secțiunea 2.2.2. Un servlet HTTP funcțional trebuie să implementeze una din metodele: service(), doGet(), doPost(), doHead(), doPut(), doDelete() corespunzătoare metodelor protocolului HTTP.

Metodele init(), destroy() și getServletInfo() aparțin clasei GenericServlet, din care se derivează clasa HttpServlet.

Metoda service() are prototipul :

public void service (HttpServletRequest cerere, HttpServletResponse răspuns) throws ServletException, java.io.IOException ;

Primul argument al metodei service() este un obiect care implementează interfața HttpServletRequest și reprezintă cererea clientului. Toate datele din cerere sunt încapsulate într-un obiect HttpServletRequest. Al doilea parametru este un obiect care implementează interfața HttpServletResponse și este răspunsul serverului către client.

Daca se lucrează cu servleturi HTTP nu se va suprascrie metoda service(), ci numai metodele corespunzătoare tipului de cerere HTTP : doGet() pentru Get și doPOst() pentru POST. Astfel implementarea implicită a metodei service() va apela automat una din aceste metode pentru a răspunde cererii clientului.

Metoda doGet() are prototipul :

protected void doGet(HttpServletRequest cerere, HttpServletResponse răspuns ) throws servletException, java.io.Exception;

Ea este apelată la implementarea implicită a metodei service() ca răspuns la o cerere HTTP de tip GET. Parametri de asemenea reprezintă cererea clientului si răspunsul serverului.

Un exemplu de procesare a unei cereri prin metoda GET :

Metoda doPost() are prototipul :

protected void doPost(HttpServletRequest cerere, HttpServletResponse răspuns ) throws servletException, java.io.Exception;

Metoda doPost() este apelată de fiecare dată când apare o cerere HTTP POST primită de servlet. Utilizată pentru procesarea datelor primite dint-un formular. Informația introdusă de client este încapsulată într-un obiect de tip HttpServletRequest și trimisă metodei doPost(), Dacă nu se găsește o implementare a metodei doPost() atunci se trimite către client un mesaj de eroare HTTP 400 ”Bad Request”.

2.2.4. Funcționalitatea servleturilor.

Ca și CGI-urile ( Common Gateway Interface ), servleturile permit interacțiunea în ambele sensuri între client și server. Posibilitățile furnizate de servleturi sunt :

construiesc dinamic și returnează un document HTML pe baza cererii clientului;

procesează datele completate de utilizatori printr-un formular HTML și returnează un răspuns;

furnizează suport pentru autentificarea utilizatorului și alte mecanisme de securitate;

interacționează cu resursele serverului, cum ar fi baze de date, fișiere cu informații utile pentru clienți;

procesează intrările de la mai mulți clienți pentru aplicații, cum ar fi jocurile în rețea;

atașează automat elemente de design pentru pagini Web, cum ar fi antete sau note de subsol, pentru toate paginile returnate de server;

redirectează cereri de la un server la altul în scop de echilibrare a încărcării;

partiționează un serviciu logic între servere sau între servleturi pentru a procesa eficient o prolemă.

2.2.5. Durata de viață a unui servlet.

Procesul apelării de către server a unui servlet se poate împărții în opt pași :

Serverul încarcă servletul când acesta este cerut de client sau la pornirea serverului, dacă așa a fost configurat.

Serverul creează o instanță a clasei servletului pentru realizarea tuturor cererilor. Folosind fire de execuție multiple, cererile concurente pot fi deservite de o singura instanță a servletului . Exemplu :

Servlet s= (Servlet) c.newInstance();

Serverul apelează metoda init() a servletului care garantează că termină execuția înaintea procesării primei cereri a servletului. Daca serverul creează mai multe instanțe ale servletului metoda init() se apelează de fiecare dată pentru fiecare instanță.

În momentul primirii unei cereri pentru servlet, serverul construiește un obiect ServletRequest sau HttpServletRequest din datele incluse in cererea clientului. De asemenea construiește un obiect ServletResponse sau HttpServletResponse care furnizează metode pentru returnarea răspunsului. Tipul parametrului depinde dacă servletul extinde GenericServlet sau Httpservlet.

Serverul apelează metoda service() (care pentru servleturi HTTP poate apela o metoda specifică doget() sau doPost()), trimițând ca parametri obiectele construite la pasul anterior.

Metoda service() procesează cererea prin evaluarea obiectului ServletRequest sau HttpServletRequest. Apoi răspunde folosind obiectul ServletResponse sau HttpServletResponse.

Daca se primește o noua cerere la servlet, se reia procesul de la pasul 5.

De fiecare dată când containerul servletului determină că un servlet trebuie descărcat, serverul apelează metoda destroy(), după terminarea firelor de execuție ale metodei service() sau după terminarea limitei de timp definite de server. Servletul poate porni dealocatorul de memorie (garbage collection).

2.2.6. Execuția unui servlet.

Există mai multe moduri de a rula un servlet. Anumite servere Web, cum ar fi iPlanet Web Server si W3C Jigsaw, oferă suport nativ pentru servleturi. Alte servere HTTP cum ar fi Apache Web Server si Microsoft Internet Information Server, oferă suport prin (servlet containerele) :

Tomcat de la Apache;

JRun de la Allaire;

ServletExec de la New Atlanta Communication;

Resin de la Caucho Technology;

În această lucrare s-a folosit serverul Apache Tomcat. Acesta este o parte a proiectului Apache Jakarta și reprezintă o implementare de referință oficială a servleturilor si JSP. Se poate obține la adresa :

http://jakarta.apache.org/tomcat/

Se instalează local dezarhivînd fișierele copiate. Urmează pornirea serverului Tomcat prin comanda startup. Se poate verifica dacă instalarea și pornirea serverului s-au realizat cu succes prin deschiderea unui navigator Web și scriind adresa (URL-ul) http://localhost:8080/ daca rezultatul este pagina de lucru a serverului Tomcat atunci e bine. Se poate modifica portul 8080 editând și schimbând porțiunea de cod corespunzătoare din fișierul /jakarta-tomcat/conf/server.xml. Toate servleturile specifice standardului Servlet API 2.2 utilizează conceptul de aplicație Web. O aplicație Web este o ierarhie de directoare și fișiere care formează împreuna o aplicație. De obicei ele sunt arhivate intr-un fișier cu extensia .war. Toate aplicațiile Web au aceeași structură de directoare referitoare la serverul utilizat. Ceea ce diferă este locul unde sunt instalate aplicațiile Web, acest lucru depinde de la un server la altul. Aplicația implementată in această lucrare folosește serverul Tomcat. Aici se păstrează toate aplicațiile în directorul /jakarta-tomcat/webapps. In caz că se folosește Jrun, aplicațiile se păstrează pentru serverul implicit în /jrun/servers/default. În aceste subdirectoare din directorul webapps va căuta serverul Tomcat fișierele HTML, JSP și imaginile asociate aplicației. Fiecărei aplicații Web i se atribuie de către administrator un ”drum de context” unic. Toate cererile către acest drum vor fi direcționate către aplicația Web corespunzătoare.

Dacă aplicației i se atribuie drumul de context /examples, atunci URL-ul http://localhost:8080/examples/index.html va afișa fișierul index.html aflat în directorul jakarta-tomcat/webapps/examples. Drumul de context pentru fiecare aplicație Web este specificat în fișierul server.xml din folderul jakarta-tomcat/conf/. Acest lucru se face astfel :

În elementul servlet se stabilește numele servletului și care este clasa asociată. Dacă aceasta face parte dintr-un pachet, numele clasei va fi precedat de numele pachetului. În tagul <servlet-mapping> se atașează unui servlet un URL. Acesta este dat de URL-ul aplicației, la care se adaugă conținutul tag-ului url-pattern.

Exemplu :

unde shop este pachetul din care face parte clasa ShowDesc care se află în jakarta-tomcat/webapps/examples/web-inf/classes/shop.

Servletul se va rula într-un navigator Web astfel :

http://localhost:8080/examples/servlet/ShowDesc

Se poate observa că apelarea servleturilor folosind Tomcat s-a făcut după următorul format pentru URL :

http://<server>:<port>/<drum_context>/servlet/<nume_servlet>[<informații_drum>][?<șir_interogare>]

Identificatorii scriși între paranteze unghiulare (<,>) semnifică faptul că aceștia trebuie înlocuiți. <drum_context> reprezintă locul unde se memorează aplicația Web, acesta trebuie sa fie unic. Cuvântul servlet indică serverului Tomcat că e vorba de un servlet nu de un HTML sau JSP; <nume_servlet> reprezintă numele clasei servletului sau numele servletului; <informatii_drum> și <șir_interogare> sunt componente suplimentare pentru un URL. <șir_interogare> permite trimiterea de informații suplimentare unui servlet utilizând formatul nume=valoare. Șirurile nume=valoare pot fi citite apelând pentru un obiect HttpServletRequest metodele getParameterNames(), getParameter(), getParameterValue().

2.2.7. Contextul de execuție

Un servlet "trăiește și moare" în interiorul unui proces ce rulează pe un server Web. În tot acest timp el poate obține diverse informații despre acest proces care mai este numit și contextul său de execuție. Aceste informații pot fi grupate astfel:

Informații primite la inițializarea servletului.

Informații despre și de la server – disponibile pe toată durata de viață a servletului.

Informații contextuale specifice cererilor primite.

Informațiile primite la inițializare sunt transmise servletului prin argumentul ServletConfig al metodei init(). Fiecare server Web oferă propria sa modalitate de a transmite diverși parametri de inițializare, uzual aceștia fiind specificați în fișierul de proprietăți ce descrie servletul. Valorile parametrilor de inițializare pot fi obținute prin metoda :

getInitParameter([nume-parametru])

Informațiile despre/de la server.

Legătura unui servlet cu serverul Web este realizată printr-un obiect de tip ServletContext. Acesta permite:

Accesarea resurselor disponibile servletului.

Monitorizarea evenimentelor (log).

Setarea/obținerea unor atribute disponibile și altor servleturi din același context.

Obținerea sa se realizează prin metoda getServletContext a clasei ServletConfig.

Exemplu ServletContext:

Contextul unei cereri.

Informațiile contextuale legate de fiecare cerere sunt oferite de obiecte ale interfețelor ServletRequest sau HttpServletRequest primite ca argument de metoda service(). Câteva exemple de metode ale clasei ServletRequest sunt:

getProtocol();

getScheme (https, http, ftp, etc.);

getServerName();

getServerPort();

getRemoteAdress() – returnează un String care conține adresa IP a calculatorului client;

getRemoteHost() – întoarce un String conținând host name-ul calculatorului client.

Clasa HttpServletRequest pune la dispoziție metodele:

public abstract String getParameter(String nume) – returnează valoarea parametrului transmis prin argumentul nume;

public abstract Enumeration getParameterNames() – întoarce un obiect java.util.Enumeration care pastrează numele tuturor parametrilor transmiși (este un șir String);

public abstract String[] getParameterValues( String nume) – returnează un șir String cu valorile parametrilor specificați prin nume sau null dacă nu există parametri dați.

2.2.8. Administrarea sesiunilor.

Ce este o sesiune de lucru ?

Păstrarea unei sesiuni de lucru se referă la memorarea clientului care a adresat o cerere unui servlet. Protocoalele Internet sunt de două tipuri:

cu stare (stateful): telnet, FTP

fără stare (stateless): HTTP

Așadar servleturile trebuie să utilizeze diverse tehnici pentru păstrarea sesiunilor. Aceste modalități pot fi următoarele:

prin intermediul cookie-urilor : containerul trimite clientului un cookie, iar acesta îl retrimite de fiecare dată când face o noua cerere la server;

prin intermediul protocolului HTTPS, care utilizează tehnologia de criptare SSL (Secure Socket Layer), care conține un mecanism de identificare fără echivoc a clientului;

prin rescrierea URL-ului, prin adăugarea unui identificator de sesiune la sfârșitul URL-ului, situație utilizată atunci când clientul nu acceptă cookie-uri.

Câmpuri ascunse în formulare;

Folosirea obiectelor sesiune.

Folosirea cookie-urilor.

Cookie-urile reprezintă o modalitate pentru o aplicație ce rulează la nivelul serverului să trimită o informație clientului care să fie memorată local pe mașina acestuia. Un cookie este compus din trei șiruri: (nume, valoare, comentarii). Pentru cookie-uri, Servlet API pune la dispoziție clasa Cookie din pachetul javax.servlet.http.

Salvarea / Restaurarea cookie-urilor:

Salvarea:

Instanțierea unui obiect de tip Cookie;

Setarea atributelor;

Trimiterea cookie-ului prin intermediul obiectului HttpServletResponse.

Restaurarea:

Obținerea tuturor cookie-urilor primite odată cu cererea clientului;

Găsirea cookie-ului cu numele căutat;

Extragerea valorii din cookie-ul găsit.

Constructorul necesită specificarea numelui și a valorii, în această ordine. Un exemplu de setare a unui cookie este folosind metoda addCookie a interfeței HttpservletResponse:

răspuns.addCookie(new Cookie(“color”,”blue”));//s-a adăugat cereri HTTP

Obținerea cookie-urilor se realizează astfel:

Cookies [] cookies =cerere.getCookies();

Tabloul returnat poate fi parcurs, iar obținerea numelui și a valorii se poate face prin intermediul metodelor getName() si getValue(). De reținut este că nu toți clienții Web au suport pentru cookie-uri, iar această facilitate poate fi dezactivată de către utilizator.

Durata de viață a unui cookie coincide cu durata sesiunii de lucru, adică cât timp este deschis browserul de Web. Explicit, ea poate fi controlată prin metoda setMaxAge ce poate avea ca argument:

>0: durata de viață în secunde;

0 : șterge cookie-ul de pe mașina clientului;

< 0: păstrat până la închiderea navigatorului Web.

Ștergerea unui cookie se face astfel:

//se creează un nou obiect Cookie

Cookie cookie = new Cookie(“nume”,””);

Cookie.setMaxAge(0);

răspuns.addCookie(cookie);

Avantajul folosirii cookie-urilor, față de metoda rescrierii URL-ului este că valorile cookie-urilor nu sunt vizibile. Comparativ cu folosirea câmpurilor ascunse are avantajul că nu necesită existența unui formular .

Rescrierea URL-ului.

Această metodă constă în adăugarea unui identificator de sesiune la sfârșitul URL-ului.

Exemplu:

http://localhost:8080/examples/servlet/progr.jsp;jsessionid=34567432

La fiecare cerere clientul va trimite la server această informație.

Câmpuri ascunse.

Această metoda este folosită doar dacă există un formular. Câmpurile ascunse sunt similare cu restul câmpurilor din HTML, doar că utilizatorul nu poate modifica valoarea lor. Când este apăsat butonul Submit, ele sunt trimise împreună cu celelalte câmpuri. Acest mecanism funcționează doar dacă formularul a fost transmis. Față de metoda anterioară, ea nu arată valoarea identificatorului în URL, dar se poate vizualiza dacă se deschide codul sursă HTML.

Obiectul session.

Fiecare sesiune are un identificator unic (ID). O sesiune persistă pentru o anumită perioada de timp, care poate fi și indefinită. Păstrarea sesiunilor va fi realizată folosind clasa HttpSession.Un obiect al acestei clase permite stocarea datelor unei sesiuni și asocierea între un utilizator și datele sesiunii sale de pe server. Etapele de bază în folosirea unui obiect HttpSession sunt:

Obținerea (crearea) unei sesiuni.

Citirea sau scrierea datelor folosind acest obiect.

Terminarea sesiunii (invalidarea ei).

Crearea unei sesiuni se realizează cu metoda getSession() a clasei HttpServletRequest. Aceasta returnează interfața HttpSession, care permite atașarea de obiecte pentru sesiunea curentă. Pentru atașarea unor informații în sesiune se face astfel:

Preluarea obiectului atașat unei sesiuni se realizează prin apelul:

Obiect obiect = (Obiect) sesiune.getAttribute(”etichetă”);

Dacă obiectul nu a fost atașat anterior se returnează null.

Pentru terminarea unei sesiuni se apelează metoda invalidate(), caz în care obiectele atașate se vor pierde. Dacă se va apela din nou, va genera excepția IllegalStateException. Sesiunile pot avea o durată de viață limitată. Perioada de timp dintre două cereri din cadrul unei sesiuni se poate stabili cu metoda getMaxInactiveInterval() și este exprimată în secunde. Metoda analogă este setMaxInactiveInterval(), iar dacă parametrul are valoare negativă intervalul este infinit.

Alte metode puse la dispoziție de interfața HttpSession sunt:

getAttribute() – returnează un atribut din obiectul session;

getAttributeNames() – returnează o enumerare java.util.Enumeration care conține numele variabilelor din obiectul session;

getCreationTime() – returnează timpul când s-a creat sesiunea curentă;

getId() – returnează un string care reprezintă identificatorul sesiunii;

getLastAccesedTime() – returnează ultimul moment când clientul accesat obiectul session;

getMaxInactiveInterval – returnează numărul de secunde cât va mai fi deschisă sesiunea curentă, după terminarea acestui interval, servletul container va distruge sesiunea;

invalidate() – distruge sesiunea curentă (invalidează obiectul session) și variabilele depuse în ea;

isNew() – returnează true dacă s-a creat un obiect session;

removeAttribute() – șterge variabilele depuse în sesiune;

setAttribute() – adaugă în sesiunea curentă (obiectul session) o noua variabilă;

setMaxInactiveInterval() – specifică timpul în secunde până când servlet containerul va invalida sesiunea;

2.2.9. Comunicarea servleturilor.

Comunicarea între servleturi reprezintă un avantaj, deoarece o cerere poate fi împărțită între mai multe servleturi și rezolvată mai ușor și mai eficient, economisind timp și resurse. Comunicarea se poate implementa astfel:

cereri HTML;

folosind clasa RequestDispacher. Acesta poate efectua una din acțiunile:

forward;

include.

Când un servlet se execută, poate folosi un obiect al interfeței RequestDispacher ca să invoce un alt servlet.

Acțiunea forward.

Transferă responsabilitatea generării răspunsului către client resursei apelate (unui alt servlet). Acest servlet va da răspunsul final clientului. Se realizează prin metoda forward a clasei RequestDispatcher.

RequestDispatcher dispatcher =context.getRequestDispatcher("resursa");

dispatcher.forward(request, response);

//nu este deschis nici un flux de ieșire către client

Servletul nu trebuie să deschidă vreun flux de ieșire către client, altfel va fi generată o excepție de tipul IllegalStateException.

Acțiunea include.

Include răspunsul primit de la resursa apelată (de la un alt servlet) în cadrul răspunsului propriu. Se realizează prin metoda include a clasei RequestDispatcher.

Redirectarea către un alt servlet se mai poate realiza și cu ajutorul metodei sendRedirect() din clasa HttpServletResponse(), iar ca parametru se va da URL-ul către pagina la care se dorește trimiterea:

răspuns.sendRedirect(“NumeServlet”);

sau

răspuns.sendRedirect(“http://localhost:8080/examples/servlet/NumeServlet”);

2.3. Noțiuni de bază JSP.

JavaServerPages (JSP) este o altă tehnologie Java pentru dezvoltarea aplicațiilor Web. Dacă servleturile sunt clase Java care generează documente Web, JSP-urile sunt documente Web care conțin secvențe de cod Java. Un avantaj al JSP-urilor sunt că ele separă conținutul HTML static de cel dinamic. În cazul servleturilor, orice modificare minoră referitoare la designul paginii Web implică recompilarea servletului. La JSP-uri, partea de generare a conținutului dinamic este păstrată separat de cea statică prin utilizarea componentelor JavaBeans externe. Un alt avantaj este ușurința dezvoltării. Serverul Web se ocupă de transformarea acestora în servleturi și apoi de compilarea lor. Acest lucru se realizează fie la încărcarea aplicației, fie la prima cerere a paginii JSP.

Astfel JSP este de fapt o extensie a servleturilor, fiind folosite deseori împreună în implementarea de aplicații Web.

Acesta secțiune se oprește asupra elementelor de bază JSP (structură și funcționare, directive, elemente de scriptare, obiecte implicite, acțiuni și componente JavaBeans).

Crearea, structura și execuția JSP-urilor.

Paginile JSP sunt executate pe partea de server, eu am ales să lucrez cu serverul Tomcat. Orice pagină JSP trebuie stocată în directorul tomcat_director/webapps/nume_aplicație. Paginile jsp au extensia .jsp.

Structura unei pagini JSP este asemănătoare cu cea a unei pagini HTML, doar că va conține și cod Java. Acesta trebuie inclus în interiorul etichetei <% … %>.

Exemplu: Simplu.jsp

Observație: Dacă o pagină este statică adică nu are conținut dinamic (dat de codul Java) atunci nu ar trebui salvat cu extensia .jsp ci .html, deoarece paginile JSP se procesează mai greu decât cele HTML.

Execuția unui JSP trebuie făcută după următorii pași:

Pornirea serverului Tomcat;

Deschiderea unui navigator Web si scrierea adresei:

http://localhost:8080/nume_aplicație/Simplu.jsp

unde nume_aplicație este un subdirector deja creat în Tomcat_director/webapps. Acolo se găsesc toate paginile JSP împreună cu paginile HTML, directorul de imagini al aplicației și un director numit WEB-INF. WEB-INF va conține la rândul lui directorul CLASSES, LIB și fișierul web.xml. În CLASSES sunt păstrate toate clasele Java create de noi si care vor fi instanțiate în interiorul paginilor JSP. În LIB se depun fișierele .jar cum ar fi mysql-connector-java-3.1.14-bin, care este folosit la conexiunea la o bază de date.

Funcționarea unui JSP.

Atunci când un client cere pentru prima oară o pagină JSP nouă sau reactualizată, containerul JSP trebuie să localizeze fișierul sursă al paginii JSP și să înceapă procesul de translatarea acesteia într-un fișier Java, mai precis un servlet. Extensia .jsp precizează serverului Web că acest fișier trebuie manipulat de către containerul JSP atunci când este cerut.

Containerele JSP rulează înafara serverului Web și sunt legate la serverul Web printr-un soclu (socket). Acest conector operează de regulă scanând toate cererile care vin la server sub formă de identificatori URL și filtrând cererile care au prefixe și sufixe specifice JSP sau containerului servlet.

Containerul JSP execută mai întâi căutarea sursei JSP, apoi îl citește, îl analizează și îl translatează într-un fișier Java. Apoi motorul JSP apelează un compilator pentru a translata fișierul sursă Java într-un fișier de clasă servlet. Clasa Java obținută este apoi încărcată ca servlet în motorul de servleturi al containerului JSP și servletul răspunde clientului. După cererea inițială pagina JSP nu mai este retranslatată, recompilată sau reîncărcată în memorie, doar dacă se fac modificări în sursa JSP sau containerul servlet este oprit sau repornit.

Elemente specifice JSP.

Directive.

JSP dispune de directive de preprocesare care pot fi folosite pentru a se preciza atribute ale răspunsului JSP sau pentru a furniza informații necesare motorului JSP pentru a translata cu precizie și a compila paginile JSP. De asemenea sunt utilizate pentru importarea pachetelor Java, includerea de fișiere sau accesarea librăriilor de taguri.

Sintaxa generală pentru directive:

<%@ directiva … %>

sau

<jsp:directive.directiva … /> (pentru format XML).

Directivele JSP:

page;

include;

taglib.

Directiva page poate fi folosită pentru a importa pachete și clase Java, analog instrucțiunii import, pentru a stabili o sesiune sau pentru a indica adresa paginii pentru eroare.

Atributele cele mai utilizate ale directivei page sunt:

language – specifică limbajul de programare.

import – specifică lista de pachete și clase care trebuie importate în pagina curentă. Pachetele implicite sunt: java.lang.*, javax.servlet.*, javax.servlet.jsp.*, javax.servlet.http.*.

session – indică dacă se stabilește o sesiune. Implicit este true.

buffer – stabilește dimensiunea buffer-ului, exprimată în kilo-octeți.

autoFlash – indică dacă se golește buffer-ul. Implicit este true.

info – dă informații despre pagina JSP. Implicit este șirul vid.

errorPage – indică URL-ul paginii care va fi trimisă clientului în caz de eroare.

isErrorPage – indică dacă este pagina pentru erori.

contentType – specifică tipul documentului returnat. Implicit text/html.

Ea poate fi plasată oriunde în pagina JSP, de preferat la început pentru a fi vizibilă și are efect asupra întregii pagini, inclusiv asupra fișierelor care sunt incluse static. Poate fi folosită de mai multe ori în cadrul aceleași pagini, doar atributele nu au voie să se repete în aceeași pagină, excepție este atributul import.

Exemplu:

<%@page language="java" import="java.sql.*,java.util.*"%>

Directiva include permite inserarea de alte fișiere în pagina JSP. Acest lucru este util atunci când dorim să creăm un site unitar în care fiecare pagină să conțină același meniu, chenar de logare, etc. Astfel se poate administra mai ușor site-ul și se evită duplicarea datelor: o modificare într-un fișier va fi vizibilă în mai multe pagini care-l vor include.

Singurul atribut al acestei directive este file, acesta indică numele fișierului care se dorește a fi inclus.

Exemplu:

<%@include file="Simplu.jsp" %>

Directiva taglib permite includerea de biblioteci de tag-uri definite de programator. Se specifică URL-ul bibliotecii prin atributul uri și prefixul utilizat în pagina Web prin atributul prefix (acesta fixează un prefix unic pentru respectiva librărie de taguri, pentru a nu apărea conflicte la utilizarea unui tag care este definit în două librării diferite).

Elemente de scriptare.

JSP este independent de limbajul de scriptare. Limbajul de scriptare predefinit este Java. De asemenea JavaScript poate fi folosit cu JSP, asemănător cu Java în ceea ce privește sintaxa elementară, dar mult mai simplu.

În JSP există trei categorii de elemente de scriptare:

Expresii

Declarații

Scriplet-uri

Expresiile.

O expresie JSP este o expresie Java care este evaluată la momentul execuției, rezultatul fiind convertit în String și scris în fluxul de ieșire. O expresie validă JSP are forma:

<%=expresie%>

sau

<jsp:expression>expresie</jsp:expression> (format XML)

Observație. Expresia nu se termină cu simbolul ”;”.

Ce conțin expresiile?

Conține o serie de apeluri de metode, creare de instanțe de clase, operatori, variabile.

Declarațiile.

În partea de declarații se pot declara date și metode pentru clasa servlet-ului generat. Sintaxa este următoarea:

<%! declarații %>

sau

<jsp:declaration> declarații </jsp:declaration> (format XML)

Plasarea declarațiilor se poate face oriunde în cadrul paginii JSP.

Exemplu:

Scriplet-uri.

Ele permit adăugarea de cod Java îmbinat cu secvențe HTML. Sintaxa generală este:

<% cod Java%>

sau

<jsp:scriptlet> cod Java </jsp:scriptlet>

Exemplu:

Obiecte disponibile JSP.

Obiectele sunt instanțe de clase. Clasa este unitatea principală de programare din cadrul programării orientate spre obiect. Prin instanțierea unui obiect se înțelege crearea unei instanțe a unei clase în memorie. Paginile JSP devin definiții de clase Java atunci când containerul JSP le translatează în cod sursă Java (servleturi). Există două tipuri de obiecte în JSP:

Cele nouă obiecte implicite JSP: application, config, exception, aut, page, pageContext, request, response și session.

Clasele care sunt importate cu atributul import al directivei page pot fi instanțiate ca obiecte.

Obiectele implicite din JSP reprezintă un set standard de clase preinstanțiate automat de către containerul JSP. Ele sunt folosite pentru formularea răspunsului către client.

S-au folosit obiectele session, request în afișarea coșului de cumpărături.

Scurte exemple din codul sursă al ShoppingCart.jsp unde s-au folosit session, request:

2.3.4 Acțiuni și componente JavaBeans.

În această secțiune o să descriu modul de utilizare al claselor JavaBean în JSP-uri, proprietățile lor cu eticheta <jsp:useBean> standard și cu etichetele (tag-urile) JSP înrudite. Ele se numesc acțiuni standard și folosesc varianta XML. Spațiul de nume utilizat este http://java.sun.com/JSP/Page și de regulă se folosește prefixul jsp.

Ce înțelegem prin JavaBean ?

O clasă JavaBean este o clasă Java generică, codificată cu respectarea unor convenții de denumire și proiectare. Prin intermediul componentelor JavaBeans se oferă posibilitatea utilizării acestora de către instrumente de editare a aplicațiilor fără ca programatorul să intervină direct în codul acestora. De asemenea un avantaj îl constituie facilitatea prin care se poate determina atributele si metodele unei clase.

Cele mai importante lucruri legate de componentele JavaBeans în contextul aplicațiilor Web, sunt:

Constructor public, fără parametri. Constructorul trebuie sa fie public pentru a putea instanția acea clasă Java în orice aplicație, oricând fără a avea drepturi speciale și fără parametri în caz că nu avem cunoștințe anterioare despre cum a fost declarat constructorul. Cel mai simplu e să nu declarăm nici un constructor, caz în care va fi creat automat constructorul implicit.

Atributele nestatice nu vor fi public. Atributele nestatice vor fi declarate private sau protected .

Utilizarea de metode setter si getter pentru accesarea membrilor nestatici.

Principalele elemente ale unei clase JavaBean sunt proprietățile private și metodele publice de tip setter/getter (acestea sunt convențiile de codificare specifice claselor JavaBeans). Ele se numesc setter deoarece sunt folosite pentru schimbarea proprietăților unei clase Java, respectiv getter pentru accesul la unele proprietăți. O proprietate este de fapt o variabilă care a fost declarată în clasa Bean.

Prototipul unei metode setter este:

public void setNumeProprietate(TipProprietate arg)

Trebuie declarată public pentru a putea fi accesată din alte clase sau din pagini Jsp. Apoi void deoarece nu returnează nimic, metodele set sunt de tip write-only. Numele metodei trebuie să înceapă cu set, scris cu litere mici, urmat de o majusculă cu care începe numele proprietății. Nu este obligatoriu ca proprietatea căruia dorim să-i aplicăm o modificare sau să o inițializăm sa aibă același nume cu cel din numele metodei set.

Prototipul unei metode getter este:

public TipProprietate getNumeProprietate()

Analog cu metoda set, se declară public din același motiv. TipProprietate trebuie specificat deoarece o metodă get va returna mereu o valoare. Numele metodei trebuie să înceapă cu get scris cu litere mici, urmat de o majusculă cu care începe numele proprietății.

Se observă că există un tipar în ceea ce privește metodele set și get. Tipul de proprietate transmis ca argument în metoda set este întotdeauna același ci tipul valorii returnate de metoda get. Nu este obligatoriu ca o clasă JavaBean să aibă pentru fiecare proprietate atât o metodă set cât și una get. Ele pot fi folosite și singure, nu neapărat ca pereche.

În aplicația mea am implementat clasa Cosul, unde am folosit aceste tipuri de metode setter/getter:

Acțiuni standard JSP.

O acțiune standard JSP este o etichetă JSP pe care containerul trebuie să o recunoască indiferent de versiune de implementare sau de diferențele dintre serverele folosite. JSP oferă mai multe acțiuni standard pentru instanțierea claselor JavaBean și pentru invocarea metodelor set/get ale acestora.

Lista de acțiuni standard JSP:

<jsp:useBean>

<jsp:setProperty>

<jsp:getProperty>

<jsp:include>

<jsp:forward>

<jsp:param>

Acțiunea <jsp:useBean> se folosește pentru a instanția o clasă Bean. Înainte de a folosi orice altă etichetă sau de a face orice altceva cu o clasă Bean, trebuie să se creeze o instanță a acesteia. Aceasta are mai multe atribute:

Observație: Atributele class si beanName nu se vor utiliza împreună, ele se exclud una pe alta. Dacă există deja o componentă cu același id în domeniul de vizibilitate specificat, se va utiliză acea componentă fără a se mai crea una nouă.

Exemplu: instanțierea clasei Cosul într-o pagină JSP.

<jsp:useBean id="shop" class="cos.Cosul" scope="page"/>

În urma acestei secvențe s-a creat un obiect al clasei Cosul, cu numele shop care are domeniul de vizibilitate pagina curentă.

Pentru setare avem la dispoziție acțiunea <jsp:setProperty>. Atributele acestei metode sunt:

Observație: Se vor utiliza la un moment dat doar unul din atributele param și value.

Exemplu:

Se setează pentru obiectul cu numele ”shop” al clasei specificate în <jsp:useBean>, proprietatea cu numele ”tracțiune” cu valoarea ” integrală”. Se presupune ca este existentă o metodă set cu numele proprietății specificate, în acest caz setTracțiune(….).

<jsp:setProperty name=”shop” property=”tracțiune” value=”integrală”/>

Analog se realizează o setare pentru același obiect si proprietate dar valoarea pentru setare este transmisă prin atributul param:

<jsp:setProperty name=”shop” property=”tracțiune” param=”nume”/>

Accesarea unei proprietății se realizează cu ajutorul tag-ului <jsp:getProperty>. Posedă aceleași atribute ca și <jsp:setPropery>. În exemplul de mai sus, pentru accesarea datei membre (proprietatea) ”tracțiune” pentru obiectul cu numele shop al clasei Cosul se scrie:

<jsp:getProperty name=”shop” property=”tracțiune”/>

La procesarea acestui exemplu se va apela metoda existentă getTracțiune() pentru obiectul shop, se va returna un String.

Acțiunea <jsp:include> se folosește pentru a include un fișier static sau rezultatul execuției unei pagini JSP. Adresa fișierului este specificată de atributul page, iar dacă se dorește golirea fluxului de ieșire sa fie automată se utilizează atributul flush cu valoare true.

cerere jsp:include

răspuns

răspuns

Includerea de pagini JSP cu jsp:include.

Sintaxa acțiunii <jsp:include> este:

Exemplu prima variantă: Toate paginile site-ului conțin următoarele pagini JSP:

Exemplu la varianta a doua: Se include în pagina curentă JSP rezultatul execuției paginii Cautari.jsp, la care se transmite parametrul cu numele ”model” având valoarea ”Cabrio”.

<jsp:include page=”Cautări.jsp” flush=”true”>

<jsp:param name=”model” value=”Cabrio”/>

</jsp:include>

Preluarea parametrului în pagina Cautari.jsp se va face astfel:

<%=request.getParameter(”model”) %>

Similar cu <jsp:include> este marcatorul <jsp:forward> care redirectează cererea. În momentul procesării, la apariția tagu-ului <jsp:forward> se va întrerupe parcurgerea paginii curente, iar controlul este dat paginii specificate în acest tag.

cerere jsp:forward

răspuns

Redirectarea răspunsului cu jsp:forward.

Atributul page specifică pagina către care se realizează redirectarea, iar pentru conținut sunt acceptați doar marcatorii <jsp:param> pentru transmiterea de parametri.

Sintaxa acțiunii <jsp:forward> este:

Acțiunea <jsp:param> definește ce parametru va fi transmis unei alte pagini. Acest tag este folosit, după cum am putut vedea mai sus, în combinație cu etichetele <jsp:forward> și <jsp:include>. Atributele sunt: name – numele parametrului, value – valoarea parametrului. Sintaxa este următoarea:

<jsp:param name=”nume” value=”valoare”/>

Asemănător cu <jsp:param> este tag-ul <jsp:params>. Acesta definește un bloc de parametri ce va fi trimis unui applet sau unei clase Bean. Eticheta se folosește în conjuncție cu tag-ul <jsp:plugin> și conține unul sau mai multe elemente <jsp:param>. Acest element nu primește nici un atribut. Sintaxa este:

<jsp:params>…. <jsp:params>

Exemplu. Se afișează un applet Java, precizând doi parametri:

Interacțiunea cu bazele de date.

Unul din principalele motive pentru care au fost inventate aceste tehnologii Internet, cum ar fi servlet-urile și JSP-urile a fost pentru a se adăuga mai multă interactivitate la ceea ce ar fi fost paginile HTML statice. De aceea fără integrarea unei baze de date este greu de îmbunătățit interactivitatea. Pentru aceasta ne stă la dispoziție API-ul Java Database Connectivity (JDBC).

JDBC este un API Java pentru accesul de tip tabelar de date. Acest API constă dint-un set de clase și interfețe care oferă un mod standard prin care se pot accesa bazele de date relaționale. JDBC se bazează pe drivere scrise de companii software independente și de producătorii de baze de date. Un driver este responsabil pentru stabilirea conexiunii cu baza de date, transmiterea interogărilor SQL și a instrucțiunilor update către sursa de date și pentru procesarea rezultatelor. În realizarea aplicației am ales să folosesc driverul punte JDBC-ODBC.

Procesul obținerii de informații dintr-o bază de date folosind JDBC implică în principiu cinci pași :

înregistrarea driverului JDBC folosind gestionarul de drivere DriverManager;

stabilirea unei conexiuni către baza de date;

execuția unei instrucțiuni SQL;

procesarea rezultatelor;

închiderea conexiunii cu baza de date.

Înregistrarea driverului JDBC folosind clasa DriverManager.

Un driver JDBC este înregistrat automat de managerul de drivere atunci când clasa driver este încărcată dinamic. Pentru aceasta se folosește metoda Class.forName(). De asemenea trebuie copiat driverul JDBC (care este un fișier cu extensia .jar) în directorul WEB-INF\lib sub aplicația dezvoltată (în caz că nu există se va crea).

Class.forName("com.mysql.jdbc.Driver");

Această instrucțiune a creat o instanță a driverului și o înregistrează în DriverManager. Class.forName(String arg) este o metodă statică ce permite mașinii virtuale Java să aloce dinamic, să încarce și să facă o legătură la clasa specificată ca argument printr-un șir de caractere. Dacă clasa nu e găsită se aruncă o excepție ClassNotFoundException.

Stabilirea conexiunii.

O conexiune JDBC este identificată printr-un URL JDBC specific. Sintaxa standard pentru URL-ul bayei de date este:

J

jdbc:<subprotocol>:<nume>

unde prima parte precizează că pentru stabilirea conexiunii se folosește JDBC, partea de mijloc <subprotocol> este un nume de driver valid, <nume> este un nume logic sau alias al bazei de date fizice.

Conectarea se realizează apelând DriverManager.getConnection(), o metodă statică ce returnează un obiect java.sql.Connection:

Connection con = DriverManager.getConnection("jdbc:mysql://localhost/bmw", nume_utilizator, parola);

Argumentele pentru metoda getConnection sunt sursa de date, numele de utilizator și parola. Dacă nu am securizat baza de date, nume utilizator și parola vor fi șirurile vide, pot lipsi. Dacă apar probleme de comunicare cu sursa de date se va genera o excepție SQLException. Aceste erori pot avea diverse cauze: instrucțiuni SQL invalide, nume utilizator sau parolă invalidă sau alte erori de baze de date.

Exemplu. Pentru conectarea la baza de date, în aplicație s-a creat o metodă cu numele connect() care va fi apelată ori de câte ori se dorește o nouă conexiune:

În pagina JSP în care se dorește o conexiune la baza de date, se creează mai întâi o instanță la clasa BookmarkBean1 astfel

<jsp:useBean id="bb" scope="session" class="ana.BookmarkBean1"/>,

apoi se apelează metoda connect() astfel: bb.connect();

Execuția unei instrucțiuni SQL.

După ce s-a realizat conexiunea, se pot trimite instrucțiuni SQL la baza de date. API-ul JDBC nu verifică corectitudinea instrucțiunii și nici apartenența ei la un standard SQL. API-ul JDBC specifică trei interfețe pentru implementarea de interogări către bazele de date, fiecăreia îi corespunde o metodă specială în clasa Connection, de creare a instanțelor respective. Ele sunt prezentate în tabelul următor:

Pentru execuția unei instrucțiuni SQL neparametrizată, se folosește metoda createStatement() aplicată unui obiect Connection.

Statement instr=con.createStatement();

Se pot aplica apoi una din metodele:

executeQuery();

executeUpdate();

execute();

obiectului Statement pentru a trimite instrucțiunile SQL.

Metoda executeQuery() este folosită când interogările returnează mulțimi rezultat (instanțe ale clasei ResultSet), de exemplu în cazul interogărilor SELECT. Obiectul de tip ResultSet returnat de apelul acestei metode va conține înregistrările din baza de date care verifică condițiile din instrucțiunea SELECT scrisă de noi.

Exemplu: O metodă ce realizează un SELECT în funcție de parametrii transmiși, va întoarce un obiect ResultSet ce păstrează rezultatele obținute.

Metoda executeUpdate() se aplică unui obiect Statement este folosită pentru operațiile de actualizare a bazei de date cum ar fi: modificări (UPDATE), ștergeri (DELETE), sau inserări (INSERT) în baza de date. Apelul acestei metode nu întoarce un ResultSet, deoarece nu este o interogare, ci returnează un întreg care reprezintă numărul înregistrării afectate.

Metoda execute() este folosită în cazul în care se obțin mai mult de o mulțime rezultat.

Exemplu: O metodă care introduce date în tabela masini_comandate: numărul comenzii, id mașinii comandate și cantitatea comandată.

Procesarea rezultatelor.

Se parcurg înregistrările unui obiect din clasa ResultSet folosind metoda next(). Un obiect ResultSet menține un cursor care indică linia de date curentă. Metoda next() avansează cursorul la linia următoare și întoarce true dacă nu s-a ajuns la sfârșitul mulțimii de date și false dacă s-a depășit ultima linie din obiectul ResultSet. Se utilizează frecvent într-un ciclu while.

Exemplu. Preluarea înregistrărilor din obiectul ResultSet returnat de metoda detaliu1() scrisă mai sus.

Închiderea conexiunii.

Este recomandat să se închidă explicit conexiunea la baza de date. Pentru aceasta este apelată metoda close() aplicată obiectului Connection. De asemenea se închid și obiectele Statement și ResultSet, dar trebuie înaintea închiderii conexiunii la baza de date.

Capitolul 3. Prezentare aplicație.

Descriere generală.

Acest capitol prezintă o aplicație de comerț electronic: un showroom online de prezentare marca BMW.

Aplicația implementează un magazin online deoarece în ultimi anii o dată cu răspândirea spațiului WWW a crescut considerabil și numărul utilizatorilor Web, aceștia putând deveni foarte ușor potențiali clienți. Oricine poate fi clientul acestui magazin, este suficientă o conexiune la Internet și un browser pentru navigare. Astfel realizând un magazin online se oferă clienților o multitudine de servicii și facilități, în special economisire de timp. Site-ul se adresează în special amatorilor și pasionaților de mașini BMW, precum și tuturor utilizatorilor Web care doresc achiziționarea online foarte rapidă a unei astfel mașini.

Site-ul de față are un conținut dinamic care permite interacțiunea cu utilizatorul, urmărindu-se satisfacerea intereselor sale, oferindu-i o gamă largă de servicii: acces la un catalog de modele BMW, un coș de cumpărături, modalități de plată și livrare sigure și rapide, posibilități de căutare după diverse criterii (CarConfigurator), un top al celor mai vândute modele BMW și multe altele.

Soluția software aleasă pentru dezvoltarea acestui magazin virtual este cea folosind JSP, HTML, MySQL, Java, CSS. Principalele avantaje oferite de această soluție au fost prezentate în capitolele anterioare.

Prima pagină a site-ului se numește bmw1.jsp:

Fig 3.1 Vizualizare prima pagină a magazinului.

Pagina principală a magazinului oferă printr-o interfață prietenoasă, posibilitatea de a naviga prin magazin. Ea este împărțită în mai multe pagini .jsp:

meniul_bun.jsp care afișează un meniu cu toate modelele existente BMW sortate după serie, care sunt link-uri către paginile de detalii (prezentare.jsp, design.jsp, motorizare.jsp, motor.jsp). Acest meniu facilitează căutarea unui model în funcție de seria BMW la care aparține.

un link către pagina Prezentare_bmw.jsp care extrage dinamic toate seriile BMW, iar pentru fiecare serie sunt afișate toate modele BMW existente.

Vandute.jsp extrage dinamic cele mai vândute modele BMW și le afișează, ele fiind link-uri către pagina de detalii tehnice motor.jsp.

Login.jsp afișează formularul de logare în partea dreaptă a paginii, în caz că utilizatorul are deja un nume și parolă. În caz că logarea s-a realizat cu succes, se verifică de asemenea dacă clientul este chiar administratorul magazinului. Dacă da el este trimis la pagina Admin.jsp, altfel utilizatorul obișnuit este direcționat către pagina Catalog.jsp unde poate vizualiza catalogul cu toate modele BMW și le poate adăuga în coș pentru o posibilă comandare. Dacă utilizatorul nu este înscris sau a uitat parola , există un link de înregistrare sau de recuperare parolă.

Info_Cos.jsp afișează informații legate de coșul clientului cum ar fi numărul de produse depuse în coș și totalul de plată din acel moment. Dacă acesta nu este logat aceste informații sunt inițializate cu 0. De asemenea există un link care dă posibilitatea de vizualizare detaliată a produselor existente în coș.

Cautari.jsp afișează un chenar cu link-uri către diferite criterii de căutare pe care utilizatorul le-ar dori face:

După preț (Caut_pret.jsp);

După serie (Caut_serie.jsp);

După model (Caut_model.jsp);

CarConfigurator (Configurator.jsp).

Vandute_chenar.jsp efectuează și afișează dinamic un top al celor mai vândute modele BMW, fiecare model afișat, fiind un link către pagina de detalii tehnice a acestuia.

Din această divizare a paginii vor fi păstrate mai departe în aproape toate paginile site-ului, făcând excepție doar interfața adresată administratorului, următoarele pagini JSP: meniul_bun.jsp (în partea de sus a paginii), Login.jsp, Info_Cos.jsp, Cautari.jsp, Vandute_chenar.jsp (toate în partea dreaptă a paginii).

3.2. Proiectarea bazei de date.

Majoritatea site-urilor cu conținut dinamic folosesc un sistem de baze de date. Pentru stocarea informațiilor referitoare la mașini, utilizatori, coșurile clienților și comenzile făcute de aceștia s-a folosit o bază de date de al cărei management se ocupă serverul MySQL.

S-a creat o bază de date cu numele bmw. Lista tabelelor bazei de date utilizate este:

masini – reține datele tehnice ale mașinii. Cheia primară este un id care determină în mod unic fiecare înregistrare.

detalii – păstrează informațiile legate de descrierea mașinii precum design, siguranța, motorizare, imagine pentru detalii tehnice, imagine design, etc. Cheia primară este un id care determină în mod unic fiecare înregistrare.

utiliz – reține datele personale ale utilizatorilor (nume, prenume, adresă, oraș, stat, țară, cod zip). Cheia primară este câmpul userid (numele de logare) care este unic pentru fiecare utilizator.

cos – informații legate de coșul clientului: id-ul produsului adăugat (cheie străină), userid-ul clientului (cheie străină), data depunerii în coș, cantitatea adăugată și orderId (numărul de ordine al produsului adăugat) este cheia primară.

comenzi – păstrează comanda făcută: nr_comanda este cheie primară și reprezintă numărul de ordine al comenzii, userid (cheie străină) este userul care a efectuat comanda, data este data comenzii, trimis este un câmp care reține dacă s-a expediat comanda la client sau nu.

masini_comandate – este legată de tabela comenzi prin câmpul nr_comandă. (nr_comanda, id) este o cheie primară compusă, id (cheie străină) este id-ul produsului din tabela mașini, iar nr_comanda (cheie străină) este numărul comenzii reținut în tabela comenzi, cantitate este preluată din tabela cos.

administrator – are un unic câmp userid care reține numele de logare al administratorului.

Tabela masini. Tabela detalii.

Tabela utiliz. Tabela cos.

Tabela comenzi. Tabela masini_comandate.

Tabela administrator.

Fig 3.2 Relaționarea tabelelor.

Arhitectura aplicației.

Aplicația a fost dezvoltată având în vedere următoarele elemente:

autentificare utilizatori;

catalog de produse, pagini de detalii mașină, coș de cumpărături, realizare comandă;

căutare după diferite criterii;

top vânzare;

administrare magazin.

Fig 3.3 Schema arhitecturală a site-ului.

Autentificare utilizatori.

Autentificarea se referă la o modalitate de identificare a posibililor clienți ai magazinului. Aceasta se realizează printr-un nume și parolă, unice ca pereche pentru fiecare utilizator. Dacă utilizatorului dorește acces la un coș de cumpărături el trebuie mai întâi să se înregistreze. Dacă nu are un cont deschis trebuie să completeze un formular de înscriere, prin care se rețin un nume de logare, o parolă și datele sale personale. Numele folosit pentru logare este unic pentru fiecare utilizator în parte, de aceea dacă el alege un userid care există deja, va primi un mesaj de avertizare și va fi nevoit să aleagă altul.

Fig 3.4

Cu acest nume și parolă el va putea beneficia mai departe de serviciile magazinului: vizualizare catalog BMW, acces la coș și posibilitatea de a da comandă.

Metoda următoare verifică dacă există numele de logare și parola dată de utilizator la autentificarea sa. Numele de logare și parola sunt transmise ca parametri metodei de mai jos. Metoda face parte din clasa UserBean1 aflată în directorul C:\Tomcat 5.5\webapps\bmw\WEB-INF\classes\cos.

Dacă valoarea returnată de această metodă este true, atunci numele și parola sunt valide și clientul este direcționat la pagina de catalog BMW Catalog.jsp, altfel îi apare un mesaj de eroare.

Pagina Proces.jsp verifică dacă autentificarea a fost corectă (cu ajutorul metodei de mai sus), dacă da atunci se verifică dacă clientul este chiar administratorul site-ului pentru al direcționa în altă parte decât pe un client obișnuit.

Recuperare parolă.

Dacă utilizatorul și-a uitat parola va apărea mesajul: ”Nume si parola invalida. Incearcă din nou!”. Pentru recuperarea parolei utilizatorul este obligat să-și dea din nou datele personale, pentru a putea verifica că este vorba de aceeași persoană. Dacă ele coincid cu cele date la înscriere (care sunt deja stocate în baza de date), va apărea un mic formular în care userul își poate alege noua parolă pe care o va folosi mai departe pentru autentificare. Această parolă o va înlocui pe cea veche, pe care el o uita-se.

Catalog prezentare BMW.

Fig 3.5 Vizualizare Catalog BMW.

Pagina de catalog BMW Catalog.jsp extrage dinamic din baza de date informații legate de categorie, model, tip de motorizare și preț al tuturor mașinilor. Astfel se pot vizualiza toate modelele existente. Pentru mai multe detalii legate de o categorie și un model anume, se dă click pe categoria BMW. Acest link va duce la pagina de prezentare a modelului, numită seria1 .jsp. Pentru detalii legate de motorizarea mașinii, se dă click pe motorul mașinii, acesta va direcționa utilizatorul la pagina de detalii tehnice motor.jsp. De asemenea se dă posibilitate clientului de a adăuga în coș modelul BMW dorit. Butonul adaugă va duce clientul la pagina Comanda.jsp care afișează un formular în care sunt înregistrate informații despre mașina care se dorește a se păstra în coș. Se mai cere să se specifice numărul de mașini dorite. Dacă se dă submit la acest formular modelul s-a adăugat în coș. În partea de jos a paginii sunt disponibile legături spre paginile următoare sau precedente, pe fiecare pagină a catalogului fiind afișate maxim 19 înregistrări. Din pagina de catalog se poate avea acces la coșul de cumpărături (link-ul din partea de sus a paginii, din partea de jos sau din chenarul din dreapta), la diverse modalității de căutare, la topul celor mai vândute mașini sau se poate alege opțiunea de ieșire din Catalog.

Metoda getAfisareProduse(Connection con,int inf,int sup) extrage informațiile necesare pentru catalogul BMW, ea face parte din clasa Catalog. Codul ei este următorul:

Următorul cod afișează dinamic catalogul de modele BMW, este o parte a paginii Catalog.jsp.

Pagina de detalii mașină.

Informații detaliate despre un anumit model se pot obține foarte simplu cu ajutorul meniului prezent în toate paginile site-ului sau din Catalogul BMW, unde există un link care va face legătura către pagina de prezentare numită seria1.jsp.

Exemplu :

Fig 3.6 Pagină prezentare model BMW.

Pagina seria1.jsp generează dinamic informațiile legate de prezentarea modelului BMW, precum și o poză a acestuia. De-asemenea sunt disponibile link-uri către paginile de design, detalii tehnice, siguranță a mașinii.

Metoda detaliu1(String cate, String model) aparține clasei BookmarkBean1, ea preia din baza de date toate informațiile despre mașină, care este transmisă în funcție de doi parametri: categorie și model . Codul ei este următorul:

Metoda de mai sus returnează un obiect de tip ResultSet care păstrează informațiile dorite. Ea va fi apelată în pagina seria1.jsp, care afișează imaginea din fig 3.4. Codul sursă al paginii seria1.jsp este următorul:

Coșul de cumpărături.

Accesul la un coș de cumpărături se poate face doar după ce utilizatorul s-a logat cu succes, în caz contrar el primește un mesaj de eroare și este direcționat pe pagina curentă.

Imaginea următoare reprezintă coșul unui client care conține trei modele BMW.

Fig 3.7. Vizualizare coș.

Fiecare produs adăugat în coș este afișat pe coloane conținând: serie, model, tip motor, preț, data adăugării în coș și cantitatea dorită. De asemenea clientul are opțiunea de a șterge din coș dacă s-a răzgândit, doar dând click pe butonul de ștergere din dreptul produsului, în urma căruia acel produs va fi șters din coș. Clientul poate vedea cât are de plătit până în acel moment în partea dreaptă a tabelului, unde este calculat totalul. O dată aflat în coș utilizatorul are două variante. Prima variantă să continue să adauge în coș prin link-ul la pagina de Catalog BMW (Catalog.jsp) din partea de sus sau jos a paginii sau dând click pe butonul Înapoi. A doua variantă este să efectueze comanda apăsând butonul Comandă care îl va trimite la pagina Cumpar.jsp. În caz că nu dorește să mai continue cumpărăturile, utilizatorul trebuie doar să dea click pe link-ul Iesire, din partea de sus sau jos a paginii și el va fi direcționat la prima pagină a site-ului bmw1.jsp.

Un client poate adăuga în coș o mașină BMW fie din pagina de Catalog BMW sau din pagina de detalii tehnice prin intermediul butonului Adaugă. Acest buton va duce clientul la pagina Comanda.jsp care afișează un formular în care sunt înregistrate informații despre mașina care se dorește a se păstra în coș. Se mai cere să se specifice numărul de mașini dorite. Dacă se dă submit la acest formular, modelul s-a adăugat în coș.

Adăugarea în coș este implementată de metoda adaugaCos care face parte din clasa Catalog. Ea primește ca parametri: conexiunea curentă, userid-ul cu care este înregistrat utilizatorului curent, id-ul mașinii care este cheie primară în tabela mașini, și cantitatea dorită. Valorile acestor parametri împreună cu data adăugării în coș, vor fi inserate în tabela Cos. Ea va returna true dacă s-a realizat cu succes inserarea în tabela Cos, altfel false.

Metoda adaugaCos are următorul cod:

Vizualizarea coșului virtual din figura 3.4 este implementată cu ajutorul metodei AfisareCos a clasei Cosul. Parametrii metodei sunt: conexiunea la baza de date și userid-ul clientului curent. Codul ei este:

Metoda de mai sus este apelată în interiorul paginii ShoppingCart.jsp, care generează imaginea coșului virtual din figura 3.4.

Ștergerea unui model din coș, în cazul în care clientul nu mai dorește să-l cumpere este implementată de metoda StergeProdus din clasa Cosul. Ea primește ca parametri: conexiunea curentă, orderId care este cheie primară în tabela Cos și reprezintă numărul de ordine al produsului în Coș, userId este numele cu care s-a înregistrat clientul. Ea va returna true dacă s-a realizat cu succes ștergerea din coș și false în caz contrar. Codul metodei este următorul:

Efectuarea comenzii.

Realizarea comenzii se poate face doar din pagina de vizualizare a coșului, având la dispoziție butonul Comandă, care face legătura către pagina Cumpar.jsp. Această pagină afișează un formular în care se cer informații despre facturare și expediere ( adresă de livrare, oraș, stat, cod zip). Ele se vor păstra în baza de date, în tabela utiliz, înlocuindu-le pe cele dinainte. Dacă se dă submit la acest formular, va apărea o confirmare cu mașinile BMW comandate. În cazul în care nu erau suficiente mașini pe stoc din cele cerute pentru comandă, va apărea un mesaj care informează câte mașini s-au putut comanda și totalul de plată. După ce s-a realizat comanda, coșul clientului se golește.

Pentru a înlătura redundanta bazei de date, s-au creat două tabele pentru realizarea corectă a comenzii: comenzi și masini_comandate. Tabela comenzi conține câmpurile: nr_comanda care este și cheie primară, data efectuării comenzii, un câmp numit trimis care ține minte dacă s-a livrat comanda, userid care este numele de logare al clientului. Tabela masini_comandate va reține câmpul nr_comanda (numărul de ordine al comenzii făcute), id-ul produsului din tabela masini și cantitatea cerută. (nr_comanda,id) formează o cheie primară compusă.

Metodele numite comenzi și masini_comanda implementează comanda, ele fac parte din clasa Admin. Metoda comenzi primește ca parametri: conexiunea curentă, userid-ul cu care este înregistrat utilizatorului curent. Valorile acestor parametri, împreună cu data efectuării comenzi și valoarea implicită ”nu” pentru câmpul trimis (se presupune că nu a fost expediată comanda) vor fi inserate în tabela comenzi.

Metoda masini_comandate realizează inserarea în tabela masini_comandate. Primește ca parametri: conexiunea curentă, numărul comenzii, id-ul mașinii și cantitatea.

Următoare secvență de cod face parte din pagina Inreg_comanda.jsp, ea va apela metodele descrise mai sus, prin instanțierea unui obiect al clasei Cosul. Mai întâi se inserează informații despre comandă în tabela comenzi. Pentru userul curent se extrage valoarea câmpului nr_comanda din tabela comenzi pentru a introduce valoarea sa în tabela masini_comandate. Tot pentru userul curent se extrag din coș pe rând produsele comandate. Dacă cantitatea de pe stoc pentru fiecare produs e mai mare sau egală cu cea din coș atunci comanda e efectuată corect, se introduc informații despre comandă și în tabela masini_comandate. Altfel se efectuează comanda cu cantitatea existentă pe stoc în acel moment. La final clientul primește o confirmare a comenzii comanda făcute. Se reactualizează pe stoc cantitatea care a mai rămas pentru fiecare produs din cele comandate și la final se golește coșul clientului curent.

Metoda care golește coșul utilizatorului după realizarea unei comenzi este următoarea (aparține clasei Cosul):

Căutarea după diverse criterii.

O caracteristică esențială a aplicaților dinamice este găsirea informațiilor cerute după anumite criterii.

Site-ul pune la dispoziția utilizatorului mai multe opțiuni de căutare a unei mașini:

după preț, după model, după serie sau îi dă posibilitatea de a-și configura mașina.

Căutarea după preț este implementată de pagina Caut_pret.jsp. Se alege intervalul de preț dorit. Se transmit parametrii: prețul minim și prețul maxim între care se face căutarea, la aceeași pagină. Se preiau acești parametri și se transmit unei metode care realizează propriu-zis căutarea în baza de date. Această metodă se numește caut_pret, face parte din clasa BookmarkBean1. Parametri ei sunt: min și max reprezintă intervalul de căutare al prețul, inf reprezintă poziția unde a rămas cursorul după extragerea datelor, iar sup indică câte înregistrări să se preia la pasul curent. Ea returnează un obiect de tip ResultSet care va fi preluat în pagina Caut_pret.jsp. Codul metodei este următorul :

Un exemplu de căutare este prezentat în imaginea următoare: sunt afișate toate modelele care au preț peste 50 000 euro.

Fig 3.8. Cautare dupa pret.

Căutarea după model și serie se face după același concept de implementare.

CarConfigurator este o căutare care afișează informațiile găsite în funcție de selecțiile făcute de utilizator. Opțiunile de căutare sunt: categorie, model, tracțiune, motor și combustibil. Dacă de exemplu utilizatorul alege un anume model și specifică ce combustibil dorește, rezultatul căutării vor fi toate mașinile din baza de date care respectă aceste alegeri. Paginile care implementează CarConfiguratorul sunt: Configurator.jsp, Car.jsp, Categ_selectie.jsp, Model_selectie.jsp, Tractiune_selectie.jsp, Motor_selectie.jsp, Combustibil_selectie.jsp. Ele transmit de la una la alta parametri care rețin alegerile făcute de utilizator, apoi sunt transmiși mai departe unor metode din clasa BookmarkBean1 pentru a realiza căutarea. În Car.jsp se instanțiază un obiect la clasa BookmarkBean1 și se apelează metoda ce are următorul prototip:

public ResultSet rezultate_selectie(String categ,String model,String trac,String comb,String motor,int inf,int sup)

Se preiau înregistrările păstrate în obiectul ResultSet și se afișează la utilizator. Pe o pagină sunt afișate maxim 7 rezultate, pentru a vedea și restul informațiilor găsite se merge la pagina următoare. Următoarea imagine afișează rezultatele unei căutări în cazul în care utilizatorul a făcut câte o selecție pentru categorie, tracțiune și combustibil.

Fig 3.9 CarConfigurator.

Topul celor mai vândute mașini BMW.

Acest top este vizibil pe toate paginile site-ului, el afișează primele 5 modele BMW care sunt cel mai des comandate de clienți. Se afișează modelul și motorul, ele fiind link-uri către pagina de detalii tehnice Motor.jsp. Topul este implementat de pagina Vandute_chenar.jsp. În această pagină se instanțiază un obiect al clasei BookmarkBean1, cu ajutorul lui se apelează metoda max_vandute() care extrage din baza de date id-ul pentru modelele cele mai vândute. Metoda max_vandute() are următorul cod:

Fig 3.10 Top vânzări.

Administrarea aplicației.

Interfața de administrare nu este vizibilă unui utilizator obișnuit, ci doar unor persoane autorizate cu drept de administrare a magazinului. Când se completează formularul de logare, se verifică dacă utilizatorul este chiar administratorul. În acest caz el va fi direcționat către pagina numită Admin.jsp, nu către pagina de catalog BMW (Catalog.jsp) unde este trimis un utilizator obișnuit. Acest modul pune la dispoziția administratorului mai multe servicii:

adăugare de noi informații și noi tipuri de motorizări pentru un model specificat;

modificare date tehnice și detalii de prezentare;

ștergere informații;

vizualizare comenzi;

vizualizare utilizatori.

Fig 3.11 Meniu administrare.

Imaginea de mai sus este implementată de pagina Admin.jsp, reprezintă prima pagină de administrare a magazinului de unde se poate alege unul din serviciile prezentate mai sus.

Adăugarea.

Se pot face două tipuri de adăugări în baza de date: date tehnice sau informații legate de prezentare, design, siguranță etc.

Pentru a adăuga date tehnice se alege butonul Adaugă date tehnice care va trimite administratorul la pagina Adaug_tehnic.jsp. Această pagină afișează dinamic un formular cu toate datele tehnice ale unei mașini. Se completează formularul cu noile date, se dă submit, se transmite formularul tot la pagina Adaug_tehnic.jsp, se preiau câmpurile și se transmit ca parametri la metoda numită adaug_model(cb.getConnection(),categ,con_urban,con_extra,motor,cilindri,cap_cilindrica,putere,cuplu,cauciucuri,jante,greutate,vit_max,acc,comb,tractiune,motorizare,pret,cantitate) care realizează inserarea în tabela masini. Pentru a vedea noua motorizare introdusă se merge la pagina de detalii tehnice a modelului pentru care s-a făcut adăugarea.

Fig 3.12 Vizualizare formular adăugare.

Analog se face și adăugarea de informații legate de prezentare, design, siguranță, etc. Din pagina de administrare se alege butonul Adauga detalii care trimite administratorul la pagina Adaug_model.jsp care va afișă un formular asemănător cu cel din figura 3.9, dar care va conține alte câmpuri (prezentare, design, siguranță, poză prezentare, poză tehnică, poză CarConfigurator, etc). Adăugarea se face pe același concept ca mai sus.

Modificarea.

Administratorul are posibilitatea de a modifica atât datele tehnice cât și informațiile despre un anumit model. Pentru a putea modifica date tehnice se alege butonul Modifica date tehnice din meniul de administrare, care va trimite la pagina Modific_date.jsp. Această pagină afișează un mic formular în care trebuie aleasă categoria și modelul pentru care se dorește o modificare. Dacă se dă submit se transmite formularul la pagina Modific_tehnic.jsp. Aici se preiau câmpurile formularului categoria și modelul, și se afișează toate motorizările corespunzătoare lor într-un formular. Se alege o motorizare, se dă submit și se trimite formularul la aceeași pagină. Pentru acest motor se extrag din baza de date toate datele tehnice și se afișează într-un nou formular. Astfel se poate modifica orice informație, după care se dă submit pentru a înlocui vechea valoarea cu cea nouă pentru câmpurile dorite. Formularul este trimis la pagina Modificat.jsp care preia câmpurile și le transmite metodei modif_model ce face parte din clasa Admin a pachetului cos. Corpul metodei este următorul :

Modificarea informațiilor legate de prezentare, design, etc a mașinii se face după același concept ca modificarea datelor tehnice.

Ștergerea.

Pentru ștergerea unei motorizări se alege din meniul de administrare butonul de Sterge date tehnice care va trimite administratorul la pagina Sterge_date.jsp. Ca și la modificare, apare un scurt formular pentru a alege categoria și modelul pentru care se dorește ștergerea. Se dă submit și formularul este trimis la pagina Sterge_tehnic.jsp, unde se preiau câmpurile lui: categoria și modelul și se afișează dinamic toate motorizările lor într-un formular. Se alege motorizarea care se dorește a fi ștearsă și se dă din nou submit la formular. El este trimis la aceeași pagină, se preia câmpul motor și se caută în baza de date id-ul înregistrării (cheia primară din tabela masini) care are categoria, modelul și motorul respectiv. Apoi se apelează metoda sterge_model(cb.getConnection(),id) a clasei Admin, care realizează ștergerea propriu-zisă.

Ștergerea de informații despre un anume model se poate realiza alegând din pagina de administrare butonul Sterge_detalii. Conceptul de ștergere în acest caz este asemănător cu cel de dinainte.

Vizualizare comenzi.

Pentru a putea vedea toate comenzile efectuate de clienți, se alege din meniul de administrare link-ul Vizualizare comenzi care face legătura către pagina Vizualizare_comenzi.jsp. Aceasta afișează imaginea de mai jos.

Fig 3.13 Vizualizare comenzi.

Fiecare comanda se afișează astfel: numele clientului care a făcut comanda, numărul de ordine al comenzii, modelul și tipul de motorizare ales, cantitatea dorită, data comenzii și o coloană numită trimis care ține minte dacă s-a expediat comanda la client. De asemenea este calculat totalul de plată al clientului. Pentru a vedea lista completă de comenzi se dă link pe Pagina următoare, pe fiecare pagină sunt afișate maxim 4 comenzi.

Numele clientului este un link către pagina Info_user.jsp care afișează informații despre el precum nume, prenume, adresă, oraș, etc. Aici administratorul poate modifica valoarea câmpului trimis cu ajutorul unui scurt formular.

Ștergerea unei comenzi, în cazul în care ea a fost expediată și administratorul nu mai dorește să o păstreze se face cu ajutorul link-ului Sterge care transmite ca parametru numărul comenzi (nr_comandă este cheie primară în tabela comenzi) la pagina Sterge_comanda.jsp. Aici se apelează două metode ale clasei Admin sterge_comenzi(cb.getConnection(),nr_comanda) și sterge_masini_comandate(cb.getConnection(),nr_comanda) care efectuează ștergerea comenzii din cele două tabele comenzi și masini_comandate (se șterg înregistrările care au câmpul nr_comandă egal cu valoarea parametrului nr_comanda al metodelor de mai sus).

Vizualizare utilizatori.

Administratorul poate vizualiza lista tuturor utilizatorilor, alegând din meniul de administrare link-ul Informații utilizatori care face legătura la pagina Utiliz.jsp. Aceasta afișează pentru fiecare utilizator nume, prenume, adresă, etc necesare pentru livrarea comenzii. Administratorul are posibilitatea de a șterge un utilizator având la dispoziție link-ul Sterge care trimite la pagina Sterge_utiliz.jsp ca parametru userid-ul persoanei (care este cheie primară în tabela utiliz). Se preia parametrul userid, se apelează metoda sterge_user(cb.getConnection(),userid) a clasei UserBean1, care realizează ștergerea din tabela utiliz a user-ului specificat de al doilea parametru al metodei.

Capitolul 4. Concluzii.

Lucrarea de față a avut ca obiectiv principal să descrie aplicabilitatea următoarelor tehnologii Web: servleturi și JSP-uri prin implementarea unei aplicații complexe: realizarea unui magazin virtual. Avantajele alegeri acestei soluții software sunt prezentate mai jos:

Performanța. Servleturile rulează în același spațiu de proces ca și serverul și sunt încărcate doar o singură dată. Astfel ele sunt capabile să răspundă mai rapid și eficient la cererile clienților.

Compilarea în byte coduri Java oferă execuții rapide față de programele scrise în limbaje de scriptare. Multe erori sunt îndepărtare încă de la compilare, servleturile devenind mai stabile.

Rezistența la blocarea platformei. Mașina virtuală Java nu permite servleturilor accesul direct la locațiile de memorie, deci se elimină posibilitatea blocării sistemului ca rezultat al accesului la memoria invalidă.

Portabilitatea platformei. Permite servleturilor să fie distribuite ușor fără a rescrie codul pentru fiecare platformă. Servleturile operează identic, fără modificări când rulează pe Unix,Windows sau alt system de operare.

Portabilitatea serverelor. Se referă la posibilitatea rulării servleurilor pe orice server Web.

Durabilitate. Servleturile rămân în memorie până când există o instrucțiune specifică de distrugere a lor. Astfel, ele necesită doar o instanțiere pentru a satisface mai multe cereri.

Încărcare dinamică. Acest lucru asigură pentru servleturi nefolosite neconsumarea resurselor. Se încarcă doar când sunt folosite.

Extensibilitate. Punerea la dispoziția programatorului de biblioteci de clase Java, drivere de baze de date.

Concurența. Natura concurențială a servleturilor permite rezolvarea cererilor clienților în fire de execuție separate într-un singur proces.

Orientarea obiect. Servleturile furnizează o arhitectură simplă și elegantă pentru dezvoltarea aplicațiilor. ServletAPI încapsulează toate informațiile esențiale și funcționalitatea în obiecte abstracte: cereri, răspunsuri, sesiuni, cookie-uri.

Independența de protocol. Servleturile sunt deseori folosite pentru extinderea funcționalității serverelor Web, fiind independente de protocol.

Securitate. Fiind clase Java, nu sunt posibile accesele nevalide la memorie.

JSP-urile au la bază tehnologia servleturilor, ele permit crearea de pagini Web dinamice. Ele sunt mult mai ușor de implementat decât servleturile, oferă posibilitatea de a crea aplicații Web complexe, care să poată utiliza: componente JavaBeans, conexiuni la baze de date și mai ales întregul suport oferit de limbajul Java.

Partea a treia a lucrării a urmărit să prezinte o soluție de implementare a magazinului cât mai eficientă, dinamică care să satisfacă nevoile utilizatorului. S-au prezentat modulele care alcătuiesc aplicația, modul lor de interacționare, modalități de abordare și posibilități de implementare cu ajutorul unor secvențe de cod-sursă și imagini.

Bineînțeles, aplicația implementată poate fi în continuare dezvoltată. Se pot implementa mai multe modalități de plată a comenzii, se pot adăuga dotări pentru mașini, etc. Nivelul actual de complexitate al aplicației este suficient pentru a prezenta o modalitate de utilizare a tehnologiilor Web: JSP și servleturi.