Designing a Dynamic Development Environment for Web Design Auteur: Toon G.Y. Macharis

Transcriptie

1

2 Universiteit Gent Faculteit Ingenieurswetenschappen Vakgroep Electronica en Informatiesystemen Voorzitter: Prof. Dr. Ir. Jan M. Van Campenhout Designing a Dynamic Development Environment for Web Design Auteur: Toon G.Y. Macharis Promotor: Prof. Dr. Ir. Rik Van de Walle Scriptiebegeleider: Ir. Erik Mannens Scriptie ingediend tot het behalen van de academische graad van burgerlijk ingenieur in de computerwetenschappen Academiejaar

3 Voorwoord Aan de universiteit heb ik niet enkel gestudeerd. Ik heb me ook geëngageerd in internationale studentenverenigingen. Wanneer ik mijn studies aan de universiteit begon, was ik een verlegen en introverte persoon, maar ik wou veranderen. Ik wou de wereld zien, mensen ontmoeten en extroverter worden. Ik wou interageren met mensen. Ik heb naar veel landen gereisd als student en ik heb zoveel zaken gedaan dat ik denk dat ik meer geleerd heb buiten de universiteit dan dat ik aan de universiteit zou kunnen leren. Ik heb geen wetenschap aangeleerd in mijn sociale leven, dit kan ik enkel aan de universiteit leren, maar ik heb sociale en organisatorische vaardigheden aangeleerd die de wetenschap die aan de universiteit aangeleerd word complementeren. Het is van mijn sociale ervaringen dat ik me ervan bewust werd dat wetenschap nodig is voor de maatchappij. Meer specifiek, websites die diensten aanbieden kunnen zeer nuttig zijn voor communities en communities zijn overal rondom ons. Elke group van mensen die een identiteit delen vormen een community, of het nu een group van vrienden is, een vereniging zonder winstbejag, een departement van de overheid of een bedrijf, velen van hen kunnen een eigen website gebruiken waarop ze diensten kunnen aanbieden aan de buitenwereld. Echter, veel van deze communities struikelen over de technische moeilijkheden om hun op maat gemaakte website op te zetten. Op het moment heerst er een community gekte. Echter, het bedrijfsplan van deze community portaalsites die claimen in de miljarden dollars waard te zijn, slaan naast de kwestie [OpenCommunity]. Communities willen hun website niet op een portaalsite aanmaken en erdoor gecontroleerd worden. Ze willen hun eigen op maat gemaakte website onder hun eigen controle hebben. En dit is waarvoor ik naar een oplossing wil helpen zoeken. Ik dank BEST [BEST] en ESN [ESN] voor de leuke ervaringen en de inspiratie. Ik dank mijn ouders omdat ze me zijn blijven steunen ook al heb ik er iets langer over gedaan om af te studeren. Ik dank Erik Mannens voor het erkennen van de waarde van mijn onderzoek en me bij te staan om het schrijven als mijn scriptie. Ik dank professor Rik Van de Walle om me mijn scriptie te laten schrijven over het onderwerp van mijn keuze.

4 Toelating tot bruikleen De auteur geeft de toelating om delen van dit document of het geheel te reproduceren voor persoonlijke, niet-commerciële of commerciële doeleinden zonder enig verzoek om toelating of zonder enige compensatie. De auteur verzoekt echter wel dat bij elke reproductie van delen van dit document of het geheel de link naar wordt geïncludeerd als de oorspronkelijke bron.

5 Designing a Dynamic Development Environment for Web Design Auteur: Toon G.Y. Macharis Scriptie ingediend tot het behalen van de academische graad van burgerlijk ingenieur in de computerwetenschappen. Academiejaar Promotor: Prof. Dr. Ir. Rik Van de Walle Scriptiebegeleider: Ir. Erik Mannens Faculteit Ingenieurswetenschappen Universiteit Gent Vakgroep Electronica en Informatiesystemen Voorzitter: Prof. Dr. Ir. Jan M. Van Campenhout Samenvatting Het doel van dit onderzoek is een ontwikkelingsomgeving te creëren die de structuur van een webapplicatie scheidt van de technische details zodat de structuur van de webapplicatie beheerd kan worden zonder kennis van de technische details. Dit zal organisaties toelaten om meer controle te hebben over hun websites. Trefwoorden: Model-View-Controller, Webapplicatie Framework, Java

6 Designing a Dynamic Development Environment for Web Design Auteur: Toon G.Y. Macharis Abstract Het doel van dit onderzoek is een ontwikkelingsomgeving te creëren die de structuur van een webapplicatie scheidt van de technische details zodat de structuur van de webapplicatie beheerd kan worden zonder kennis van de technische details. Dit zal organisaties toelaten om meer controle te hebben over hun websites. Trefwoorden Model-View-Controller, Webapplicatie Framework, Java Inleiding Een website kan een nuttig communicatiemiddel zijn voor veel organisaties. Als de website enkel dient om zijn bezoekers te informeren, dan volstaan statische technologieën als XHTML en CSS. Echter, vaak is het wenselijk dat een organisatie niet enkel informatie verschaft op haar website, maar ook diensten. Zulke software diensten kunnen geïmplementeerd worden door gebruik te maken van verscheidene technologieën. Vanuit het gezichtspunt van een organisatie doet het er vaak niet toewelke technologie gebruikt wordt om de diensten aan te bieden. Zaken die van belang zijn, zijn oplossingen die goedkoop zijn, oplossingen die snel geleverd worden, oplossingen waarvan de structuur eenvoudig aangepast kan worden en oplossingen die portabel en schaalbaar zijn. Een zeer belangrijke kwaliteit voor een organisatie is dat de organisatie controle heeft over de structuur van haar website en dat ze deze structuur eenvoudig kan aanpassen aan haar vereisten, die kunnen veranderen na verloop van tijd. Al te vaak hebben organisaties een beperkte controle over hun website. De reden hiervoor is dat organisaties vaak zelf niet over voldoende technische vaardigheden beschikken om hun website te ontwikkelen en daarom afhankelijk zijn van externe partners. Deze partners bieden gewoonlijk technische oplossingen aan die niet transparant zijn voor de organisatie. Wegens het gebrek aan transparantie en het gebrek aan kennis over hoe een technische oplossing aan te passen, zijn

7 organisaties vaak genoodzaakt om oplossingen als een ondeelbare alles of niets oplossing te aanvaarden. Dergelijke oplossingen zijn duur, omdat een organisatie niet een software ontwikkelaar kan vragen om een deel van de website te creëren en een andere software ontwikkelaar om een ander deel te creëren; in plaats hiervan dient de hele website door enkel een software ontwikkelaar gemaakt te worden. Als organisaties een alternatief willen, moeten ze een andere software ontwikkelaar vragen om ook een volledige oplossing te creëren. Wegens het gebrek aan transparantie, weet de organisatie niet dat als een vereiste die niet volledig geïmplementeerd is als gewenst, dit is omdat de technische kost echt te hoog zou zijn of omdat de software ontwikkelaar niet over de nodige vaardigheden beschikt en zich achter valse technische voorwendsels verbergt. Het gebrek aan transparantie hindert ook het aanpassen van de website wanneer vereisten van de organisatie evolueren, aangezien dit kan leiden tot een volledig nieuwe website. Kort gezegd, organisaties zijn vaak genoodzaakt om technische oplossingen voor hun website te aanvaarden waarvan de structuur niet transparant is voor hen en wegens dit gebrek aan transparantie zijn ze overgeleverd aan de welwillendheid van software ontwikkelaars, die vaak hun invloed in hun eigen voordeel gebruiken, ten koste van de organisaties. Het doel van dit onderzoek is een ontwikkelingsomgeving te creëren die de structuur van een webapplicatie scheidt van de technische details zodat de structuur van de webapplicatie beheerd kan worden zonder kennis van de technische details. Dit zal organisaties toelaten om meer controle te hebben over hun websites. Voor een bedrijfsplan over hoe deze benadering economisch uitvoerbaar kan zijn, verwijs ik naar de appendix. Er bestaat ook een Engelse vertaling van deze scriptie voor mensen die geen Nederlands spreken. Referenties

8 Inhoudstafel 1. Motivatie State of the Art Struts XML configuratie View ActionForm klasse Action klasse Controller Wat is er verkeerd aan Struts Analyse van Struts Een alternatief voor Struts Software architectuur Vereisten Functionele vereisten Integratie van functionaliteit Integratie van de gebruikersinterface Kwaliteitsattributen Bruikbaarheid Flexibiliteit Aanpasbaarheid Portabiliteit Gebruikersbeheer Gebruik van EJB Architectuur Module decompositie gezichtspunt Proces gezichtspunt Toewijzingsgezichtspunt Planning Iteratieve ontwikkeling Iteratie Iteratie Iteratie Iteratie Risicos Het dynamisch laden van klassen Externe bestanden Lightweight persistentie Flow charts en gebruikersbeheer Onafhankelijke delen... 42

9 5. Demonstratie Configuratie Het maken van een eenvoudige rekenmachine Het Model De View De Controller Element container Element register Component register Configuratie van de applicatie Demonstratie van de eenvoudige rekenmachine Herstellen van de rekenmachine Uitbreiding van de rekenmachine Het Model De View De Controller Demonstratie van de uitgebreide rekenmachine Demonstratie van de uiteindelijke rekenmachine Verder werk Besluit Appendices A Bibliografie B Lijst van figuren C Software schemas C.1 Preliminary C.2 Element Container C.3 Element Registry C.4 Component Registry D Bedrijfsplan

10 Lijst van afkortingen AJAX: Asynchronous JavaScript and XML, een webtechnologie die toelaat om dynamisch de inhoud van een webpagina aan te passen zonder de volledige webpagine te hoeven hernieuwen. API: Application Programming Interface, een verzameling interfaces waardoor zekere functionaliteit beschikbaar is. CSS: Cascading Style Sheets, een webtechnologie die de weergave van zekere XML elementen specifieert. EJB: Enterprise JavaBeans, een onderdeel van de Java Enterprise Edition technologie. GPL: GNU General Public License, een vrije software licentie. GUI: Graphical User Interface, een grafische weergave waardoor een gebruiker met een systeem interageert. IDE: Integrated Development Environment, een software applicatie die het ontwerpen van software ondersteunt. JAR: Java ARchive, een bestandsstandaard die de ZIP standaard extendeert en toelaat om meerdere bestanden in een archiveringsbestand te bundelen. JNDI: Java Naming and Directory Interface, een Java API die toegang verleent tot een directory service. Data en objecten kunnen aangesproken worden via de directory service met hun identificerende naam. JSP: JavaServer Pages, een Java technologie die scripting in XHTML of andere XML paginas toelaat.

11 LOB: Large Object, een object van ongespecifieerde grootte en een hoge maximum grootte limiet in een databank. MVC: Model-View-Controller: een software patroon dat software functionaliteit scheidt van de gebruikersinterface. PACITA: Pages, Actions and Conditions Iterations Abstraction, de naam van het webapplicatie framework ontwikkeld in deze scriptie en het acroniem van de drie pijlers waarrond het is opgebouwd. PHP: PHP: Hypertext Preprocessor, een technologie die scripting in XHTML paginas toelaat. UML: Unified Modeling Language, een gestandaardiseerde specificatie taal voor het modelleren van objecten. URI: Uniform Resource Identifier, een string gebruikt ter identificatie van een web hulpbron. URL: Uniform Resource Locator, een URI die ook specifieert hoe de geïdentificeerde hulpbron kan aangesproken worden. SQL: Structured Query Language, een standaard query taal ter manipulatie van data in een relationele databank. XHTML: Extensible HyperText Markup Language, een opmaaktaal voor webpaginas die voldoet aan de XML syntax. XML: Extensible Markup Language, een data formaat waarin de structuur van data opgeslagen wordt met de data en de structuur georganiseerd wordt als geneste menselijk leesbare tags.

12 Designing a Dynamic Development Environment for Web Design Elke creërende actie is eerst en vooral een vernietigende actie. Pablo Picasso 1. Motivatie Een website kan een nuttig communicatiemiddel zijn voor veel organisaties. Als de website enkel dient om zijn bezoekers te informeren, dan volstaan statische technologieën als XHTML en CSS. Echter, vaak is het wenselijk dat een organisatie niet enkel informatie verschaft op haar website, maar ook diensten. Zulke software diensten kunnen geïmplementeerd worden door gebruik te maken van verscheidene technologieën. Vanuit het gezichtspunt van een organisatie doet het er vaak niet toewelke technologie gebruikt wordt om de diensten aan te bieden. Zaken die van belang zijn, zijn oplossingen die goedkoop zijn, oplossingen die snel geleverd worden, oplossingen waarvan de structuur eenvoudig aangepast kan worden en oplossingen die portabel en schaalbaar zijn. Een zeer belangrijke kwaliteit voor een organisatie is dat de organisatie controle heeft over de structuur van haar website en dat ze deze structuur eenvoudig kan aanpassen aan haar vereisten, die kunnen veranderen na verloop van tijd. Al te vaak hebben organisaties een beperkte controle over hun website. De reden hiervoor is dat organisaties vaak zelf niet over voldoende technische vaardigheden beschikken om hun website te ontwikkelen en daarom afhankelijk zijn van externe partners. Deze partners bieden gewoonlijk technische oplossingen aan die niet transparant zijn voor de organisatie. Wegens het gebrek aan transparantie en het gebrek aan kennis over hoe een technische oplossing aan te passen, zijn organisaties vaak genoodzaakt om oplossingen als een ondeelbare alles of niets oplossing te aanvaarden. Dergelijke oplossingen zijn duur, omdat een organisatie niet een software ontwikkelaar kan vragen om een deel van de website te creëren en een andere software ontwikkelaar om een ander deel te creëren; in plaats hiervan dient de hele website door enkel een software ontwikkelaar gemaakt te worden. Als organisaties een alternatief willen, moeten ze een andere software ontwikkelaar vragen om ook een volledige oplossing te creëren. Wegens het gebrek aan 1

