Servlets en JSP's

Intro Servlets en JSP's

Servlets zijn java-programma's die door een webserver worden uitgevoerd als een browser daar om vraagt. Een browser stuurt een http-request naar de server. De request komt bij de servlet terecht en in de java-code van de servlet ligt vast welke response door de server teruggesturd zal worden. Als de response naar de browser is gestuurd is dat voor wat betreft het http-protocol einde-verhaal. Het http-protocol is een stateless protocol: nadat de response naar de browser is teruggestuurd is er in het http-protocol geen informatie opgeslagen dat er ooit contact is geweest tussen client en server.

In toepassingen waarin het wel van belang is om te onthouden dat er al eerder een request van de browser is geweest moet dit dus buiten het http-protocol om geprogrammeerd worden. Een typisch voorbeeld van een dergelijke applicatie is het winkelwagentje. Een grbuiker loopt door een aantal pagina's van een folder en als er iets interessants is dat gekocht moet worden stopt hij dat in het winkelwagentje. Aan het einde van het programma kan dan de inhoud van het wagentje nog eens worden bekeken en vervolgens met een druk op de knop worden besteld. Het programma moet dus voortdurend bijhouden welke artikelen tot dusver al in het winkelwagentje zijn gelegd.

Het bijhouden van het winkelwagentje zou je zelf kunnen programmeren door bij het eerste contact met een browser een uniek persoonsId te genereren en dit id bij elke response mee te sturen naar de browser. Als vervolgens de browser bij elke nieuwe request dat id ook weer meestuurt naar de server, dan kunnen in een servlet bijhouden welke artikelen tot dusver voor die perssonId in een winkelwagentje zijn beland. Zo zou het kunnen, maar java biedt een eigen oplossing voor dit algemene probleem: de java Session object.

JSP's zijn, ook al zien ze er heel anders uit, eigenlijk ook servlets. In een JSP staat de html-code die naar de browser gestuurd gaat worden centraal. Naast die html-tags kan ook output naar de browser worden gegenereerd door java-code aan te roepen.

Alle programma's bij een web-applicatie runnen in een context. Het is mogelijk om vanuit een servlet andere servlets/ JSP-pagina's aan te roepen.

Hieronder volgt in vogelvlucht een korte samenvatting van de belangrijkste classes. Voor een uitgebreide introductie wordt verwezen naar de J2EE tutorial van Sun.

HttpServletRequest en HttpServletResponse classes

De beschrijving van de HttpServletRequest interface begint als volgt:

  • Extends the ServletRequest interface to provide request information for HTTP servlets.
  • The servlet container creates an HttpServletRequest object and passes it as an argument to the servlet's service methods (doGet, doPost, etc).

De inhoud van de doGet en de doPost moeten door de programmeur worden gevuld met code waarin oa. wordt beschreven hoe de response zal zijn. Begonnen wordt met het lezen van het met doGet en/of doPost meegestuurde HttpServletRequest-object en (na eventuele extra gevraagde acties) het schrijven naar het met doGet en/of doPost meegestuurde HttpServletResponse-object. Om de informatie uit een request op te halen heeft een HttpServletRequest allerlei getXXXX-methodes. Een erg belangrijke is de getSession die het HttpSession-object teruggeeft als er al een session-object voor de request is.

Een belangrijke methode die geerfd is van ServletRequest is getRequestDispatcher. Met deze methode kan een Dispatcher-object worden verkregen waarmee o.a. de controle naar een andere servlet of JSP-pagina kan worden doorgegeven.

De beschrijving van de HttpServletResponse interface begint als volgt:

  • Extends the ServletResponse interface to provide HTTP-specific functionality in sending a response. For example, it has methods to access HTTP headers and cookies.
  • The servlet container creates an HttpServletResponse object and passes it as an argument to the servlet's service methods (doGet, doPost, etc).

Context, Session en Request classes

Zoals uit de volgende links naar ServletContext HttpSession HttpServletRequest blijkt hebben alle genoemde classes de mogelijkheid om eigenschappen te setten en getten met getAttribute en setAttribute. Ze hebben allen een eigen rol. Stel we hebben een applicatie die bestaat uit een aantal servlets en JSP's die allemaal dezelfde database benaderen. Dan is de Context een logische plek omde databasenaam vast te leggen. Stel we hebben een winkelwagentje-programma. Dan is de Session de logische plek om de inhoud van het winkelwagentje bij te houden. Stel we hebben een servlet die informatie berekend en het resultaat aan een JSP-pagina wil doorgeven. Dat is de Response de logische plek voor die informatie.

