Struts
Inhoudsopgave Hoofdstuk 1.Inleiding...........................................................3 1.1.Design patterns...................................................................................................3 1.1.1.Model 1 Architectuur....................................................................................3 1.1.2.Model 2 Architectuur (MVC)........................................................................4 1.2.Frameworks.........................................................................................................6
Hoofdstuk 2.Struts installatie..............................................7 2.1.Installatie van het Struts framework....................................................................7
Hoofdstuk 3.Struts overzicht.............................................12
3.1.MVC algemeen.................................................................................................12 3.2.Struts MVC........................................................................................................12 3.2.1.De Struts Controller component................................................................13 3.2.2.De Struts Model component......................................................................15 3.2.3.De Struts View component........................................................................16
Hoofdstuk 4.Configuratie van Struts.................................18
4.1.Het configuratiebestand struts-config.xml........................................................18 4.2.Voorbeeldapplicatie: MasterMind.....................................................................19 4.2.1.Het MasterMind Model..............................................................................19 4.2.1.1.Klasse-diagram..................................................................................19 4.2.1.2.State diagram.....................................................................................20 4.2.2.De MasterMind controller en view.............................................................21 4.2.2.1.Doorverwijzen naar de login-pagina...................................................22 4.2.2.2.Aanmelden.........................................................................................25 4.2.2.3.LoginForm..........................................................................................27 4.2.2.4.Login.jsp.............................................................................................30 4.2.2.5.LoginAction.........................................................................................31 4.2.2.6.Login mapping....................................................................................35 4.2.2.7.GuessForm.........................................................................................37 4.2.2.8.GuessAction.......................................................................................40 4.2.2.9.Guess.jsp............................................................................................41 4.2.2.10.Score.jsp...........................................................................................44 4.2.2.11.RestartAction....................................................................................45 4.2.3.Internationalization.....................................................................................47 4.2.3.1.Het Locale object in Java...................................................................47 4.2.3.2.Struts Resource Bundles...................................................................48 4.2.3.3.Boodschappen...................................................................................52 4.2.3.4.Foutboodschappen............................................................................54 4.2.4.Foutafhandeling.........................................................................................54 4.2.4.1.Programmatorische foutafhandeling..................................................55 4.2.4.2.Declaratieve foutafhandeling.............................................................57 4.2.4.3.Foutpreventie en robuustheid van een webapplicatie.......................58 4.3.Voorgedefinieerde Actions................................................................................61 4.3.1.ForwardAction............................................................................................62 4.3.2.IncludeAction.............................................................................................62 4.3.3.LocaleAction..............................................................................................62 4.3.4.DispatchAction...........................................................................................64 4.3.5.LookupDispatchAction...............................................................................68 4.3.6.MappingDispatchAction.............................................................................71
Copyright 2012 Noël Vaes
-1-
www.noelvaes.eu
4.4.DynaActionForms..............................................................................................71 4.5.Het Validator Framework..................................................................................75 4.5.1.Inleiding......................................................................................................75 4.5.2.Installatie van het Validator Framework....................................................75 4.5.3.Validator ActionForms...............................................................................75 4.5.4.Validatieregels...........................................................................................76 4.5.5.Formulier-validatie.....................................................................................77 4.5.6.Client-Side JavaScript validatie.................................................................84 4.6.Tiles...................................................................................................................86 4.7.Struts Plugin......................................................................................................93
Copyright 2012 Noël Vaes
-2-
www.noelvaes.eu
Inleiding
Hoofdstuk 1. Inleiding 1.1. Design patterns Java servlets en Java Server Pages (JSP) hebben het mogelijk gemaakt dynamische websites te ontwikkelen op basis van de Java-technologie. Dergelijke webapplicaties beantwoorden aan het WORA-principe: Write Once Run Anywhere. Servlets bieden de mogelijkheid om programmatorisch pagina's realtime te genereren. Servlets hebben echter het nadeel dat de volledige HTML-code programmatorisch gegenereerd moet worden. HTML-pagina's bestaan echter voor het grootste gedeelte uit statische gegevens. Het gebruik van servlets is daarom vrij omslachtig. Een wijziging van de website vergt een wijziging van de Java-code Bovendien moet de webdesigner de Java-programmeertaal machtig zijn. Hij moet zowel programmeur als designer zijn. Sommige van deze problemen werden opgelost met Java Server Pages (JSP). Dit was een makkelijke manier om een servlet te genereren. De rollen werden hierbij omgekeerd. JSP pagina's bestaan gewoon uit HTML-syntax waardoor het makkelijk is de statische inhoud van de pagina te genereren en te onderhouden. De dynamische gegevens worden hieraan toegevoegd d.m.v. scriptlets en custom tags. De webcontainer zorgt voor de omzetting van de JSP-pagina naar een servlet. Een JSP-pagina is daarom ook niet meer dan een makkelijke manier om een servlet te genereren. Met de introductie van JSP werden niet alle problemen opgelost. De JSP pagina's verworden al snel tot een onleesbare en moeilijk onderhoudbare mengeling van statische HTML-code en scriptlets. Als er bovendien ook nog (clientside) JavaScript code aan wordt toegevoegd, wordt de verwarring nog groter. Ook hier moet de webontwikkelaar zowel designer als programmeur zijn. Dit soort problemen heeft geleid tot het ontstaan van een aantal design patterns voor de ontwikkeling van webapplicaties. Een design pattern is een beproefde manier of patroon om een bepaald soort problemen adequaat op te lossen. Design patterns ontstaan in de gemeenschap van (web)-ontwikkelaars doordat ze allen dezelfde problemen tegenkomen en hiervoor oplossingen zoeken. Deze oplossingen worden uitgewisseld, getest en bijgestuurd. Bij web-ontwikkeling zijn er allerhande design patterns. Wij zullen hier twee courante design patterns bespreken: de Model 1 Architectuur en de Model 2 Architectuur. Deze laatste is beter bekend als de Model View Controller architectuur.
1.1.1. Model 1 Architectuur Bij de Model 1 Architectuur worden alle pagina's gegenereerd door JSP pagina's. Er wordt hier geen gebruik gemaakt van pure servlets. Om echter te vermijden dat dergelijke JSP-pagina's overladen worden met allerlei scriptlets wordt de Java-code afgezonderd in JavaBeans en/of Custom Tags. Deze architectuur bestaat uit twee componenten: Copyright 2012 Noël Vaes
-3-
www.noelvaes.eu
Inleiding
1. View-component: Deze is verantwoordelijk voor de presentatie aan de gebruiker. 2. Model-component: Deze bevat de logica van de applicatie. Op die manier krijgen we een scheiding tussen programmatie-logica en presentatielogica en tevens een scheiding van de verantwoordelijkheden in de ontwikkeling van de webapplicatie: enerzijds zijn er de webdesigners die zich vooral bezig houden met de layout van de webapplicatie (presentation logic); en anderzijds zijn er de programmeurs die zich bezighouden met de achterliggende logica (business logic) van de applicatie. Hierbij hoort meestal ook de toegang tot databases en andere componenten. Met de voorziene JSP-tags kunnen de designers de JavaBeans en Custom Tags aanspreken en zo de functionaliteit van de applicatie oproepen.
View
Model
request response
Java Beans
JSP
DB
Custom Tags
Model 1 Architectuur
Deze architectuur is een eerste stap naar een gestructureerde opbouw van een webapplicatie. Nadeel is echter nog steeds dat er verschillende JSP-pagina's zijn die door de gebruiker afzonderlijk opgeroepen kunnen worden. Dit vormt een probleem indien het werken met zo'n webapplicatie volgens een bepaalde volgorde moet gebeuren. Een controle van de status van de gebruiker in iedere JSP-pagina zou de oplossing kunnen zijn. Voorts moet de flow van de applicatie voorzien worden in de afzonderlijke JSP-pagina's. Problemen kunnen hier ook optreden wat de beveiliging en de gewenste taal betreft. Deze gegevens zouden in iedere pagina getest moeten worden. Filters zouden evenwel dit euvel kunnen verhelpen. Tenslotte zijn de mogelijkheden om vanuit een JSP-pagina gebruik te maken van JavaBeans eerder beperkt.
1.1.2. Model 2 Architectuur (MVC) De Model 2 Architectuur gaat een stap verder en introduceert een servlet die als controller functioneert. Het verzoek van de browser gaat steeds via deze servlet. De servlet onderneemt afhankelijk van de status van de applicatie de nodige acties. Meestal worden de acties uitbesteed aan andere componenten zoals JavaBeans. Hierbij worden de nodige gegevens gegenereerd of aangepast. Na het uitvoeren van de acties wordt het verzoek doorgestuurd naar de JSP pagina die enkel dient om het Copyright 2012 Noël Vaes
-4-
www.noelvaes.eu
Inleiding
resultaat van de actie terug aan de gebruiker te tonen. De servlet geeft de nodige informatie aan de JSP-pagina door d.m.v. JavaBeans die gekoppeld worden aan een van de scope-objecten. De gegevens van de JavaBeans kunnen immers met de voorziene tags eenvoudig opgenomen worden in de opmaak van de pagina.
request
Controller
Model
(Servlet)
forward
response
(DB) Java Beans
View
Custom Tags
(JSP) Model 2 Architectuur
Deze architectuur noemt men doorgaans de Model-View-Controller architectuur. Deze bestaat uit drie componenten: 1. Controller: Deze component staat centraal in de applicatie. Alle acties van de gebruiker (verzoeken van de browser) komen hier samen. Naargelang het verzoek zal de controller de nodige acties ondernemen of andere componenten de opdracht geven acties te ondernemen. De controller houdt de status van de gebruiker bij en bepaalt de flow van de applicatie door het verzoek door te sturen naar de juiste JSP-pagina. 2. Model: Deze component stelt het business-model van de applicatie voor. Hierin zit de applicatie-logica en eventueel de persistente objecten. In een eenvoudige applicatie kunnen dit een reeks Java-klassen (POJO's: Plain Old Java Objects) of JavaBeans zijn; in een grotere 4-tier applicatie, wordt hier gebruik gemaakt van Enterprise JavaBeans (EJB) of van het Spring framework. 3. View: Deze component genereert de layout van de applicatie en maakt hierbij gebruik van de gegevens die door het model gegenereerd zijn en hem door de controller worden aangereikt. De MVC-architectuur maakt het beheer en ontwikkelen van complexe applicaties makkelijker. Zo kan de beveiliging, het bijhouden van de applicatie-status en de flow van de applicatie centraal beheerd worden. Strikt genomen is het in de MVC-architectuur mogelijk meerdere controllers te hebben die elk verantwoordelijk zijn voor een deel van de applicatie. Het design pattern Front Controller plaatst echter één centrale servlet aan de ingang van de web applicatie. Van daaruit worden alle verzoeken doorgestuurd naar de verschillende componenten. De Model View Controller en Front Controller zijn twee design Copyright 2012 Noël Vaes
-5-
www.noelvaes.eu
Inleiding
patterns die makkelijk samen gebruikt en geïntegreerd kunnen worden. Dit is o.a. het geval in het Struts Framework.
1.2. Frameworks De MVC-architectuur is in de loop der jaren een veel gebruikt design pattern geworden. Als men gebruik wil maken van dit pattern heeft men wel een goede manier om een webapplicatie op te bouwen maar men is nog steeds verplicht de nodige componenten volgens dit pattern te ontwikkelen. Gelukkig zijn er intussen allerlei frameworks gemaakt die ons helpen een webapplicatie te ontwikkelen. Een framework is niet meer dan een reeks classen en interfaces die op een abstracte en generieke wijze bepaalde functionaliteit aanbieden waarmee we onze eigen (web)-applicatie gestalte kunnen geven. Applicaties worden als het ware boven een framework gebouwd waarbij het framework zorgt voor de onderliggende functionaliteit die gemeenschappelijk is voor alle applicaties.
Webapplicatie Framework JEE (Servlets - JSP - Custom Tags) JSE Platform
Zo zijn er inmiddels ook frameworks die het MVC-pattern voor webapplicaties implementeren en waarboven een concrete webapplicatie gebouwd kan worden. De fundamentele code die zorgt voor het MVC-principe wordt daarbij door het framework geleverd zodat de programmeur/webdesigner zich kan toeleggen op datgene wat specifiek is voor zijn applicatie. Een van de meest populaire frameworks die gebaseerd zijn op het MVC-pattern is Struts. Het werd in 2000 ontwikkeld door Craig R. McClanahan en door hem ter beschikking gesteld van de Apache Software Foundation. Struts is daarmee een open-source framework dat in de industrie reeds op grote schaal wordt gebruikt. Naast Struts zijn er nog andere frameworks voor webontwikkeling; sommige zijn open-source; andere closed-source. Een bekend open-source framework dat intensief gebruik maakt van XML is bijvoorbeeld Cocoon, ook een project van de Apache Software Foundation. Een vergelijkende studie tussen de verschillende frameworks gaat echter buiten het bestek van deze cursus. Copyright 2012 Noël Vaes
-6-
www.noelvaes.eu
Struts installatie
Hoofdstuk 2. Struts installatie 2.1. Installatie van het Struts framework Het Struts framework is beschikbaar op de website http://www.apache.org1. Struts is een reeks van klassen en interfaces die gebruik maken van JSE en JEE en zo de webontwikkelaar een raamwerk bieden voor het ontwikkelen van webapplicaties volgens het MVC-pattern. Struts maakt gebruik van de standaard webtechnologieën die beschikbaar zijn in JEE: servlets, JSP en Custom Tags. Het Struts framework vormt op zich een basis-webapplicatie die men kan uitbreiden en configureren om zo een specifieke webapplicatie te maken. De installatie van Struts komt er dus op neer deze basis-webapplicatie te installeren in de webcontainer. In een tweede stap kunnen we dan deze basis-webapplicatie uitbreiden.
Opdracht 1: Struts downloaden In deze opdracht gaan we het Struts framework downloaden van de Apache site en uitpakken in een lokale map. Download het bestand struts-1.3.x-bin.zip van de Apache site (http://apache.org) of kopieer hem van een andere lokatie. Pak het bestand uit op je lokale harde schijf (C:\) We krijgen volgende mapstructuur: C:\struts-1.3.x-bin +-- apps +-- docs +-- lib +-- src De map lib bevat de nodige JAR-bestanden die het Struts framework nodig heeft. De map apps bevat een aantal voorbeeld webapplicaties die gebruik maken van Struts. De map docs bevat de documentatie en de map src bevat de broncode. Struts kunnen we gebruiken in de vorm van een basis-webapplicatie die we vervolgens kunnen uitbreiden. Deze basis-webapplicatie vinden we in het bestand struts-blank-1.3.x.war in de map apps. We kunnen deze applicatie gewoon uitpakken in een nieuw project en vervolgens dingen toevoegen. Deze blanco webapplicatie is nog gebaseerd op versie 2.3 van de servletspecificatie. Dit zien we in de DTD die gebruikt wordt in web.xml:
1 Deze syllabus maakt gebruik van Struts 1.3.x. Sommige instellingen kunnen verschillend zijn bij een andere versie. Copyright 2012 Noël Vaes
-7-
www.noelvaes.eu
Struts installatie
<web-app> ...
Om ten volle gebruik te kunnen maken van de meest recente technologieën zoals expression language moeten we gebruik maken van versie 2.4 of hoger. Hiervoor moet de DTD-definitie vervangen worden door het overeenkomstige schema. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd "> ...
Opdracht 2: Een Struts-project aanmaken In deze opdracht maken we een nieuw project aan voor de ontwikkeling van een webapplicatie. Daarin plaatsen we de blanco Struts-applicatie. Deze breiden we tevens uit met een aantal extra JAR-bestanden om later meer geavanceerde mogelijkheden te kunnen gebruiken. Het resultaat van deze opdracht is tevens te vinden in OpdrachtenBlanco.zip. Als alternatief voor het stap voor stap uitvoeren van deze opdracht kan je tevens dit zip-bestand uitpakken en integreren in je IDE. Maak ergens een nieuwe projectfolder met de naam Struts. Doe dit eventueel binnen je vertrouwde IDE (Eclipse, NetBeans ...) Creëer volgende subfolders: .\Struts +-- src +-- WebContent Voeg volgend ANT-script toe: <project name="Struts" default="deploy"> <property name="srcdir" value="src" /> <property name="docsdir" value="docs" /> <property name="webdir" value="WebContent" /> <property name="builddir" value="build" /> <property name="destdir" value="${webdir}/WEB-INF/classes" /> <property name="warname" value="struts.war" /> <property environment="env" /> <property name="jee.libdir" value="${env.TOMCAT_HOME}/common/lib" /> <property name="deploydir" value="${env.TOMCAT_HOME}/webapps" /> <path id="classpath"> <pathelement path="${destdir}" />
Copyright 2012 Noël Vaes
-8-
www.noelvaes.eu