13 transparantie, weet de organisatie niet dat als een vereiste die niet volledig geïmplementeerd is als gewenst, dit is omdat de technische kost echt te hoog zou zijn of omdat de software ontwikkelaar niet over de nodige vaardigheden beschikt en zich achter valse technische voorwendsels verbergt. Het gebrek aan transparantie hindert ook het aanpassen van de website wanneer vereisten van de organisatie evolueren, aangezien dit kan leiden tot een volledig nieuwe website. Kort gezegd, organisaties zijn vaak genoodzaakt om technische oplossingen voor hun website te aanvaarden waarvan de structuur niet transparant is voor hen en wegens dit gebrek aan transparantie zijn ze overgeleverd aan de welwillendheid van software ontwikkelaars, die vaak hun invloed in hun eigen voordeel gebruiken, ten koste van de organisaties. Het doel van dit onderzoek is een ontwikkelingsomgeving te creëren die de structuur van een webapplicatie scheidt van de technische details zodat de structuur van de webapplicatie beheerd kan worden zonder kennis van de technische details. Dit zal organisaties toelaten om meer controle te hebben over hun websites. Voor een bedrijfsplan over hoe deze benadering economisch uitvoerbaar kan zijn, verwijs ik naar de appendix. Er bestaat ook een Engelse vertaling van deze scriptie voor mensen die geen Nederlands spreken. 2

14 2. State of the Art 2.1. Struts Er bestaan raamwerken die een zekere structuur van een website van zijn technische implementatie scheiden. Deze raamwerken zijn vaak gebonden aan een zekere technologie. De technologie die ik zal veronderstellen zal Java zijn. Ik heb een uitgebreide ervaring met de populaire scripting taal PHP, doch het is mijn mening dat Java technisch superieur is aan PHP [JAVAvsPHP]. Het enige voordeel dat PHP heeft over Java is dat er in de praktijk meer PHP hosting aanbieders dan Java hosting aanbieders lijken te zijn en dat men gemakkelijker een goedkope PHP hosting oplossing kan vinden dan een goedkope Java hosting oplossing. Java heeft minder bugs, is portabeler, heeft een bredere API en heeft betere ontwikkelingshulpmiddelen dan PHP. Men kan argumenteren dat Java niet de beste technologie is die er bestaat voor het maken van webapplicaties. Ik denk dat ze het wel is. Ik ga hier niet argumenteren wat nu inderdaad de beste technologie is. Ik denk dat elke technologie die je noden oplost geldig is. Voor mij doet Java het, dus ik ga me tot Java beperken. Ik moet een technologie kiezen om mee te beginnen werken, maar de concepten die ik zal uitwerken, zijn toepasbaar op alle uitvoerbare technologieën. Het populairste web raamwerk voor Java is op het moment van schrijven Struts [Struts1]. Volgens een recent artikel aangekondigd op deze website [Struts2], is Struts nog steeds niet over de piek van zijn populariteit heen. In dit hoofdstuk zal ik uitleggen hoe Struts werkt. Ik gebruikte het leervoorbeeld [Struts3] als inspiratie. 3

15 2.2. XML configuratie Het Struts raamwerk bestaat uit 2 delen. Een deel bestaat uit JSP paginas die gebruikt worden om uitvoer naar de gebruiker te sturen en het andere deel bestaat uit acties die invoer van de gebruiker verwerken en doorsturen naar de nieuwe uitvoer na de verwerking. Elke actie bestaat uit 2 delen: een ActionForm object en een Action object. Het ActionForm object bevat de invoer van de gebruiker en het Action object verwerkt de invoer. Het ActionForm object en het Action object moeten in het WEB-INF/strutsconfig.xml bestand geconfigureerd worden als hieronder uitgelegd. De structuur van het WEB-INF/struts-config.xml bestand ziet eruit als: <struts-config> <form-beans> <!-- ActionForm objects are defined here --> </form-beans> <action-mappings> <!-- Action objects are defined here --> </action-mappings> </struts-config> De definitie van een ActionForm object ziet eruit als: <form-bean name="customform" type="strutsexample.customform"/> Hierin definiëert de waarde van het name attribuut de naam van het ActionForm object en de waarde van het type attribuut definiëert de volledig gequalificeerde naam van de ActionForm klasse. De definitie van een Action object ziet eruit als: <action path="/customaction" type="strutsexample.customaction" name="customform" input="/error.jsp" scope="request"> <forward name="odd" path="/odd.jsp"/> <! there can be multiple forward tags --> <forward name="even" path="/even.jsp"/> </action> 4

16 Een beschrijving van de attributen van de action tag: path: definiëert het URL patroon waarvoor de actie wordt uitgevoerd. Voor dit voorbeeld wordt de specifieke actie uitgevoerd op het URL patroon /customaction.do. type: definiëert de volledig gequalificeerde naam van de Action klasse name: definiëert het ActionForm object dat geassociëerd is met dit Action object input: definiëert het URL patroon waarnaar de controle wordt doorgestuurd als het ActionForm object een fout genereert terwijl de invoer gevalideerd wordt scope: definiëert het bereik van het ActionForm object. Dit kan ofwel request scope ofwel session scope zijn. De forward tags die genest zijn onder een action tag definiëren het URL patroon waarnaar de controle kan doorgestuurd worden na het succesvol uitvoeren van een actie. 5

17 2.3. View De view van een Struts applicatie wordt geïmplementeerd door JSP paginas. Deze JSP paginas moeten Struts custom tags gebruiken in plaats van de XHTML invoer elementen. De URL van de tag library descriptor van de Struts invoer custom tags is WEB-INF/struts-html.tld. De broncode van een webpagina in een Struts applicatie kan er dus uitzien als: <!-- imports the Struts custom tags --> uri="/web-inf/struts-html.tld" prefix="html"%> <html> <head><title>insert a Number</title></head> <body> <html:form action="customaction.do"> Insert a number: <html:text property="value"/> <html:submit/> </html:form> </body> </html> Een browser zou deze JSP pagina renderen tot: Figuur 1: De Struts voorbeeld JSP pagina gezien in een browser Als men op de submit knop klikt, wordt de Struts actie die geassociëerd is met het URL patroon customaction.do uitgevoerd. Als we de XML configuratie van de vorige paragraaf gebruiken, dan zou een klik op de submit knop de uitvoering van een strutsexample.customaction Action object veroorzaken, dat op zijn beurt een strutsexample.customform ActionForm object zou gebruiken om de invoer data te bevatten. 6

18 2.4. ActionForm klasse Een ActionForm klasse is een normale Java klasse die de klasse org.apache.struts.action.actionform extendeert. De ActionForm klasse bevat de eigenschappen die gedefiniëerd worden in een JSP pagina die een geassociëerde actie oproept. De ActionForm klasse volgt de JavaBeans specificatie [JavaBeans] voor toegangsmethoden tot de eigenschappen. In het voorbeeld van dit hoofdstuk heeft de JSP pagina een eigenschap, namelijk value en daarom definiëert de ActionForm klasse de methoden setvalue en getvalue. De ActionForm klasse kan ook de validate methode van zijn basis klasse opheffen (overriden). De ActionForm klasse definitie zou er bijgevolg kunnen uitzien als: package strutsexample; import javax.servlet.http.httpservletrequest; import org.apache.struts.action.*; public class CustomForm extends ActionForm { private String value; public void setvalue(string value) { this.value = value; } public String getvalue() { return value; } } public ActionErrors validate(actionmapping mapping, HttpServletRequest request) { ActionErrors errors = new ActionErrors(); try { Integer.valueOf(value); } catch(numberformatexception e) { errors.add("value", new ActionError("error.value")); } return errors; } Voordat een Action object de invoer van een JSP pagina verwerkt, wordt een nieuw ActionForm object gecreëerd en worden zijn eigenschappen ingesteld met zijn setmethoden en de waarden van de eigenschappen in de JSP pagina. Vervolgens wordt de validate methode van het ActionForm object uitgevoerd. Als deze methode een ActionErrors object retourneert dat niet leeg is, wordt de controle doorgestuurd naar het URL patroon dat gedefiniëerd is in het input attribuut van de action tag in de XML configuratie. Als de validate methode een ActionErrors object retourneert dat leeg is, wordt de controle doorgestuurd naar het Action object. 7

19 Als de validate methode een ActionErrors object retourneert dat niet leeg is, kunnen de fouten in dit ActionErrors object naar de uitvoer geschreven worden met de custom tag <html:errors/>. Voor een geschikte uitvoer moet men de foutberichten definiëren in het bestand WEB-INF/classes/ApplicationResources.properties zoals: errors.header=<b> errors.footer=</b> error.value=the inserted value is not a number! Het effect van de <html:errors/> custom tag is dat eerst de string geassociëerd met errors.header naar de uitvoer geschreven wordt, dan de een na de andere de strings geassociëerd met de error.property waarden die het ActionErrors object bevat en uiteindelijk de string geassociëerd met errors.footer. 8

20 2.5. Action klasse Een Action klasse is een normale Java klasse die de klasse org.apache.struts.action.action extendeert. De Action klasse heft de perform methode van zijn basis klasse op, die uitgevoerd wordt om de invoer te verwerken. In het voorbeeld van dit hoofdstuk zou de Action klasse definitie er kunnen uitzien als: package strutsexample; import javax.servlet.http.*; import org.apache.struts.action.*; public class CustomAction extends Action { public ActionForward perform(actionmapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) { CustomForm customform = (CustomForm)form; int value = Integer.valueOf(customForm.getValue()).intValue(); if ((value % 2) == 1) { return mapping.findforward("odd"); } else { return mapping.findforward("even"); } } } De perform methode van de Action klasse wordt uitgevoerd als de validate methode van het ActionForm object een leeg ActionErrors object heeft geretourneerd. Het ActionForm object wordt als argument aan deze methode doorgegeven. Het Action object heeft toegang tot de eigenschappen van de JSP invoer pagina door dit ActionForm object. Na het verwerken van de waarden van de eigenschappen retourneert de perform methode een ActionForward object. Dit ActionForward object wordt gecreëerd door de findforward methode van het ActionMapping object dat aan de perform methode is doorgegeven als een argument aan te roepen. Het argument voor de findforward methode is de waarde van het name attribuut van een forward tag genest in de action tag die het actie object in de XML configuratie definiëert. De controle wordt doorgegeven aan het URL patroon geassociëerd met deze forward tag. 9

21 2.6. Controller De controller van het Struts raamwerk bestaat uit een servlet die geassociëerd is met het *.do URL patroon. Elke keer een aanvraag gemaakt wordt naar zo n URL patroon, identificeert de servlet het URL patroon met een Action object en een geassociëerd ActionForm object. Een nieuw ActionForm object wordt gecreëerd en zijn eigenschappen worden ingesteld door de gepaste set-methoden aan te roepen. Het ActionForm object wordt gevalideerd. Als er validatie fouten zijn, wordt de controle doorgestuurd naar een URL pattern dat de validatie fouten behandelt. In het andere geval wordt een nieuw Action object gecreëerd en zijn perform methode wordt uitgevoerd om de invoer te verwerken. Na het verwerken van de invoer, retourneert de perform methode een object dat bepaalt aan welk URL patroon de controle vervolgens wordt doorgegeven. 10

22 3. Wat is er verkeerd aan Struts 3.1. Analyse van Struts Struts is een technische oplossing voor techneuten. Bovendien kan men elegantere technische raamwerken ontwerpen. Hoewel Struts afdwingt om webapplicaties the structureren in acties en paginas en hoewel de structuur gescheiden wordt van de code in het XML configuratie bestand, is het moeilijk om in the beelden dat organisaties bereid zijn om de structuur in het XML configuratie bestand te begrijpen, laat staan om het te beheren. Ook al kan Struts een grote hulp zijn voor software ontwikkelaars, het is amper nuttig voor een organisatie die niet door de technische duisterheden kan zien. Organisaties aanzien ook Struts projecten als monolithische oplossingen. Als men bereid is om even uit de wereld van technische ingewikkeldheden te treden en men veronderstelt het absolute minimum aan concepten dat noodzakelijk is om de structuur van een website te beschrijven, is het mogelijk dat men een ontwerp voor een raamwerk benadert dat zeer gebruiksvriendelijk is. Laten we een eerste poging wagen. Figuur 2: een illustratie van de basis definitie van een computer of een informatie systeem 11

23 Met enige verbeelding kan men de figuur links op Figuur 2 als een gebruiker beschouwen en het kader rechts als een systeem waarmee hij interageert. De gebruiker geeft invoer aan het systeem. Het systeem verwerkt de invoer en retourneert het resultaat van de verwerking aan de gebruiker. De gebruiker observeert deze uitvoer, interpreteert het en genereert een nieuwe invoer. In al zijn eenvoud kan men vergeten dat Figuur 2 de basis definitie van een computer of een informatie systeem illustreert. Echter, Figuur 2 geeft niet veel structuur vrij. Laat ons daarom het informatie systeem in 3 delen als in Figuur 3. in Gebruikersinterface View Functionaliteit Model Presentatie Controller Applicatie Logica Uitvoer Data Bron Beheer uit Figuur 3: een informatie systeem opgedeeld volgens het Model-View-Controller patroon 12