Een ServletContext kan verkregen worden door de methode getServletContext van een object Servlet. Verder maakt een object ServletContext deel uit van het ServletConfig object wat in de methode init van een servlet wordt aangeboden.

JSP pagina's

In een JSP-pagina komen de gebruikelijke html-tags voor. Maar daarnaast ook andere elementen: directives, actions, scriptlets en tag libraries.

directives <%@page ... %> bijvoorbeeld: <%@ page contentType="text/html; charset=UTF-8" %>
scriptletsherkenbaar aan <% ... %>, bijvoorbeeld <%= new java.util.Date() %> waardoor er de huidige tijd=datum in de jsp-pagina wordt opgenomen. In scriptlets kan gebruik gemaakt worden van oa. de volgende impliciete objecten: out, config, application, request en session.
actionseen standard action is bijv: <jsp:useBean...>. bijvoorbeeld: <jsp:useBean id="locales" scope="application" class="mypkg.MyLocales"/> (de JSP-pagina laadt een java-bean). Andere standard actions zijn: <jsp:include...>, <jsp:forward...>, <jsp:setProperty...> (set een property in een java-bean) en <getProperty...> (gets een property in een java-bean)
tag librariessoort bibliotheek met voorgedefinieerde code. Veel gebruikt is de standard tag library (jstl) van Sun. Als je hiervan gebruik maakt wordt de bibliotheek "geladen" door <%@taglib uri="http://java.sun.com/jsp/jstl/core". prefix="c" %>

Om output in een pagina te krijgen kan gebruik gemaakt worden van scriplets die een waarde opleveren (zoals in <%= new java.util.Date() %>) en van het impliciete object out. Out is een JspPrinter object. De informatie in komt de JSP pagina binnen via scriplets, via impliciete objecten zoals session en request, of via java-beans.

Om te illustreren hoe een JSP-pagina opgebouwd zou kunnen zijn het volgende voorbeeld: we willen een pagina voor het toevoegen van een nieuwe auteur in de tabel auteur. We zouden in de JSP-pagina veel java-code in scriptlets kunnen opnemen, waarin classes worden gedefinierd en connecties met de database worden opgezet, maar het is mooier om zo veel mogelijk de code uit de JSP-pagina zelf te halen en de JSP voornamelijk te gebruiken voor de visuele aspecten van de pagina. We willen de code zelf dan in java-beans plaatsen.

We maken twee java-beans: één voor de opslag van de gegevens van een auteur (class AuteurBean, met velden naam, adres en land), en één voor het opzetten van de connectie met de database (class DbBean).

In de JSP-pagina zouden we dan de volgende elementen gebruiken

  1. In het init-gedeelte van de pagina zouden we beide beans declareren en een id geven: <jsp:useBean id="auteur" scope="page" class="xyz.AuteurBean" /> en <jsp:useBean id="dbauteur" scope="page" class="xyz.DbBean" />
  2. We willen dat, nadat de auteurgegevens zijn ingevuld dezelfde pagina weer wordt aangeroepen. Als alle gevraagde gegevens ingevuld zijn wordt doorverwezen naar een andere JSP-pagina die alle auteurs in de database toont. Hiervoor zetten we aan het begin van de body-sectie de volgende scriptlet: <% if (auteur.getNaam()==null || auteur.getLand==null || auteur.getPlaats==null) { %>
  3. hierop volgt de opbouw van de pagina als er nog auteursgegevens moeten worden ingevoerd. Totdat we bij het else gedeelte aankomen: <% } else { dbauteur.addAuteur(auteur);%>
  4. We geven vervolgens op dat er nu geforward moet worden naar een andere JSP-pagina: <jsp:forward page="ViewAuteurs.jsp" />
  5. en we sluiten het if-statement nu af met: <% } %>
  6. In het eerste gedeelte van het if-statement komt een formulier voor, waarin de auteurs gegevens kunnen worden ingevuld. De gegevens moeten met een druk op een submitknop worden gestuurd naar dezelfde JSP-pagina. Als de ingevulde parameters binnekomen (bij de eerste aanroep zullen ze allen null zijn) worden die waarden in de auteurbean gestopt met: <jsp:setProperty name="auteur" property="naam" param="naam" />
versie: 6 mei 2006; copyright: Drikus Kleefsman