24 Een informatie systeem kan in 3 gedeeld worden volgens het Model-View-Controller 1 patroon. De view is het deel waarmee een gebruiker interageert: het toont de uitvoer aan de gebruiker en het onderschept invoer van de gebruiker. Het bestaat uit de uitvoer data, de manier waarop deze gepresenteerd wordt en triggers voor invoer. Het model bevat de functionaliteit van het systeem. Deze functionaliteit bestaat uit de verwerking van gebruikersinvoer (de applicatie logica laag) en uit invoer van en uitvoer naar andere informatie systemen (de bron beheer laag). Het model bestaat uit de dode code van de applicatie. De controller is een lopend programma dat invoer van de gebruiker onderschept, de invoer interpreteert en de invoer doorstuurt naar het juiste deel van het model om de invoer te verwerken. Wanneer de invoer verwerkt is, onderschept de controller het resultaat, interpreteert hoe het resultaat moet gepresenteert worden en stuurt de presentatie naar de gebruiker. De controller verbindt de view aan het model. De controller is algemeen. De view en het model zijn aan de andere kant zeer specifiek. Een ander verschil met het model is dat de controller een levend programma is dat delen van het model activeert wanneer ze nodig zijn. Als we Struts analyseren, dan vinden we dat de view bestaat uit de JSP paginas met de Struts custom tags; het model bestaat uit de Action en ActionForm klassen en de onderliggende logica die ze aanspreken; de controller bestaat uit de servlet geassociëerd met het *.do URL patroon en het XML configuratie bestand. 1 Blijkbaar zijn er veel verschillende interpretaties van het Model-View-Controller patroon. Het enige dat al deze verschillende interpretaties gemeenschappelijk hebben is dat ze uit 3 verschillende delen bestaan. In sommige interpretaties is de View direct gekoppeld aan het Model of vice versa [MVCwiki]. Sommige andere interpretaties identificeren de Controller met de Applicatie Logica Laag en het Model met de Bron Beheer Laag [CakePHP]. De interpretatie van het Model-View-Controller patroon dat ik presenteer is de modulairste interpretatie. 13

25 3.2. Een alternatief voor Struts In deze scriptie zal ik een alternatief voor Struts ontwikkelen. Ik zal het alternatieve raamwerk PACITA (wat een acroniem is voor Paginas Acties Condities, ITeraties en Abstractie) noemen. Het Struts raamwerk en het PACITA raamwork worden met elkaar vergeleken in Figuur 4. Struts deployed PACITA on the fly enkel lokale paginas View Controller Model JSP paginas met Struts custom tags voor in en uitvoer lokale en externe paginas JSP paginas met 1 data custom tag voor uitvoer XML configuratie GUI configuratie met opslag in XML enkel lokale klassen Action klasse voor acties ActionForm klasse voor data geen interface voor condities geen interface voor gebruikersaccounts lokale en externe klassen Action interface voor acties Data interface voor data Condition interface voor condities UserAccounts interface voor gebruikersaccounts Figuur 4: vergelijking van het Struts raamwerk met het PACITA raamwerk Een eerste verschil is dat met het Struts raamwerk, een applicatie gedeployed moet worden naar de server samen met het Struts raamwerk. Veranderingen aan de applicatie vereisen het undeployen van de oude applicatie en het redeployen van de nieuwe applicatie. Voor het PACITA raamwerk dient enkel het raamwerk zelf gedeployed te worden naar de server. De view en het model kunnen on the fly in het systeem ingevoerd worden zonder de nood aan deployment. Een tweede verschil is dat het Struts raamwerk enkel met lokale paginas en klassen werkt. Het PACITA raamwerk kan ook paginas en klassen die zich op een externe server bevinden configureren. Struts wordt geconfigureerd in een XML bestand. PACITA wordt geconfigureerd d.m.v. een grafische gebruikersinterface. De configuratie van het PACITA raamwerk kan geëxporteerd worden naar of geïmporteerd worden van XML bestanden. 14

26 Struts vereist het gebruik van een veelheid aan Struts custom tags om invoer van of uitput naar JSP paginas door te sturen. PACITA laat toe om standaard XHTML invoer elementen te gebruiken om invoer van JSP paginas door te sturen en vereist het gebruik van een enkele algemene data custom tag om uitvoer naar JSP paginas door te sturen. De data van een data custom tag heeft toegang tot de data van een ouder data custom tag en de data van een data custom tag kan geïtereerd worden. Struts gebruikt de Action en ActionForm basis klassen voor acties en data. PACITA gebruikt de Action en Data interfaces voor acties en data. Struts heeft geen interfaces voor condities of gebruikersaccount lijsten. PACITA gebruikt de Condition interface voor condities en de UserAccounts interface voor gebruikersaccount lijsten. Condities maken het mogelijk om expliciet control flow aan de structuur van de actie ketting toe te voegen. In Struts bepaalt een actie intern de volgende ActionForward en daarom is de control flow in Struts geen deel van de externe structuur. De gebruikersaccount lijsten maken het mogelijk om gebruikersgroepen te definiëren. PACITA laat toe om toegang tot delen van de gebruikersinterface of zekere functionaliteit te beperken. De toegang kan beperkt worden tot zekere gebruikers of tot bepaalde condities waaraan voldaan moet worden. Struts ondersteund geen beperking op de toegang tot de gebruikersinterface of zekere functionaliteit. Omdat een applicatie die het Struts raamwerk gebruikt moet gedeployed worden naar de server en omdat de structuur van de applicatie geconfigureerd wordt in een XML bestand, is het waarschijnlijk dat personen met technische vaardigheden zorgen voor de installatie van een Struts applicatie. Het PACITA raamwerk laat toe om een applicatie on the fly samen te stellen met een GUI en gebruik makend van externe klassen en paginas. The GUI vermindert de technische moeilijkheden en een organisatie is dus beter in staat om hiermee om te gaan, terwijl het invoegen van externe klassen en paginas het gemakkelijker maakt om de ontwikkeling van een webapplicatie in verschillende rollen die corresponderen met de onderdelen van het Model-View-Controller patroon op te delen. De ontwikkeling van een webapplicatie kan opgedeeld worden in drie rollen als geïllustreerd in Figuur 5. 15

27 laag View Controller Model actor gebruiker auteur editor linker ontwerper programmeur verantwoordelijkheid interageert met resultaat maakt paginas op beheert componenten beheert elementen definiëert functionele interfaces implementeert functionaliteit Figuur 5: ontwikkelingspijplijn met rollen opgesplitst in overeenstemming met het MVC patroon Een rol, waarin een software ontwikkelaar de gevraagde functionaliteit voorziet, correspondeert met het model. Een andere rol, waarin een web ontwikkelaar de gevraagde paginas voorziet, correspondeert met de view. De derde rol, waarin de organisatie de geleverde paginas en functionaliteit in zijn webapplicatie integreert, correspondeert met de controller. Het is vermeldenswaardig dat een webapplicatie niet in een keer hoeft ontworpen te worden. Elk van de drie rollen kan relatief onafhankelijk van de andere werken en op gedeeltelijke resultaten van de andere voortbouwen. De webapplicatie kan in iteraties evolueren. Een website is niet meer een ondeelbare alles of niets verwezenlijking met een gebrek aan transparantie, maar een flexibele structuur die eenvoudig kan aangepast worden. De GUI en de flexibele structuur van de controller laten iteratieve ontwikkeling van webapplicaties toe. Voordelen van iteratieve ontwikkeling zijn: snelle resultaten: een deel van de functionaliteit kan onmiddelijk gebruikt worden, i.p.v. te moeten wachten tot alle functionaliteit is geïmplementeerd. Een voorlopige gebruikersinterface kan eveneens gebruikt worden voordat een meer uitgekuiste versie verwezenlijkt is. lage test kosten: fouten worden snel ontdekt, wanneer ze nog niet geaccumuleerd zijn, wat het veel eenvoudiger maakt om ze aan te passen dan wanneer ze allemaal ineens zouden komen. snelle aanpassing: door de snelle resultaten, kunnen ze snel geëvalueerd worden en als een aanpassing in het ontwikkelingspad gewenst zou zijn, kan de ontwikkeling snel veranderd worden in de volgende iteratie. 16

28 4. Software architectuur 4.1. Vereisten Functionele vereisten De functionele vereisten voor het PACITA raamwerk zijn enerzijds dat functionaliteit kan geïntegreerd worden in de webapplicatie en anderzijds dat een gebruikersinterface kan geïntegreerd worden in de webapplicatie Integratie van functionaliteit Functionaliteit wordt geïntegreerd door klassen die een van de interfaces getoond in Figuur 6 implementeren. Serializable Action execute(request : HttpServletRequest) Element Condition test(request : HttpServletRequest) : boolean UserAccounts Data check(user : String, password : String) : boolean getallusernames() : String[] getdatabean(session : HttpSession) : Object Figuur 6: de interfaces voor klassen die het PACITA raamwerk van functionaliteit voorzien Klassen die een dergelijke interface implementeren worden elementen genoemd, omdat ze elementair of essentieel zijn om het systeem te voorzien van functionaliteit. 17

29 Integratie van de gebruikersinterface De structuur van de gebruikersinterface wordt samengesteld door componenten. Er zijn drie verschillende soorten componenten: Pagina componenten vormen de view van de webapplicatie. Een pagina component toont de inhoud van de web pagina die gelinked is aan de component. Een pagina component bevat triggers voor de verwerking van invoer. Als een trigger geactiveerd wordt, wordt de controle doorgestuurd naar de component die gelinked is aan de trigger. Een pagina component bevat beans die dynamische inhoud tonen. Een bean is een JavaBean object dat geretourneerd wordt door de getdatabean methode van een Data element dat gelinked is aan de pagina. Actie componenten zijn een deel van de controller van de webapplicatie. Een actie component verwerkt invoer door de execute methode van het Action element dat gelinked is aan de component aan te roepen. Na uitvoeren van de actie, wordt de controle doorgestuurd naar de volgende component die gelinked is aan de actie component. Conditie componenten zijn het andere deel van de controller van de webapplicatie. Een conditie component test een voorwaarde door de test methode van het Condition element dat gelinked is aan de component aan te roepen. Als de voorwaarde geldt, wordt de controle doorgestuurd naar de volgende positieve component die gelinked is aan de conditie component. In het andere geval wordt de controle doorgestuurd naar de volgende negatieve component die gelinked is aan de conditie component. 18

30 De structuur van een gebruikersinterface die samengesteld is door componenten kan grafisch weergegeven worden in een flow chart als in Figuur 7. Calculator error result input calculate calculate input is number is reset reset is add add is subtract subtract Figuur 7: de gebruikersinterface componenten van een eenvoudige rekenmachine Een pagina wordt weergegeven zoals een klasse wordt weergegeven in een UML schema. Het wordt voorgesteld door een rechthoek die uit drie deelrechthoeken bestaat. De eerste deelrechthoek toont de naam van de pagina, de tweede de beans van de pagina en de derde de triggers van de pagina. Acties worden weergegeven door ovalen en voorwaarden door ruiten. De pijlen die figuren verbinden geven de link tussen componenten weer. Een flow chart als in Figuur 7 kan een duidelijk beeld van de structuur van een website weergeven in tegenstelling tot de configuratie informatie in XML bestanden. Het PACITA raamwerk heeft als doelstelling om na verloop van tijd dergelijke flow chart afbeeldingen te ondersteunen. 19

31 Kwaliteitsattributen De functionele vereisten bepalen wat het PACITA raamwerk moet doen, terwijl de kwaliteitsvereisten de architectuur van het raamwerk bepalen. De gewenste kwaliteiten voor het raamwerk worden vermeld (in volgorde van belangrijkheid): Bruikbaarheid De belangrijkste kwaliteit voor het PACITA raamwerk is dat het bruikbaar is. Het raamwerk moet gebruiksvriendelijk voor een organisatie zijn. De organisatie moet in staat zijn om de architectuur van een website op een duidelijke en eenvoudige manier te definiëren. Het definiëren van de architectuur van een website mag geen codering of XML configuratie vereisen. De architectuur van een website moet gedefiniëerd worden aan de hand van een gebruikersinterface. De initiële gebruikersinterface zal zijn als in Figuur 8. Figuur 8: de gebruikersinterface van het PACITA raamwerk De configuratie van een webapplicatie gebeurt in 5 stappen. Deze 5 stappen worden in de volgende paragraaf uitgelegd. De 5 tabs bovenaan de GUI corresponderen met deze stappen. Men kan van een stap in de configuratie naar een andere overgaan door op de tabs te klikken. Elke stap heeft een deelmenu dat bestaat uit iconen in de linkermarge. Men kan van deelstap naar een andere overgaan door op deze iconen te klikken Flexibiliteit Als we het Model-View-Controller patroon als beschreven in 3.1 beschouwen, kunnen we 3 verschillende stappen afleiden om een webapplicatie te configureren. Een stap integreert de functionaliteit in de webapplicatie. Een andere stap integreert de paginas in de webapplicatie. Een laatste stap beperkt de toegang tot paginas en functionaliteit tot zekere gebruikers en voorwaarden. 20

32 Echter, als we enkel 3 stappen gebruiken, moeten we de gebruikersinterface direct aan de functionaliteit koppelen. Als we dan de functionaliteit aanpassen, moeten we de gebruikersinterface ook aanpassen. Dit wordt geïllustreerd in de volgende figuur. Figuur 9: illustratie van koppeling (boven) en ontkoppeling (onder) tussen front end en back end Beschouw als voorbeeld een Data element dat een fotoalbum op een pagina toont 2. De pagina in kwestie toont het laatste fotoalbum dat aan de webapplicatie is toegevoegd. Als een nieuw fotoalbum wordt toegevoegd, moet de pagina aan een andere Data element verbonden worden. Dit kan gebeuren door het oude Data element te vervangen door het nieuwe Data element in de stap die het Model integreert zonder de pagina aan te passen. Echter, een andere pagina moet mogelijk nog aan het oude Data element verbonden zijn. Als we het oude Data element vervangen door het nieuwe Data element, dan zal deze andere pagina ook aan het nieuwe Data element verbonden zijn; tenzij de verbinding indirect is. Daarom verbinden we componenten niet direct aan elementen. In plaats hiervan verbinden we componenten aan referenties die verbonden zijn aan elementen. Als een component aan een nieuw element moet verbonden worden, kunnen de verbindingen van de componenten naar de referenties onveranderd blijven. Enkel de referentie moet aan een nieuw element verbonden worden, terwijl geen andere verbindingen aangepast moeten worden. In het voorbeeld kunnen beide paginas aan een andere referentie verbonden zijn. Deze referenties verwijzen initiëel naar hetzelfde oude Data element. Als we een van de referenties verbinden aan een 2 Het is mogelijk om Data elementen te programmeren die verschillende fotoalbums tonen in functie van invoer argumenten. Ik veronderstel hier een Data element die zijn invoer niet interpreteert en altijd hetzelfde fotoalbum toont, wat de invoer ook is. 21

33 nieuw Data element, dan kan de andere referentie nog steeds naar het oude Data element verwijzen. Er zijn dus twee stappen voor het model in plaats van een. De eerste stap is de Element Container stap die functionaliteit in het systeem integreert. De tweede stap is de Element Registry stap die referenties naar de elementen in het systeem bevat. Er zijn ook twee stappen voor de View. De eerste stap voor de View is de Component Registry stap. Deze stap definiëert de componenten van de gebruikersinterface. De tweede stap is de Application stap en vormt een indirecte verwijzing naar de applicatie die samengesteld wordt door de componenten. Deze indirectie laat toe dat een verwijzing naar een applicatie kan aangepast worden terwijl een andere verwijzing naar de zelfde applicatie naar de oude applicatie kan blijven wijzen. De vijfde stap is de User Management stap die toelaat om de toegang tot de functionaliteit en de gebruikersinterface te beperken. Het principe van ontkoppeling door een niveau van indirectie toe te voegen wordt ook toegepast op paginas. Paginas verwijzen niet direct naar de data die ze bevatten of de componenten die getriggerd kunnen worden vanaf de pagina. In plaats hiervan verwijzen bean-namen naar Data elementen en trigger-namen naar componenten. 22

34 Aanpasbaarheid Niet alle vereiste functionaliteit kan onmiddelijk ontworpen worden en vereisten kunnen evolueren na verloop van tijd, dus het PACITA raamwerk moet kunnen evolueren. Dit wordt in grote mate mogelijk gemaakt door het raamwerk aanpasbaar te maken. De volgende maatregelen worden in de architectuur van het raamwerk genomen om het aanpasbaar te maken: De gebruikersinterface van het raamwerk wordt onafhankelijk van de applicatie logica gemaakt. Beiden zijn expliciet verschillende projecten. De gebruikersinterface kan aangepast worden zonder de applicatie logica te wijzigen. De gebruikersinterface van het raamwerk zelf wordt gemaakt met een voorlopige versie van het PACITA raamwerk. De gebruikersinterface kan eenvoudig aangepast worden door de betrokken componenten of elementen aan te passen. Het raamwerk wordt onderverdeeld in 5 onafhankelijke projecten volgens de 5 stappen in de gebruikersinterface van het raamwerk. De applicatie logica en de gebruikersinterface van elk van deze projecten kan aangepast worden zonder een van de andere projecten te wijzigen Portabiliteit Het raamwerk en de websites die ermee gemaakt worden moeten naar elk ander systeem kunnen overgedragen worden. De code van de functionaliteit van een webapplicatie kan zich op elke server (of verschillende servers) waartoe het raamwerk via het internet toegang heeft bevinden. De code van de functionaliteit moet in de vier Java element interfaces ingekapseld worden. De code van de paginas van een webapplicatie kan zich op elke server (of verschillende servers) waartoe het raamwerk via het internet toegang heeft bevinden. De code van de paginas kan in elke geldige webtechnologie geschreven worden. 23

35 De structuur van een webapplicatie en de staat van een webapplicatie worden opgeslagen op de server waarop het raamwerk is geïnstalleerd. Het raamwerk is geprogrammeerd in Enterpise Java. Het raamwerk zelf wordt dus eenvoudig overgedragen naar een ander systeem. De functionaliteit en staat van de webapplicatie worden opgeslagen in objecten van klassen die een van de vier element interfaces implementeren. Deze objecten kunnen geëxporteerd en geïmporteerd worden naar en van bestanden via serializatie. De configuratie informatie van een webapplicatie kan geëxporteerd en geïmporteerd worden naar en van XML bestanden. De staat en architectuur van een webapplicatie wordt dus ook eenvoudig overgedragen van een server naar een andere Gebruikersbeheer De UserAccounts element interface laat een organisatie toe om een gebruikersaccountsysteem in de architectuur van zijn website in te pluggen. Dit gebruikersaccountsysteem kan gebruikt worden om gebruikersgroepen te creëren die gebaseerd zijn op bestaande gebruikersaccounts of om gebruikers in en uit de webapplicatie te loggen. Voor elke component of element kan er een lijst van gebruikersgroepen gedefiniëerd worden (in de User Management stap). Als een gebruiker geen lid is van een van de gebruikersgroepen, dan heeft hij geen toegang tot de component of het element. Lidmaatschap van een gebruikersgroep is disjunctief: een gebruiker is lid als hij direct lid is van de gebruikersgroep of als hij lid is van een andere gebruikersgroep die direct lid is van de gebruikersgroep. Authorisatie voor een component of een element is conjunctief: een gebruiker is enkel bevoegd om toegang te krijgen tot de component of het element als hij lid is van alle vereiste gebruikersgroepen Gebruik van EJB Het raamwerk is geprogrammeerd in Enterprise Java waarbij gebruik gemaakt is van EJB session beans en entiteiten. De EJB container ondersteunt verscheidene kwaliteiten als schaalbaarheid (met clustering en load-balancing) en transacties. 24

36 4.2. Architectuur De architectuur van het PACITA raamwerk kan vanuit verschillende perspectieven bekeken worden. De gezichtspunten die in deze verhandeling gedocumenteerd worden zijn: Module Decompositie Gezichtspunt: dit gezichtspunt specifiëert hoe het raamwerk logisch wordt samengesteld uit verschillende delen. Proces Gezichtspunt: dit gezichtspunt specifiëert de relatie tussen de kerncomponenten van het raamwerk en een sequentie diagramma van de controller. Toewijzingsgezichtspunt: dit gezichtspunt specifiëert hoe de logische delen worden afgebeeld op het bestandensysteem. Software Schemas: dit gezichtspunt toont schemas van de software. De schemas tonen structuur van de software zonder dat de broncode ontcijferd moet worden. De schemas worden geïncludeerd in de appendix Module decompositie gezichtspunt Het raamwerk wordt opgesplitst in modules die corresponderen met de 5 architecturale stappen. 3 van de 5 stappen worden verder opgesplitst in submodules. De decompositie in modules en sub-moules wordt geïllustreerd in Figuur 10. Elke sub-module komt overeen met een selecteerbaar item van de gebruiksersinterface. Application Management Application Configuration Application Emulation Component Management Component Registry Component View Page Flow View User Management User Group Registry User Component Registry User Element Registry User Log Element Registry Element Registry Figuur 10: De architecturele sub-modules van het PACITA raamwerk Element Container Element Container 25

37 Hier is een samenvatting van het doel van elke sub-module: Element Container: bevat geserialiseerde objecten die de functionaliteit en staat van webapplicaties samen stellen. Element Registry: bevat referenties naar de functionaliteit in element containers. User Group Registry: bevat gebruikersgroep definities. User Component Registry: beheert de toegangsbeperkingen op componenten. User Element Registry: beheert de toegangsbeperkingen op elementen. User Log: bevat logs van gebruikerstoegangen tot componenten en elementen. Component Registry: bevat de definities van de componenten. Component View: toont de configuratie van een component en zijn verband met andere componenten. Page Flow View: toont de data en triggers op een pagina en het verband met andere paginas. Application Configuration: configureert de webapplicaties. Een webapplicatie kan gestart worden in een popup scherm. Application Emulation: emuleert een applicatie. Het is mogelijk om de toegang tot de componenten en de elementen voor een gegeven gebruiker en applicatie te controleren zonder de componenten of de functionaliteit te laden. 26

38 Proces gezichtspunt Het volgende schema illustreert het verband tussen de kern klassen van het PACITA raamwerk. StatefullSessionBeans ApplicationSessionRemote DataTag DataSession ComponentRegistry UserSession ElementRegistry UserGroupRegistry Log Figuur 11: de kern klassen van het PACITA raamwerk en hun verbanden ApplicationSessionRemote, DataSession en UserSession bevatten de sessie informatie van de webapplicatie. ComponentRegistry, ElementRegistry, UserGroupRegistry en Log bevatten de configuratie informatie van de webapplicatie. Het DataSession object kan opgevraagd worden door de getdatasession statische methode van de DataTag klasse aan te roepen. Het ApplicationSessionRemote object kan opgevraagd worden door de get statische methode van de StatefullSessionBeans klasse aan te roepen en de ApplicationSessionRemote klasse als argument mee te geven. Het object van een andere klasse in het schema wordt verkregen door de gepaste get methode van de klasse die naar deze andere klasse in het schema wijst aan te roepen. 27

39 Via het ApplicationSessionRemote object kan men het ComponentRegistry object en de standaard component van een webapplicatie verkrijgen. Via het DataSession object kan men de bean gedefiniëerd door de huidige data custom tag en de beans gedefiniëerd door zijn ouder data custom tags verkrijgen. Men kan ook het aantal keer dat de huidige data custom tag of zijn ouder data custom tags zijn geïtereerd opvragen en instellen of een van deze data custom tags een andere keer zal geïtereerd worden of niet. Via het UserSession object kan men een gebruiker inloggen, controleren of iemand ingelogd is en de gebruikersnaam opvragen en een gebruiker uitloggen. Opdat iemand kan inloggen voor de webapplicatie, moet een UserAccounts object voor de webapplicatie ingesteld worden. Het ComponentRegistry object bevat de definitie van de componenten van de webapplicatie. Het ElementRegistry object bevat de referenties naar de functionaliteit van de webapplicatie. Het UserGroupRegistry object stelt het UserAccounts object voor de webapplicatie in en bevat de definities van de gebruikersgroepen. Er moet geen UserGroupRegistry object gedefiniëerd worden voor een webapplicatie als er geen gebruikersbeheer is voor de webapplicatie. Het Log object logt wanneer een gebruiker in- of uit-logt en welke componenten en elementen een gebruiker aanspreekt. Er hoeft geen Log object gedefiniëerd te worden voor een webapplicatie als de interactie van gebruikers met de webapplicatie niet gelogd wordt. Het proces van de controller van de webapplicatie is als in Figuur

40 ComponentRegistry PageSessionRemote ElementRegistry loop [controller component] alt [page component] Figuur 12: een abstractie van het controller proces Eerst wordt de huidige component van de webapplicatie geïnitialiseerd. Terwijl de huidige component ofwel een actie of een conditie component is, controlleert de controller of het de bevoegdheid heeft om de component aan te spreken. Als de controller geen dergelijke bevoegdheid heeft, wordt de behandeling van de component afgebroken. Als de controller bevoegd is om de component aan te spreken, vraagt het het ElementRegistry object om de execute of test methode van het geassociëerde element uit te voeren. Na het uitvoeren van de methode, wordt de volgende huidige component geïnitialiseerd en de lus wordt heruitgevoerd. Als de huidige component een pagina component is, controlleert de controller of het de bevoegdheid heeft om de pagina aan te spreken. Als de controller geen dergelijke bevoegdheid heeft, wordt de behandeling van de pagina afgebroken. Als de controller bevoegd is om de pagina aan te spreken, worden de beans en de triggers van de pagina geïnitialiseerd. Vervolgens wordt de pagina als uitvoer naar de gebruiker gestuurd. Een data custom tag in de pagina veroorzaakt het uitvoeren van de getdatabean methode van het geassociëerde Data element. De bean die gedefiniëerd wordt door de data custom tag wordt ingesteld op de geretourneerde waarde van deze methode. De methode van een element wordt aangesproken als in Figuur

41 ElementRegistry UserGroupRegistry Container loop loop Figuur 13: bevoegde toegang tot de methode van een element De controller controleert of de huidige gebruiker lid is van al de gebruikersgroepen van het element. Dan wordt voor elke voorwaarde van het element de authorisatieprocedure recursief aangeroepen. Als en slechts als de gebruiker lid is van al de gebruikersgroepen en aan alle voorwaarden voldaan wordt, wordt de methode van het element uitgevoerd. De authorisatie voor componenten is gelijkaardig: er wordt eerst gecontrolleerd of een gebruiker lid is van alle vereiste gebruikersgroepen en dan worden alle vereiste voorwaarden getest. Een gebruiker kan een component enkel aanspreken als hij lid is van alle vereiste gebruikersgroepen en als aan alle vereiste voorwaarden voldaan wordt. Van zodra de gebruiker geen lid is van een gebruikersgroep of aan een voorwaarde wordt niet voldaan, wordt de authorisatie afgebroken Toewijzingsgezichtspunt Elke sub-module wordt afgebeeld op een software broncode package: Element Container: be.macharis.toon.pacita.container Element Registry: be.macharis.toon.pacita.element User Group Registry: be.macharis.toon.pacita.user.group User Component Registry: de functionaliteit wordt geïmplementeerd in de Component Registry package User Element Registry: de functionaliteit wordt geïmplementeerd in de Element Registry package 30

42 User Log: be.macharis.toon.pacita.user.log Component Registry: be.macharis.toon.pacita.component Component View: de functionaliteit wordt geïmplementeerd in de Component Registry package Page Flow View: de functionaliteit word geïmplementeerd in de Component Registry package Application Configuration: be.macharis.toon.pacita.application Application Emulation: de functionaliteit wordt geïmplementeerd in de Component Registry package 31

43 Elke sub-module wordt afgebeeld op een URL patroon waar de bronbestanden van de gebruikersinterface gevonden kunnen worden: Element Container: container Element Registry: element User Group Registry: user.group User Component Registry: user.component User Element Registry: user.element User Log: user.log Component Registry: component Component View: component.view Page Flow View: component.pageflow Application Configuration: application Application Emulation: application.emulation Als <patroon> het gegeven patroon is, dan: bevinden de paginas van de sub-module zich op /pacita_ui_0_1/<patroon>/ bevinden de actie elementen van de sub-module zich op pacita.<patroon>.actions bevinden de conditie elementen van de sub-module zich op pacita.<patroon>.conditions bevinden de data elementen van de sub-module zich op pacita.<pattern>.data bevinden de custom tags van de sub-module zich op pacita.<pattern>.tags 32

44 4.3. Planning Het is moeilijk om de tijd te schatten die nodig is om software te schrijven dat aan een zekere specificatie voldoet. Een nauwkeurige schatting zou de kennis vereisen van welke code er geschreven zal worden en hoe lang het duurt om elke regel code te schrijven. Men beschikt enkel over deze kennis wanneer het software project af is. Echter, er bestaan methodologieën die de resultaten van het schrijven van software maximaliseren voor een gegeven hoeveelheid tijd. Deze methodologieën bestaan typisch uit het opdelen van de software in kleine onafhankelijke sub-projecten die relatief snel verwezenlijkt kunnen worden. De belangrijkste sub-projecten worden eerst verwezenlijkt en de reeds verwezenlijkte kern kan na verloop van tijd evolueren om stabieler, efficiënter en algemener te worden. De belangrijkste sub-projecten zijn deze die ofwel een maximale functionaliteit aanbieden voor een minimale inspanning of deze die het risicovolst zijn. Het eerst aanpakken van risicovolle sub-projecten minimaliseert de accumulatie van het risico naar de andere sub-projecten. In deze geest is het PACITA raamwerk ontwikkeld in iteraties en zal het blijven evolueren in iteraties. Elke iteratie bouwt op de vorige, waarbij de vorige een beetje wordt uitgebreid. In de laatste iteratie voor deze verhandeling werden de risicos eerst aangepakt. Het raamwerk bestaat uit onafhankelijke modules zoals uiteengezet in de beschrijving van het aanpasbaarheidskwaliteitsattribuut. 33

45 Iteratieve ontwikkeling De huidige iteratie van het PACITA raamwerk is de 4 e iteratie. De iteraties zijn hieronder beschreven Iteratie 1 De eerste iteratie van het PACITA raamwerk was ontwikkeld in PHP. Er was een PHP pagina die als controller dienst deed. Paginas bevatten directe referenties naar dynamische data en naar acties die konden getriggerd worden van de pagina. Een trigger gaf de controle door aan de controller pagina, die de geassociëerde actie uitvoerde, de dynamische inhoud instelde en de gepaste pagina naar de gebruiker stuurde. Het aaneenhangen van acties was niet mogelijk, doch acties konden genest worden in het codeblok van een andere actie. De code werd georganiseerd in 3 delen in overeenstemming met het MVC-patroon. Een directory bevatte de paginas. Deze paginas kwamen overeen met de View. Een andere directory bevatte klassen die de functionaliteit implementeerden. Deze klassen kwamen overeen met het Model. Een derde directory bevatte de acties. Deze acties hadden een uitvoerbare methode die de gepaste functionaliteit van de klassen aanriep. Deze acties kwamen overeen met de Controller. De naam en het path van acties en paginas werden ingebracht in een MySQL databank tabel. Als de controller een actie diende uit te voeren of een pagina diende te includeren, kon het het path naar het bronbestand vinden in de MySQL databank Iteratie 2 Tijdens de ontwikkeling in PHP werd het duidelijk dat PHP niet zo portabel of stabiel is als Java. Ik zou hier een gedetailleerde beschrijving kunnen geven van de moeilijkheden die ik tegengekomen ben, doch in plaats hiervan zal ik naar [JAVAvsPHP] verwijzen. Bovendien is de API van PHP niet zo ruim als de API van Java en Java heeft betere ontwikkelingomgevingen. Weerom zal ik niet in detail gaan. Het is een feit dat enkele goed gemotiveerde technische redenen me ertoe hebben aangezet PHP te verlaten ten voordele van Java, maar ik zal deze redenen niet uiteenzetten aangezien ik denk dat een dergelijke uiteenzetting een afleiding zou zijn van de kern van de zaak. 34

46 Deze iteratie introduceerde de Action en Condition elementen en de Action, Condition en Page componenten. De componenten konden vanaf deze iteratie aaneengehangen worden. Paginas bevatten directe verwijzingen naar de componenten die getriggerd konden worden vanaf de pagina. De directe verwijzing had het nadeel dat de eigenlijke naam van een component moest gebruikt worden in een trigger. De naam van de component moest gebruikt worden als waarde voor de trigger (die geïmplementeerd was als de component parameter) en de View was gekoppeld aan het Model zoals uitgelegd in de paragraaf over het flexibiliteitskwaliteitsattribuut. Ook werden alle direct bereikbare componenten blootgesteld op alle paginas. De controller werd statisch in de broncode geconfigureerd Iteratie 3 Deze iteratie introduceerde het Data element. Een pagina verwees indirect naar zowel Data elementen als de componenten die getriggerd konden worden van de pagina in plaats van er direct naar te verwijzen. Dit liet toe om de naam van de Data elementen en componenten van de pagina te ontkoppelen. Ook waren enkel de Data elementen en componenten die gedeclareerd werden voor een pagina toegankelijk vanaf de pagina, in plaats van allemaal zoals in de vorige iteratie. De controller voor een webapplicatie werd geconfigureerd met 2 XML bestanden: een om de functionaliteit en een ander om de gebruikersinterface in het raamwerk te integreren. Dit wordt geïllustreerd in Figuur 14. Functionality Linking XML File Linking Schema Linking Registry Application Developer Application Editing XML File Editing Schema Component Registry Presentation Figuur 14: configuratie van de controller in de derde iteratie 35

47 Het linking bestand bevatte de definities van de elementen en moest aan het linking schema voldoen. Het editing bestand bevatte de definities van de componenten en moest aan het editing schema voldoen. De controller sprak de gepaste componenten aan om een applicatie te draaien. De volgende iteratie van het raamwerk werd ontworpen met deze iteratie als raamwerk Iteratie 4 De huidige iteratie heeft veel nieuwe kenmerken geïncludeerd. Eerst en vooral configureert het huidige raamwerk een webapplicatie met behulp van een GUI. De configuratie kan geëxporteerd worden naar en geïmporteerd worden van XML bestanden. De staat van de binaire objecten kan geserialiseerd worden naar of gedeserialiseerd worden van bestanden. Het raamwerk wordt geïmplementeerd door gebruik te maken van een EJB 3.0 container. Het gebruikt lightweight persistentie in de vorm van entiteiten en geen SQL code moest geprogrammeerd worden. Elke verandering van de staat van de webapplicatie is transactioneel. Een webapplicatie is schaalbaar en kan ge-loadbalanced worden. De klassen van de webapplicatie moeten niet beschikbaar zijn tijdens het opzetten van het PACITA raamwerk, maar kunnen op elk ogenblik dynamisch geladen worden. Klassen kunnen zowel van de lokale server als van een externe server geladen worden. Zowel paginas die zich op de lokale server bevinden als paginas die zich op een externe server bevinden kunnen in het raamwerk geïntegreerd worden. De data custom tag wordt geïntroduceerd om Data elementen te includeren in een pagina en de Data elementen kunnen deze tag itereren of Data elementen van ouder data custom tags aanspreken. De data custom tag vormt een volledig alternatief voor custom tags in het algemeen. Bijgevolg kunnen volledig functionele JSP paginas uit alleen maar XHTML code, data custom tags en getproperty JSP acties bestaan(!) Dit ontkoppelt de JSP paginas volledig van de applicatie logica en vereenvoudigt aanzienlijk het onderhoud van de JSP paginas. 36

48 Op het moment van schrijven is deze iteratie nog niet beëindigd. De nog niet verwezenlijkte kenmerken zijn flow charts van de gebruikersinterface van een webapplicatie en ondersteuning voor gebruikersbeheer. Flow charts zullen een grafisch overzicht geven van welke componenten voorafgaan aan en volgen op een component en van welke paginas voorafgaan aan en volgen op een pagina. Gebruikersbeheer wordt mogelijk gemaakt door het UserAccounts element, dat in deze iteratie geïntroduceerd is. Het gebruikersbeheer zal bestaan uit de mogelijkheid om gebruikersgroepen te definiëren en om de toegang tot componenten en elementen te beperken tot zekere gebruikersgroepen of voorwaarden waaraan voldaan moet zijn. Het zal mogelijk zijn om elke toegang tot een element of een component te loggen. Ook zal een emulatie van de webapplicatie het mogelijk maken te controleren voor welke componenten en elementen elke gebruiker of gebruikersgroep bevoegd is en voor welke niet, zonder de applicatie te draaien Risicos De risicos voor de verwezenlijking van de huidige iteratie hielden hoofdzakelijk verband met de toegevoegde kenmerken. De veronderstelde risicos waren het dynamisch laden van klassen, het lezen van bestanden op een externe server, lightweight persistentie en de flow charts en het gebruikersbeheer. De paragrafen hieronder leggen uit hoe deze risicos aangepakt werden Het dynamisch laden van klassen Het dynamisch laden van klassen was een nieuw concept en de uitleg hier maakt duidelijk dat ik erin geslaagd ben om de details ervan te begrijpen. Eenmaal ik de details van het laden van klassen verstond, was het duidelijk dat de enige beperking op het laden van klassen die niet voorzien was tijdens de intiële planning, is dat de originele klasse definities beschikbaar moeten blijven om geserialiseerde objecten te kunnen deserialiseren. 37

49 Klasse laders vormen een hiërarchie en klassen worden geladen van de klasse lader met het hoogste niveau in de hiërarchie die de klasse definitie bevat. Dit voorkomt dat klasse definities zouden vervangen worden door kwaadwillige code onderaan de hiërarchie. Ook kan een veiligheidsuitzondering opgeworpen worden als een nieuwe klasse definitie onderaan de hiërarchie zich in een package bevindt waartoe enkel klasse laders van een hoger niveau in de hiërarchy bevoegde toegang hebben. Eens een klasse geladen wordt, blijft ze conceptueel altijd geladen. (Doch een klasse object kan door de garbage collector opgeruimd worden als er geen verwijzingen meer zijn naar zijn klasse lader en naar alle objecten van de klasse lader.) Een klasse definitie die geladen wordt in een klasse lader is niet compatibel met dezelfde klasse definitie die geladen wordt in een andere klasse lader. Echter, door gebruik te maken van proxies en invocation handlers is het mogelijk om objecten van beide klasse definities aan te spreken met dezelfde interface. De standaard ObjectInputStream deserialiseert objecten naar de systeem klasse lader. Men kan objecten naar een aangepaste klasse lader deserialiseren door een sub-klasse te maken van de ObjectInputStream klasse en de resolveclass methode te overriden. Argumenten van remote session beans worden automatisch geserialiseerd en gedeserialiseerd door gebruik te maken van de systeem klasse lader. Het is conceptueel onmogelijk om de argumenten van session beans te deserialiseren naar een aangepaste klasse lader en dit is dus een tekortkoming in de EJB container [EJBlimit]. Het is echter mogelijk om objecten expliciet te serialiseren voordat ze als een argument worden doorgegeven aan een session bean methode, het argument als een byte array door te geven en in de methode de byte array expliciet te deserialiseren naar een aangepaste klasse lader. Het laden van een klasse bestaat uit drie fasen: laden: de binaire data van de klasse definitie wordt in het geheugen geplaatst linken: de binaire data van de klasse definitie in het geheugen wordt verwerkt initialiseren: de statische initialisatie van de klasse wordt uitgevoerd 38

50 De volgende methoden zijn van belang voor het laden van klassen: ClassLoader.loadClass(String name): laadt de klasse met de gegeven naam voor de gegeven klasse lader. ClassLoader.resolveClass(Class<?> c): linkt de gegeven klasse voor de gegeven klasse lader. Class.forName(String name, boolean initialize, ClassLoader loader): laadt en linkt de klasse met de gegeven naam voor de gegeven klasse lader. Of de klasse geïnitialiseerd wordt hangt af van de waarde van de boolean initialize. ObjectInputStream.resolveClass(ObjectStreamClass desc): de methode van ObjectInputStream die overschreven moet worden als een klasse definitie geladen moet worden van een aangepaste klasse lader Externe bestanden Het lezen van externe bestanden lag nogal voor de hand. Een stukje code zoals hieronder zou de klus klaren. De klassen URI, URL en URLConnection zijn van de package java.net en de klassen InputStream en BufferedInputStream zijn van de package java.io. // link is a string representation of the remote URI URI sourceuri = new URI(link); URL sourceurl = sourceuri.tourl(); URLConnection connection = sourceurl.openconnection(); InputStream in = new BufferedInputStream(connection.getInputStream()); // continue manipulating in Lightweight persistentie Lightweight persistentie heeft het potentiëel om SQL code die gegenereerd wordt door gebruikers en het onderhoud dat ermee gepaard gaat onnodig te maken. EJB 3.0 entiteiten zijn een manier om lightweight persistentie te bereiken. Echter, de EJB 3.0 persistentie specificatie [EJB3.0] is op het moment van schrijven nauwelijks een jaar oud en de beschikbare documentatie is eerder beknopt, onduidelijk en ambigu. Het vereiste enig experimenteerwerk om de specificatie te vatten. 39

51 Enkele waargenomen moeilijkheden: Entiteiten kunnen geen statische methoden hebben. De waarde van de primaire sleutel van een entiteit kan geconfigureerd worden als auto-increment. Dit incrementeert de waarde van de primaire sleutel die opgeslagen wordt in de databank, maar heeft geen invloed op de waarde van de primaire sleutel van de gedetacheerd entiteit. Dus als men gedetacheerde entiteiten wil creëren met een auto-incrementerende primaire sleutel, dan moet men expliciet een algoritme ontwerpen voor het genereren van de primaire sleutel. Dependency injectie lijkt soms niet te werken. In een dergelijk geval moet een expliciete JNDI opzoeking uitgevoerd worden. De lokale interface voor session beans lijkt niet te werken als ze onrechtstreeks aangesproken worden buiten de EJB container. Een remote interface moet dus in de praktijk voor alle session beans gebruikt worden. De EJB container lijkt dummy entiteiten te kunnen aanmaken. De standaard constructor mag geen initialisatie code bevatten die conflicteert met het aanmaken van dummy entiteiten. Een vroege versie van de Sun Application Server die de EJB 3.0 specificatie ondersteunt lijkt niet correct om te gaan met LOB velden van een entiteit. Deze velden moeten expliciet geserialiseerd worden naar byte arrays. De automatisch gegenereerde code door Netbeans voor het aanpassen van entiteiten in persistente opslag of het verwijderen van entiteiten van persistente opslag is verkeerd (in combinatie met een ambigue Java persistentie specificatie). De volgende tabel toont de verbetering van de automatisch gegenereerde code in de façade session bean voor een entiteit. SQL equivalent automatic generated code correct code update em.merge(entity); Entity attached = em.merge(entity); attached.copy(entity); delete em.merge(entity); em.remove(em.merge(entity)); em.remove(entity); Figuur 15: verkeerde automatisch gegenereerde code voor het aanpassen en verwijderen van entiteiten en de verbetering. Echter, eenmaal de persistentie API duidelijk was en het duidelijk was aan welke voorwaarden entiteiten moesten voldoen, waren er geen moeilijkheden meer om entiteiten op te slaan, op te halen, aan te passen en te verwijderen. 40

52 Flow charts en gebruikersbeheer De flow charts en het gebruikersbeheer zijn geen essentiëel onderdeel van het raamwerk. Hun integratie in het systeem vormt dus niet het risico. Het risico is dat hun ontwikkeling tijd in beslag neemt. Het risico wordt aangepakt door het systeem aanvankelijk zonder ondersteuning voor flow charts of gebruikersbeheer te ontwerpen en enkel nadat alle andere vereisten geïmplementeerd zijn, wordt de ondersteuning voor flow charts en gebruikersbeheer ontwikkeld. Op het moment van schrijven is de ondersteuning voor flow charts en gebruikersbeheer nog niet afgewerkt, doch het raamwerk is volledig functioneel aangezien alle essentiële delen van het raamwerk geïmplementeerd zijn. 41

53 Onafhankelijke delen Het project wordt opgedeeld in kleinere projecten die onafhankelijk van elkaar ontworpen kunnen worden. Elk van de kleinere projecten implementeert een deel van de functionaliteit van het totale project. De risicos werden eerst aangepakt. Er waren ongeveer 3 weken nodig om de details van het dynamisch laden van klassen te verstaan en ongeveer 2 weken om alle moeilijkheden met EJB entiteiten op te lossen. Nadien volgden 4 ontwikkelingsstappen die elk ongeveer 3 weken in beslag namen: De eerste ontwikkelingsstap focuste op de ontwikkeling van algemene ondersteuningsklassen. De tweede ontwikkelingsstap implementeerde de functionaliteit en gebruikersinterface voor het integreren van functionaliteit in het PACITA raamwerk. De derde ontwikkelingsstap implementeerde de functionaliteit en gebruikersinterface voor het aanmaken van verwijzingen naar de functionaliteit de geïntegreerd is in het PACITA raamwerk. Deze ontwikkelingsstap implementeerde ook voorzieningen voor gebruikersbeheer, wat het gemakkelijker maakt om de functionaliteit voor gebruikersbeheer achteraf af te werken. De vierde ontwikkelingsstap implementeerde de functionaliteit en gebruikersinterface voor het beheren van componenten en configureren van applicaties met het PACITA raamwerk. Deze ontwikkelingsstap implementeerde ook voorzieningen voor flow charts, wat het gemakkelijker maakt om de functionaliteit voor flow charts achteraf af te werken. Deze ontwikkelingsstappen zijn dezelfde als de stappen waarvoor de software schemas die zich in de appendix bevinden zijn gemaakt. 42

54 5. Demonstratie 5.1. Configuratie Om het PACITA raamwerk te kunnen draaien heeft men Java SE 6 en een Java EE 5 applicatie server nodig. Java SE 6 kan gedownload worden op [JavaSE]. Netbeans met een Java EE 5 applicatie server kan gedownload wordern op [JavaEE]. De PACITA raamwerk broncode kan gedownload worden op [PACITAsource]. In dit deelhoofdstuk zal ik uitleggen hoe het PACITA raamwerk opgezet kan worden op een test computer door gebruik te maken van Netbeans en de ingebouwde applicatie server. Nadat de Java SE 6 Development Kit en de Netbeans Java EE 5 Tools Bundle geïnstalleerd zijn, moet je de broncode van het PACITA raamwerk downloaden en het naar een directory op je computer unzippen. Vervolgens start je Netbeans op. In het Netbeans menu, selecteer je File Open Project. Je bladert naar de directory waar je de broncode van het PACITA raamwerk geunzipt hebt en selecteert de projecten PACITA-v0_2_8-ejb en PACITA-v0_2_8-war om te openen. Het selectie scherm zal eruit zien als in Figuur 16. Figuur 16: het openen van het EJB en Web project van het PACITA raamwerk 43

55 Nadat je de projecten in de Netbeans IDE geopend hebt, moet je rechts klikken op de naam van het web project en Properties selecteren als in Figuur 17. Figuur 17: het selecteren van de eigenschappen van het web project 44

56 Onder de eigenschappen van het web project moet je Libraries selecteren en nagaan of er een correcte verwijzing naar het EJB project aanwezig is. Als je de broncode downloadt en het in een directory installeert, zou het web project een verwijzing naar het EJB project bevatten, maar de verwijzing zou gebroken zijn. (Tenzij je exact dezelfde directory structuur als mij zou gebruiken.) Je moet de verwijzing corrigeren door de gebroken verwijzing te verwijderen en een correcte verwijzing toe te voegen. Je voegt een correcte verwijzing toe aan het EJB project door op de Add Project knop te klikken en het EJB project te selecteren. Het scherm met de eigenschappen is geïllustreerd in Figuur 18. Figuur 18: eigenschappen van het web project 45

57 Nadat je de verwijzing van het web project naar het EJB project juist hebt ingesteld, moet je het EJB project en het web project compileren. Je doet dit door rechts op de naam van de projecten te klikken en Clean and Build Project te selecteren. Dit wordt geïllustreerd in Figuur 19 en Figuur 20. Figuur 19: het compileren van het EJB project Figuur 20: het compileren van het web project 46

58 Nadat de projecten gecompileerd zijn, is het tijd om hen op de applicatie server op te zetten. Je zet de projecten op de ingebouwde applicatie server op door rechts te klikken op hun naam en Deploy Project te selecteren als geïllustreerd in Figuur 21 en Figuur 22. Je zet eerst het EJB project op en dan het web project. Figuur 21: het opzetten van het EJB project Figuur 22: het opzetten van het web project 47

59 Nadat de projecten opgezet zijn, ga je naar de URL Dit zal het PACITA raamwerk initialiseren en de uitvoer naar de browser zal als in Figuur 23 zijn. Figuur 23: initialisatie van het PACITA raamwerk Nadat het PACITA raamwerk geïnitialiseerd is, kan je het raamwerk aanspreken vanuit een browser door naar de URL te gaan. De uitvoer naar de browser zal als in Figuur 24 zijn. Figuur 24: startpagina van het PACITA raamwerk 48

60 5.2. Het maken van een eenvoudige rekenmachine Nu we het PACITA raamwerk geïnstalleerd hebben, zullen we beginnen met het maken van een eenvoudige toepassing. De volgende deelhoofdstukken zullen aantonen hoe de toepassing flexibel kan aangepast worden. We zullen een eenvoudige rekenmachine maken. De grafische gebruikersinterface van de rekenmachine wordt geïllustreerd in Figuur 25. Calculator error result input calculate calculate input is number is reset reset is add add is subtract subtract Figuur 25: de GUI van een eenvoudige rekenmachine, stippelijnen zijn de paden die gevolgd worden wanneer een voorwaarde vals is, volle lijnen zijn de paden die gevolgd worden wanneer een voorwaarde geldt. Om de rekenmachine te maken zijn er drie zaken nodig: de functionaliteit, de webpaginas waarmee gebruikers interageren en de configuratie die de webpaginas met de functionaliteit verbindt. De functionaliteit en de webpaginas moeten niet door een organisatie ontworpen worden. De functionaliteit wordt ontworpen door software aanbieders in de vorm van elementen. De webpaginas worden ontworpen door webontwerpers. Een organisatie moet enkel de configuratie van zijn webapplicatie juist instellen met een grafische gebruikersinterface. Niettegenstaande, in dit eenvoudige voorbeeld zal ik ook de elementen en de webpagina tonen om een volledig beeld te geven van hoe het raamwerk werkt. Ik zal ook de grafische gebruikersinterface in detail uitleggen door een schermafbeelding van elke kleine stap te tonen. Later, wanneer ik zal tonen hoe de applicatie kan aangepast worden nadat ze samengesteld is, zal ik niet meer zo veel in detail gaan, aangezien ik ervan uit zal gaan dat de lezer zich bewust zal zijn van de details die weggelaten worden. 49

61 Het Model De rekenmachine vereist de implementatie van 3 Action elementen, 4 Condition elementen en 3 Data elementen. De broncode van de Action elementen: public class Add implements Action { public void execute(httpservletrequest request) { HttpSession session = request.getsession(); int result = (Integer)session.getAttribute("result"); int input = (Integer)session.getAttribute("input"); session.setattribute("result", result + input); } } public class Reset implements Action { public void execute(httpservletrequest request) { HttpSession session = request.getsession(); session.setattribute("result", 0); session.setattribute("input", 0); } } public class Subtract implements Action { public void execute(httpservletrequest request) { HttpSession session = request.getsession(); int result = (Integer)session.getAttribute("result"); int input = (Integer)session.getAttribute("input"); session.setattribute("result", result - input); } } De broncode van de Condition elementen: public class InputIsNumber implements Condition { public boolean test(httpservletrequest request) { String input = request.getparameter("input"); HttpSession session = request.getsession(); try { session.setattribute("input", new Integer(input)); if (session.getattribute("result") == null) { session.setattribute("result", 0); } return true; } catch (NumberFormatException e) { session.setattribute("error", ""<i>" + input + "</i>" is not a valid number"); return false; } } } 50

62 public class IsAdd implements Condition { public boolean test(httpservletrequest request) { return request.getparameter("operation").equals("add"); } } public class IsReset implements Condition { public boolean test(httpservletrequest request) { return request.getparameter("operation").equals("reset"); } } public class IsSubtract implements Condition { public boolean test(httpservletrequest request) { return request.getparameter("operation").equals("subtract"); } } De broncode van de Data elementen: public class Error implements Data { public static class Bean { private String message; private Bean(String message) { this.message = message; } public String getmessage() { return message; } } public Object getdatabean(httpsession session) { String errormessage = (String)session.getAttribute("error"); if (errormessage!= null) { session.removeattribute("error"); return new Bean(errorMessage + "<br/><hr/>"); } else { return new Bean(""); } } } public class Input implements Data { public static class Bean { private String value; private Bean(String value) { this.value = value; } public String getvalue() { return value; } } public Object getdatabean(httpsession session) { Integer input = (Integer)session.getAttribute("input"); if (input == null) { input = 0; } return new Bean(input.toString()); } } public class Result implements Data { public static class Bean { private String value; private Bean(String value) { this.value = value; } public String getvalue() { return value; } } public Object getdatabean(httpsession session) { Integer result = (Integer)session.getAttribute("result"); if (result == null) { result = 0; } return new Bean(result.toString()); } } 51

63 De View De rekenmachine heeft maar een pagina. De broncode van de pagina is: contenttype="text/html"%> pageencoding="utf-8"%> uri="/web-inf/tlds/pacita.tld" prefix="pacita"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" " <html> <head> <meta http-equiv="content-type" content="text/html; charset=utf-8"/> <title>basic Calculator</title> <script language="javascript"> <!-- function post(trigger, operation) { span = document.getelementbyid('args'); span.innerhtml = '<input type="hidden" name="trigger"' + ' value="' + trigger + '"/>' + '<input type="hidden" name="operation"' + ' value="' + operation + '"/>'; document.form.submit(); } //--> </script> </head> <body> <form name="form" action="?" method="post"> <pacita:data bean="error_bean"> <jsp:getproperty name="error_bean" property="message"/> </pacita:data> <pacita:data bean="result_bean"> Result: <b><jsp:getproperty name="result_bean" property="value"/></b><br/> </pacita:data> <span id="args"></span> <pacita:data bean="input_bean"> Input: <input type="text" name="input" value="<jsp:getproperty name="input_bean" property="value"/>"/> <br/> </pacita:data> <a href="javascript:post('calculate', 'reset')">reset</a> <a href="javascript:post('calculate', 'add')">add</a> <a href="javascript:post('calculate', 'subtract')" >subtract</a> </form> </body> </html> 52

64 Bemerk dat er geen server-side scripting in de webpagina aanwezig is 3. Er is geen nood aan scripts in een webpagina aangezien de <pacita:data/> custom tag de volledige functionaliteit van custom tags in het algemeen en de volledige functionaliteit die scripting kan leveren aanbiedt. Scripten in webpaginas is zowat het ergste software anti-pattern [Antipattern] dat er bestaat, omdat het webpaginas niet onderhoudbaar maakt. Scripten is de ultieme manifestatie van spaghetti code [SpaghettiCode]. Als je me niet zou geloven dat scripten zinloos is, geef je er ten volle aan over, ik ga niet met je discussiëren, het is niet mijn tijd die je verspeelt De Controller Een organisatie wordt enkel blootgesteld aan de details van de controller van een webapplicatie. De controller integreert de webpaginas met de elementen. De controller wordt beheert met de GUI van het PACITA raamwerk. Ik zal aan de hand van becommentariëerde schermafbeeldingen in de kleinste details uitleggen hoe men een eenvoudige rekenmachine bouwt van de elementen en pagina gegeven in de vorige paragrafen. Er zullen vier noodzakelijke stappen zijn om de configuratie van een webapplicatie te vervolledigen. Deze stappen zijn de Element Container stap, de Element Registry stap, de Component Registry stap en de Application Configuration stap zoals uitgelegd in Ik zal de vier stappen de een na de andere uitleggen. Enkel de noodzakelijke delen zullen behandeld worden. Gebruikersbeheer en flow charts, die nog niet geïmplementeerd zijn op het moment van schrijven en die niet noodzakelijk zijn, zullen niet behandeld worden Element container Als men op de Element Container tab van de GUI klikt en vervolgens klikt men op de start vlag, dan ziet men het volgende scherm. 3 Ja, er is een beetje JavaScript, maar dat is client-side scripting 53

65 Dit scherm toont alle containers die object instanties van element klassen bevatten. Deze containers bevatten dus de staat en functionaliteit van alle webapplicaties. Op deze schermafbeelding en op de schermafbeeldingen die volgen zal er reeds configuratie informatie van enkele bestaande test applicaties aanwezig zijn. Ik heb de configuratie informatie van deze andere test applicaties in het raamwerk gelaten, om te benadrukken dat het raamwerk meerdere applicaties tegelijkertijd kan ondersteunen. We maken een nieuwe container aan om de elementen van onze eenvoudige rekenmachine te bevatten. Hiervoor moeten we de naam van de container in het tekstveld schrijven en op de kleine zon rechts van het tekstveld klikken. Dit maakt een nieuwe lege container met de gespecifieerde naam aan, in het geval er nog geen container met deze naam bestond. Ik heb calculator functionality in het tekstveld ingevuld en op de gele zon geklikt. In de schermafbeelding hierboven is de lege container met deze name reeds aangemaakt. Nadien klikken we op het groene aanvinkteken links van de calculator functionality container. Dit leidt ons tot het volgende scherm. Het bovenstaande scherm toont de elementen in de geselecteerde container. Omdat we een nieuwe lege container hebben aangemaakt, zijn er nog geen elementen in de container. Om elementen in de container te laden, klikken we op Load en we krijgen het volgende scherm te zien. 54

66 We krijgen een tekstveld te zien waarin we een bron URI kunnen ingeven die de klasse definities van elementen bevat. Deze URI verwijst naar een JAR bestand. Het JAR bestand kan zich ofwel op de lokale server ofwel op een externe server bevinden. In dit geval bevindt het JAR bestand zich op de lokale server. Het JAR bestand bevindt zich in de root van de server en de naam van het JAR bestand is basic.jar. Nadat ik de URI heb ingevoerd en op Select heb geklikt, krijg ik het volgende scherm te zien. Het PACITA raamwerk identificeert alle klassen in het JAR bestand en geeft hun volledig gekwalificeerde namen in een lijst weer. De gebruiker kan kiezen om al dan niet enkele van deze klassen te selecteren door de checkbox voor de klassenamen aan te vinken. Het voorbeeld JAR bestand bevat alle klasse definities waarvoor de broncode in getoond wordt en geen andere klasse definities. Blijkbaar heeft elk Data element in het gegeven voorbeeld een Bean inwendige klasse en een anonieme inwendige klasse (die geïdentificeerd wordt door 1). Ik moet raden waar de anonieme inwendige klassen vandaan komen 4, maar ik veronderstel dat het verband houdt met de Bean inwendige klassen. Ik heb de checkboxen zoals in het scherm hierboven geselecteerd en op Load Selected geklikt. Dit brengt ons terug naar de pagina waar we een bron URI kunnen ingeven waarvan we andere elementen kunnen laden. Een schermafbeelding word hieronder getoond. 4 Ik weet niet hoe de Java compiler werkt. Ik weet enkel hoe Java code te schrijven en hoe het te compileren en draaien. Ik veronderstel dat er een reden is waarom de Java compiler de anonieme klassen aanmaakt, maar naar de reden kan ik enkel maar raden. 55

67 De pagina toont bovenaan de opmerking dat 10 elementen in de container ingeladen werden en dat 2 klassen die geen elementen waren werden overgeslagen. De geselecteerde klassen die geen elementen waren waren basic.data.error$bean en basic.data.error$1. Deze zijn inwendige klassen van het basic.data.error Data element, maar zijn geen elementen op zichzelf en dus worden ze overgeslagen. Alle andere geselecteerde klassen zijn elementen omdat ze een van de interfaces gespecifiëerd in implementeren. Een nieuw object wordt aangemaakt voor al deze klassen door de no argument constructor aan te roepen en dit object wordt opgeslagen in de container. We willen geen andere elementen aan de container toevoegen en daarom klikken we nu op Back. Dit brengt ons terug naar de pagina die de elementen in de container toont, zoals hieronder getoond. 56

68 De container was voordien leeg en er werden geen elementen in de container getoond. Nu we elementen in de container geladen hebben, krijgen we een lijst te zien die de volledig gekwalificeerde naam van de klasse van de elementen toont, de datum waarop ze toegevoegd werden, de URI die de klasse definitie van het element bevat en hoeveel keer een element methode is aangeroepen door het PACITA raamwerk. De element methoden zijn de methoden van de interfaces die gedefiniëerd zijn in Aangezien de elementen vers in de container geladen zijn, is hun functionaliteit nog niet aangeroepen en daarom staat het aantal aanroepingen nog steeds op 0 voor alle elementen. We moeten geen veranderingen meer maken in de container en dus klikken we op Go Back to Container List. Dit brengt ons terug naar de start pagina die de lijst van containers toont zoals hieronder getoond. 57

69 We klikken eerst op Save. Dit slaat de veranderingen die we in de configuratie gemaakt hebben op. Veranderingen worden niet automatisch opgeslagen omdat meerdere personen de configuratie op hetzelfde moment kunnen aanpassen. Als aanpassingen automatisch opgeslagen werden, zouden veranderingen van verschillende bronnen met elkaar interfereren. In plaats hiervan worden veranderingen in de configuratie niet automatisch in het PACITA raamwerk opgeslagen. Ze worden enkel lokaal in de sessie bewaard. Enkel wanneer een gebruiker expliciet kiest om zijn configuratie op te slaan, wordt het geschreven naar het PACITA raamwerk. Het is nog altijd mogelijk dat een gebruiker de configuratie van een andere gebruiker in het raamwerk overschrijft. Echter, de lokale configuratie waarmee een gebruiker werkt wordt niet beïnvloed door veranderingen gemaakt door andere gebruikers. Een gebruiker kan op elk ogenblik de configuratie die in het raamwerk opgeslagen is laden door op Refresh te klikken. 5 Nadat we op Save hebben geklikt, selecteren we de calculator functionality container door de checkbox voor de naam aan te vinken en dan klikken we op Back Up. Dit brengt ons naar het volgende scherm. 5 Ik weet het, concurrency control in veranderingen aan de configuratie van het PACITA raamwerk kan nog altijd verbeterd worden, maar een betere oplossing uitwerken zou extra tijd vereisen. Dit is een zaak waaraan gewerkt kan worden wanneer het raamwerk evolueert. 58

70 Vanaf deze pagina kunnen we de inhoud van de containers die we op de vorige pagina selecteerden exporteren naar een bestand. We kunnen ook de inhoud van containers die we eerder in een bestand opsloegen laden. Op dit moment zullen we de inhoud van de calculator functionality container opslaan. We vullen calculator.ser in het New storage file tekstveld in en klikken op de gele zon naast het tekstveld. Dit slaat de inhoud van de calculator functionality container op in het bestand calculator.ser en brengt ons terug naar de start pagina zoals hieronder getoond. De schermafbeelding hierboven toont ook de naam van reeds bestaande backup bestanden. Wanneer we naar de start pagina terugkeren, zien we de opmerking dat het calculator.ser bestand aangemaakt werd en dat de inhoud van de calculator functionality container erin opgeslagen werd. Dit was al het nodige om de element containers te configureren Element register Als we op de Element Registry tab klikken en dan op de start flag, zien we de pagina om element registers te configureren, zoals hieronder. Deze pagina toont de namen van de element registers. We maken een nieuw leeg element register aan met de naam calculator linking. We vullen de naam in het tekstveld in, klikken op de gele zon en klikken vervolgens op het groene aanvinkteken voor de naam. We krijgen de volgende pagina te zien die de verwijzingen naar elementen in het element register toont. 59

71 Omdat het element register op dit ogenblik leeg is, bevat het nog geen verwijzingen naar elementen. We maken verwijzingen naar elementen aan door hun naam in te geven in het tekstveld en op de gele zon naast het tekstveld te klikken. Op deze manier maken we de verwijzingen naar de elementen zoals getoond in de schermafbeelding hieronder aan Wanneer nieuwe verwijzingen naar elementen aangemaakt worden, verwijzen ze nog niet naar een container of een element, zoals in het scherm hierboven getoond. Nadat de verwijzingen aangemaakt zijn, selecteren we de add action verwijzing door op het groene aanvinkteken voor de naam te klikken. Dit brengt ons naar de volgende pagina. We zien de element containers in het PACITA raamwerk. We selecteren de calculator functionality container. Dit brengt ons naar de volgende pagina. 60

72 De bovenstaande pagina toont de elementen in de geselecteerde container. We selecteren het basic.actions.add element. Dit brengt ons terug naar de pagina die het overzicht geeft van de verwijzingen naar element in het geselecteerde element register, zoals hieronder getoond. De add action verwijzing verwijst nu naar het basic.actions.action element in de calculator functionality container. Dit element is een Action element, maar geen Condition element of geen Data element, zoals getoond wordt in de is action, is condition en is data kolommen 6. We verwijzen ook de andere verwijzingen naar hun overeenkomstige elementen in de calculator functionality container en bekomen het resultaat dat op de volgend schermafbeelding getoond wordt. 6 Men kan opmerken dat er geen kolom is voor UserAccounts elementen. UserAccounts elementen leveren geen functionaliteit die in de gebruikersinterface ingebed wordt zoals de andere types van elementen. Hierdoor worden UserAccounts elementen niet getoond in de Element Registry stap. In plaats hiervan kunnen UserAccounts elementen geselecteerd worden in de User Management stap om gebruikersgroepen aan te maken van een gebruikersaccount lijst. Deze gebruikersgroepen kunnen gebruikt worden om de toegang tot elementen en componenten te beperken in de User Management stap. 61

73 Nu dat naar alle elementen verwezen wordt, klikken we op Go Back to Registry List. Dit brengt ons terug naar de start pagina zoals in de volgende schermafbeelding getoond. We slaan de configuratie op door op Save te klikken. We selecteren het calculator linking register en klikken op Back Up. Dit brengt ons naar de volgende pagina. We slaan de inhoud van het calculator linking register op in het calculator.xml bestand. Nadat we het bestand opgeslagen hebben, worden we teruggebracht naar de start pagina en wordt er een opmerking getoond over de opslag naar het XML bestand zoal hieronder. 62

74 Dit is al het nodige om element registers te configureren Component register Als we op de Component Registry tab klikken en dan de start vlag selecteren, zien we de pagina om component registers te configureren, zoals hieronder. We maken het calculator components register aan. Bij de aanmaak is een component register leeg en niet verbonden met een element register. We klikken op select element registry naast calculator components om het component register te verbinden met een element register. We krijgen de volgende pagina te zien. De pagina hierboven toont de namen van de element registers in het PACITA raamwerk. We selecteren calculator linking. Dit brengt ons terug naar de start pagina zoals hieronder getoond. We klikken op Save. Het calculator components component register is nu verbonden met het calculator linking element register. 63

75 We selecteren het calculator components register door op het groene aanvinkteken voor de naam te klikken. We krijgen de pagina hieronder te zien die de componenten in het component register toont. Omdat het component register nog leeg is, worden er nog geen componenten getoond. We maken de componenten voor de web applicatie aan door hun naam in het tekstveld in te voeren en op de gepaste create link naast het tekstveld te klikken. Dit maakt niet-geïnitialiseerde componenten aan. We zien het resultaat hieronder. We selecteren de add actie component. We krijgen de volgende pagina te zien. 64

76 De add actie component is nog niet verbonden met een actie of een volgende component. We selecteren het groene aanvinkteken naast no embedded action en krijgen de lijst van Action elementen in het element register waarmee het component register verbonden is te zien: We selecteren add action. Het add action element is nu in de add action component ingebed, zoals men hieronder kan zien. We selecteren nu het groen aanvinkteken naast no next component en krijgen de lijst van componenten in het component register te zien: 65

77 We selecteren calculator als de volgende component. Dit resulteert in het volgende: Als het PACITA raamwerk de add actie component behandelt, zal het eerst het add action element uitvoeren en nadien de controle doorsturen naar de calculator pagina component. De add actie component is geconfigureerd, dus we klikken op Go Back to Component List. Dit toont ons opnieuw de lijst van componenten in het component register: We configureren de andere actie componenten op dezelfde manier zoals we de add actie component geconfigureerd hebben. Vervolgens selecteren we de is add conditie component. We krijgen de pagina hieronder te zien. 66

78 De is add conditie component is nog niet verbonden aan een conditie element of aan volgende componenten. We selecteren het groene aanvinkteken naast no embedded condition. We krijgen de lijst van Condition elementen in het element register waarmee het component register verbonden is te zien: We selecteren is add condition. Het is add condition element is nu ingebed in de is add conditie component, zoals hieronder gezien kan worden. In de pagina hieronder zijn de volgende componenten voor de is add conditie component ook reeds ingesteld. Ze worden op dezelfde manier ingesteld als een volgende component voor een actie component ingesteld wordt. 67

79 Als het PACITA raamwerk de is add conditie component behandelt, zal het eerst het is add condition element testen. Als de test faalt, wordt de controle doorgestuurd naar de is subtract conditie component, als de test slaagt, wordt de controle doorgestuurd naar de add actie component. De is add conditie component is geconfigureerd, dus we klikken op Go Back to Component List. Dit toont ons opnieuw de lijst van componenten in het component register: We configureren de andere conditie componenten op dezelfde manier als we de is add actie component geconfigureerd hebben. Vervolgens selecteren we de calculator pagina component. We krijgen de volgende pagina te zien. De pagina component is niet verbonden met een feitelijke webpagina en er zijn geen beans of triggers gedefiniëerd voor de pagina. We klikken op het groene aanvinkteken naast no page linked. Dit brengt ons naar de volgende schermafbeelding. 68

80 We vullen de URI van de pagina waarmee de pagina component verbonden moet worden in in het tekstveld in de bovenstaande schermafbeelding. Als de URI met een / begint zal de pagina van de lokale server geïncludeerd worden. Anders zal de pagina van over het internet geïncludeerd worden. We klikken op Select om de string waarde voor de URI op te slaan. Dit brengt ons terug naar de configuratie pagina voor de pagina component: We voegen beans en triggers aan de pagina toe door hun naam in het tekstveld in te vullen en op de gepaste create link naast het tekstveld te klikken. Dit resulteert in het volgende: 69

81 De beans en triggers verwijzen aanvankelijk naar niets. Merk op dat ik een underscore gebruikte in de bean namen in plaats van een spatie. De <jsp:getproperty/> JSP actie kan niet met spaties in de naam van een bean omgaan. We klikken op het groene aanvinkteken naast error_bean en krijgen de lijst van Data elementen in het element register waarmee het component register verbonden is te zien: We selecteren error data. Het error data element is nu in de calculator pagina ingebed als de error_bean bean zoals op de volgende schermafbeelding kan gezien worden: 70

82 We verbinden de andere beans met de pagina op dezelfde manier: De /calculator/basic.jsp pagina zal de beans geretourneerd door de getdatabean methode van de Data elementen kunnen aanspreken. De pagina kan een dergelijke bean aanspreken via de bean naam die naar zijn Data element verwijst. Nadat we de beans van de pagina component verbonden hebben, klikken we op het groene aanvinkteken naast calculate. Dit toont ons de lijst van componenten in het component register: 71

83 We selecteren input is number. Dit verbindt de calculate trigger met de input is number conditie component. Dus als de calculate trigger geactiveerd wordt op de /calculator/basic.jsp pagina, zal de controle doorgestuurd worden naar de input is number conditie component. De uiteindelijke configuratie van de calculator pagina component wordt op de volgende schermafbeelding getoond. We klikken op Go Back to Component List en krijgen het volgende te zien: 72

84 We klikken op Go Back to Registry List en krijgen het volgende te zien: We klikken op Save. We selecteren het calculator components register en klikken op Back Up. Dit toont ons de pagina waarvan we de inhoud in het calculator components register kunnen exporteren naar een XML bestand: We slaan de inhoud van het calculator components register op in het calculator.xml bestand. Nadat de inhoud is opgeslagen keren we terug naar de start pagina en zien de opmerking dat de inhoud was opgeslagen: 73

85 Dit is al het nodige om component registers te configureren Configuratie van de applicatie Als men op de Application tab van de GUI klikt en dan klikt men op de start vlag, dan krijgt men een scherm zoals hieronder te zien. Zoals in de vorige stappen maken we een nieuw leeg register aan door de naam in het tekstveld van de start pagina in te vullen en op de gele zon naast het tekstveld te klikken. Hier hebben we het calculator application register aangemaakt. Na de aanmaak kregen we de pagina hierboven te zien. Vervolgens klikken we op select component registry, naast calculator application. We krijgen de lijst van component registers in het PACITA raamwerk te zien, zoals hieronder. We selecteren calculator components. Het calculator application register is nu verbonden met het calculator components register. 74

86 We klikken op select standard component naast calculator application. We krijgen de lijst van componenten in het component register waarmee het applicatie register verbonden is te zien: We selecteren de calculator pagina component als standaard component. We keren terug naar de start pagina zoals hieronder: We klikken op Save. We selecteren calculator application en klikken op Back Up. We krijgen de volgende pagina te zien: 75

87 We slaan de inhoud van het calculator application register op in het bestand calculator.xml en keren terug naar de start pagina: De backup die in alle stappen gemaakt werd is niet noodzakelijk om de applicatie te draaien. De backup bestanden maken het echter mogelijk om de hele applicatie inclusief staat naar een andere server te exporteren of om de applicatie naar een vorige staat te herstellen. De web applicatie is nu actief op de server! Als je op het groene aanvinkteken naast calculator application klikt, zal een nieuw browser scherm die de applicatie draait opspringen. Dit wordt in het volgende deelhoofdstuk geïllustreerd. 76

88 5.3. Demonstratie van de eenvoudige rekenmachine De applicatie die hier getoond wordt is eerder eenvoudig in vergelijking met zijn exhaustieve configuratie die hierboven getoond is. Men moet opmerken dat de bovenstaande configuratie tot in de fijnste details is uitgelegd en dat veel ingewikkeldere applicaties geen ingewikkeldere configuratie vereisen. Er bestaat geen scripting taal of volledig functionele webtechnologie waarvan de kracht volledig kan getoond worden in 50 schermafbeeldingen. Ongeveer 50 schermafbeeldingen volstaan om de volledige kern van het PACITA raamwerk uit te leggen, hoe ingewikkeld de web applicatie die het PACITA raamwerk gebruikt ook is. Om naar onze eenvoudig applicatie verder te gaan, die later uitgebreid zal worden: De linker schermafbeelding is wat je te zien krijgt als je de applicatie opstart. Rechts zie je dat de gebruiker de waarde in het tekstveld veranderd heeft in 5. Als de gebruiker op add klikt nadat hij de waarde in het tekstveld in 5 veranderd heeft, krijgt hij de linker schermafbeelding hieronder te zien. Als hij een andere keer op add klikt, krijgt hij de schermafbeelding in het midden hieronder te zien. Als een gebruiker op add klikt, wordt de waarde in het tekstveld onthouden en wordt deze waarde bij het resultaat opgeteld. In de rechter schermafbeelding hieronder verandert de gebruiker de waarde in het tekstveld in een niet numerieke waarde. Als de gebruiker op add klikt wanneer de waarde in het tekstveld geen getal is, wordt een foutmelding getoond aan de gebruiker zoals in de linker schermafbeelding hieronder. De oude invoer waarde wordt hersteld. In de rechter schermafbeelding hieronder verandert de gebruiker de invoer waarde in 3. 77

89 Als de gebruiker nu op subtract klikt, wordt de waarde in het tekstveld afgetrokken van het resultaat zoals getoond in de linker schermafbeelding hieronder. Als de gebruiker op reset klikt, worden het resultaat en de waarde in het tekstveld heringesteld op 0. 78

90 5.4. Herstellen van de rekenmachine Voordat we de rekenmachine uitbreiden, zal ik tonen hoe men een applicatie herstelt van backup bestanden. Eerst gaan we naar de start pagina van een van de stappen zoals hieronder getoond: We klikken vervolgens op Purge, dit verwijdert alle containers van de stap in het PACITA raamwerk en zuivert de databank. We krijgen de volgende pagina te zien. We klikken op Back Up en komen op de volgende pagina: We selecteren het bestand calculator.ser door op het groene aanvinkteken voor de naam te klikken. Dit toont ons de lijst van de containers die in het bestand zijn opgeslagen. Omdat er slechts een container opgeslagen is in het bestand, namelijk de calculator functionality container, krijgen we enkel de naam van deze ene container te zien: 79

91 We selecteren de container en klikken op Load. Dit laadt alle geselecteerde containers in de gebruikerssessie en brengt ons terug naar de pagina waar we containers kunnen opslaan naar bestanden of laden van bestanden. We zien een opmerking dat de geselecteerde containers geladen werden: We klikken op Back en keren terug naar de start pagina. De rekenmachine is nu geladen in de gebruikerssessie: We klikken op Save om de configuratie in de gebruikerssessie in het PACITA raamwerk op te slaan. We doen dit ook voor de 3 andere noodzakelijke stappen en de applicatie is hersteld. Nadat de rekenmachine applicatie hersteld is, testen we haar een aantal keer en selecteren vervolgens de calculator functionality container: 80

92 We zien de lijst van elementen in de container en zien dat elk element een aantal keer is aangeroepen. Van de basic.conditions.inputisnumber lijn, leiden we af dat we 22 keer op add, subtract of reset hebben geklikt. De is reset conditie is 19 keer getest, wat inhoudt dat we (22 19) = 3 keer een niet numerieke waarde in het tekstveld hebben ingevoerd. De reset actie is eenmaal uitgevoerd en dus is de is add conditie (19 1) = 18 keer getest. De add actie is 7 maal uitgevoerd en dus is de is subtract conditie (18 7) = 11 keer getest. De subtract actie is 11 maal uitgevoerd. De calculator pagina is 23 keer getoond en dus zijn de error, result en input data elementen 23 keer aangesproken. Echter, wegens een of andere reden wordt de dubbele hoeveelheid getoond voor het aantal toegangen. Dit betekent dat er ergens een bug is die ofwel de data elementen tweemaal aanroept of die het aantal toegangen met 2 vermenigvuldigt. 81

93 5.5. Uitbreiding van de rekenmachine Terwijl de rekenmachine actief is, zullen we ze uitbreiden met de vermenigvuldiging en de deling. We zullen de start pagina ook met een andere pagina die een ingegeven bericht een aantal keer zal tonen verbinden. Veranderingen aan de grafische gebruikersinterface zullen eruit zien als in Figuur 26. Calculator is subtract subtract calculate to message is multiply multiply is divide divide to message store message to calculator mod 10 Message result modulo parent message child message to calculator Figuur 26: veranderingen aan de grafische gebruikersinterface van de rekenmachine Het Model De uitbreiding vereist de implementatie van 4 Action elementen, 2 Condition elementen en 3 Data elementen. Ik zal de implementatie van de multiply, is multiply, divide en is divide elementen niet tonen omdat hun implementatie gelijkaardig is aan de implementatie van de add en is add elementen. De implementatie van mod 10 en store message: public class Mod10 implements Action { public void execute(httpservletrequest request) { HttpSession session = request.getsession(); int result = (Integer)session.getAttribute("result"); session.setattribute("modulo", result % 10); } } 82

94 public class StoreMessage implements Action { public void execute(httpservletrequest request) { String message = request.getparameter("message"); request.getsession().setattribute("message", message); } } De implementatie van modulo, parent message en child message: public class Modulo implements Data { public static class Bean { private String value; private Bean(String value) { this.value = value; } public String getvalue() { return value; } } public Object getdatabean(httpsession session) { Integer result = (Integer)session.getAttribute("modulo"); if (result == null) { result = 0; } return new Bean(result.toString()); } } public class ParentMessage implements Data { public static class Bean { private String message; private Bean(String message) { this.message = message; } public String getmessage() { return message; } } public Object getdatabean(httpsession session) { return new Bean((String)session.getAttribute("message")); } } 83

95 public class ChildMessage implements Data { public static class Bean { private HttpSession session; private Bean(HttpSession session) { this.session = session; } public String getmessage() { DataSession datasession = DataTag.getDataSession(this); Reference selfreference = datasession.getcurrentreference(); int maxiterations = (Integer)session.getAttribute("modulo"); int iterations = datasession.gettotaliterations(selfreference); if (iterations < maxiterations) { datasession.setrepeat(selfreference, true); } Reference parentreference = datasession.getparentreference(selfreference); if (parentreference == null) { return "#" + iterations + ": No parent to expose!"; } else { Object parentdata = datasession.getdata(parentreference); String parentmessage; try { parentmessage = (String)parentData.getClass().getMethod("getMessage", new Class[] {}).invoke(parentdata, new Object[] {}); } catch (Exception e) { return "#" + iterations + ": Exposing parent: parent has no message"; } return "#" + iterations + ": Exposing parent's message: " + parentmessage; } } } public Object getdatabean(httpsession session) { return new Bean(session); } } De View De uitbreiding vereist het aanmaken van twee paginas, een pagina die de oude calculator pagina vervangt en een nieuwe message pagina. Ik zal de broncode van de nieuwe calculator pagina niet tonen. Echter, ik zal de broncode van de message pagina tonen, omdat het zal aantonen dat de data custom tag genest en geïtereerd kan worden: 84

96 contenttype="text/html"%> pageencoding="utf-8"%> uri="/web-inf/tlds/pacita.tld" prefix="pacita"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" " <html> <head> <meta http-equiv="content-type" content="text/html; charset=utf-8"/> <title>message</title> </head> <body> <pacita:data bean="result_bean"> <b><jsp:getproperty name="result_bean" property="value"/></b> mod 10 = </pacita:data> <pacita:data bean="modulo_bean"> <b><jsp:getproperty name="modulo_bean" property="value"/></b> <br/><br/> </pacita:data> <pacita:data bean="parent_bean"> Parent's Message: <jsp:getproperty name="parent_bean" property="message"/><br/> <pacita:data bean="child_bean"> Child's message: <jsp:getproperty name="child_bean" property="message"/> <br/> </pacita:data> </pacita:data> <br/> <a href="?trigger=to%20calculator">back to calculator</a> </body> </html> De kind bean zal het bericht van de ouder bean ontvangen en het een aantal keer dat gelijk is aan ((het resultaat % 10) + 1) afdrukken. 85

97 De Controller De volgende 5 schermafbeeldingen tonen de configuratie voor de uitgebreide rekenmachine: 86

98 87

99 Demonstratie van de uitgebreide rekenmachine Als we de rekenmachine applicatie opstarten krijgen we het volgende scherm te zien: We voeren 3 in het Input tekstveld in en klikken op add en zien het volgende scherm: Met 3 in het Input tekstveld, klikken we op multiply en zien het volgende: 88

100 We voeren 2 in het Input tekstveld in zoals in de volgende schermafbeelding: Nu klikken we op divide en zien het volgende: We voeren 1000 in het Input tekstveld in, klikken op add en voeren My test message in het Secret Message tekstveld in zoals in de volgende schermafbeelding: We klikken op to message en krijgen de message pagina zoals hieronder te zien. De waarde van (result % 10) wordt berekend en de ingevoerde waarde voor het bericht wordt getoond door een ouder data custom tag. Een kind data custom tag extraheert het bericht van de ouder en toont het (1 + (result % 10)) keer. Als we op Back to calculator klikken, keren we terug naar de calculator pagina zoals hieronder getoond. 89

101 Demonstratie van de uiteindelijke rekenmachine Om de demonstratie af te sluiten, veranderen we de configuratie van de twee pagina componenten zoals in de volgende twee schermafbeeldingen: 90

102 De calculator pagina van de webapplicatie wordt dan in actie veranderd om er uit te zien als: Als we op to message klikken, worden we doorgestuurd naar de externe pagina met URL 91