Visualisatie van een databank met behulp van JPA

Academiejaar 2008-2009 Departement Toegepaste Ingenieurswetenschappen Schoonmeersstraat 52-9000 Gent Visualisatie van een databank met behulp van JPA Masterproef voorgedragen tot het behalen van het diploma van INDUSTRIEEL INGENIEUR INFORMATICA Tim Mallezie Promotoren: Veerle Ongenae Evert De Rammelaere

Inhoudsopgave Lijst van afkortingen 2 I Probleemstelling en doelstellingen 5 1 Inleiding 6 1.1 Persistentie..................................... 6 1.2 Object relational paradigm mismatch....................... 6 1.3 ORM, JPA en Hibernate.............................. 7 2 Doelstellingen 9 2.1 Visualisatie van een relationeel databankmodel................. 9 2.2 Visualisatie van een objectmodel......................... 10 II Gebruikte technologieën 11 3 Maven 12 3.1 Een Maven project aanmaken........................... 12 3.2 Het gebruik van dependencies........................... 14 3.3 Site generatie met Maven............................. 14 4 JPA 16 4.1 Inleiding....................................... 16 4.2 Mapping door annotaties............................. 16 4.3 Configuratie van JPA............................... 22 4.4 Opslaan en opvragen van objecten........................ 23 5 Spring 24 5.1 Dependency injection................................ 24 5.2 JPA en Spring................................... 24 Bibliografie 25 1

Lijst van afkortingen API Application Programming Interface APT Almost Plain Text CRUD Create Read Update Delete EJB Enterprise Java Beans HTML Hypertext Markup Language III Industrieel Ingenieur Informatica JDO Java Data Objects JDK Java Development Kit JPA Java Persistence API JPAQL JPA Query Language JSR Java Specification Request ORM Object/Relational Mapping POM Project Object Model SQL Standard Query Language 2

Lijst van figuren 2.1 Visualisatie van een relationeel databankmodel door DbVisualizer....... 9 3.1 Directory structuur na creatie met behulp van archetype............ 13 4.1 Klassediagram van een objectmodel dat gemapt wordt naar een databankmodel 17 4.2 Een één-op-één relatie in een databankmodel.................. 19 4.3 Een één-op-veel relatie in het databankmodel.................. 20 4.4 Een veel-op-veel relatie............................... 21 3

Lijst van codevoorbeelden 3.1 Maven s Project Object Model........................... 13 3.2 Configuratiebestand van de website........................ 15 4.1 Mapping van een klasse.............................. 17 4.2 Annotaties op attributen.............................. 18 4.3 Annotaties op een één-op-één relatie....................... 19 4.4 Annotaties op een één-op-veel relatie....................... 19 4.5 Annotaties op een één-op-veel relatie....................... 20 4.6 Mapping van een klasse.............................. 21 4.7 Annotaties op een superklasse........................... 22 4.8 Voorbeeld van persistence.xml configuratiebestand............... 22 4

Deel I Probleemstelling en doelstellingen 5

Hoofdstuk 1 Inleiding 1.1 Persistentie Een applicatie die data gebruikt en bewerkt, moet in staat zijn deze op te slaan, als het programma wordt afgesloten. Hierbij wordt de data meestal bewaard in een relationele databank. De databank is verantwoordelijk voor het behoud van de data, onafhankelijk van de applicatie. De applicatie moet er voor zorgen, dat wijzigingen aan de data, doorgegeven worden aan de databank. De data gebruikt in de applicatie moet persistent zijn met die in de databank. Persistentie zorgt ervoor dat een object onafhankelijk, van zijn gebruikte context, bewaard kan worden. Het omgekeerde begrip wordt transistentie 1 genoemd, dit zijn objecten met een levensduur die beperkt blijft tot het gebruik in de applicatie. 1.2 Object relational paradigm mismatch Een vaak voorkomend probleem bij het gebruik van een databank, ontstaat bij het aanmaken en wijzigen van de gebruikte objecten in de applicatie, en de overeenkomstige tabellen in de databank. Een (relationele) databank maakt gebruik van een relationeel datamodel, met tabellen, één-op-één relaties, één-op-veel en veel-op-veel relaties tussen deze tabellen. Samen met het gebruik van primaire en secundaire sleutels modelleert een relationeel databankmodel op deze manier een werkelijke situatie. In een applicatie echter maakt men gebruik van een objectmodel om de werkelijkheid te modelleren. Hierbij gebruikt men objecten en klassen, en verschillende mogelijke relaties tussen deze. Daarbij heeft men de keuze tussen het gebruik van attributen die een heeft-een relatie kunnen voorstellen, of kan men overerving en interfaces gebruiken om is-een relaties te modelleren. 1 Een vernederlandsing van het Engelse begrip transient. 6

Hoofdstuk 1. Inleiding 7 Deze tegenstrijdigheid wordt de object-relational paradigm mismatch genoemd. Een wijd aanvaarde oplossing voor persistentie en de object-relational paradigm mismatch is een oplossing genaamd Object/Relational Mapping (ORM). ORM is een geautomatiseerd en transparante techniek die de relatie tussen objecten en tabellen in een relationele databank vastlegt. Metadata 2 wordt gebruikt om deze mapping te beschrijven. 1.3 ORM, JPA en Hibernate 1.3.1 ORM Een ORM oplossing bestaat uit vier delen. Een API voor Create Read Update Delete (CRUD) operaties. Een taal of API om queries te definiëren. Een techniek om de metadata vast te leggen, die nodig is voor de mapping. Een techniek die transactionele objecten behandelt. 1.3.2 Java Persistence API (JPA) In 2003 werd door Sun 3 een Java Specification Request (JSR) opgestart met de naam Enterprise Java Beans (EJB) 3.0. Deze specificatie bestaat uit twee delen. Het eerste deel definieert een nieuw model voor het gebruik van Java Beans 4. Het tweede deel behandelt persistentie. Dit deel wordt JPA genoemd, waarschijnlijk omdat de interfaces zich in de package javax.persistence.* bevinden. De JPA is een specificatie die een verzameling interfaces definieert. Deze interfaces bepalen hoe persistentie in Java moet geïmplementeerd worden. 1.3.3 Hibernate Hibernate is een implementatie 5 van de JPA standaard. De JPA specificatie definieert de ORM metadata syntax door gebruik te maken van JDK 5.0 annotaties. Deze annotaties bepalen de relatie tussen de gegevens in een object, en de bijhorende databanktabellen waar deze gegevens moeten opslaan. De JPA specificatie voorziet niet alleen in annotaties om de 2 Aanvullende data die aan een klasse wordt meegegeven. 3 Sun Microsystems Inc. werd opgericht in 1982 en creëerde het Java platform rond 1990 4 Herbruikbare Java componenten. 5 Hibernate biedt ook extra mogelijkheden aan buiten de JPA standaard, maar in deze masterproef wordt enkel de JPA standaard en Hibernate zijn implementatie behandelt.

Hoofdstuk 1. Inleiding 8 gegevens op te slaan, maar ook in verschillende annotaties om de relaties tussen objecten en zaken zoals overerving en polymorfisme te modelleren naar een relationeel databankmodel. De JPA specificatie bepaalt ook interfaces, regels voor de levensduur van persistente objecten, en query toepassingen. De Hibernate implementatie voor dit deel van de JPA specificatie is de Hibernate EntityManager. Deze zet verbindingen op met de databank, en laat toe om opzoekingen en wijzigingen uit te voeren in de databank. 1.3.4 Persistente objecten aanmaken, opzoeken en wijzigen De JPA specificatie laat ons toe om via annotaties, de juiste relaties te bepalen tussen de gegevens in de objecten en de tabellen van de relationele databank. De Hibernate EntityManager bevat verschillende functies om deze objecten op te zoeken, en zorgt ervoor dat wijzigingen aan deze objecten automatisch aan de databank worden doorgegeven. Via de Hibernate EntityManager voeren we bewerkingen uit op objecten. Er wordt op zoek gegaan naar objecten, die onderliggend als data in databank staan. Er worden wijzigingen uitgevoerd op attributen van objecten, en deze worden automatisch doorgegeven aan de juiste tabellen in de databank. De Hibernate EntityManager laat toe om objecten op te vragen en te wijzigen zonder kennis van het onderliggende relationele databankmodel. 1.3.5 JPAQL JPA Query Language (JPAQL) is een taal die toelaat om specifieke objecten op te zoeken. De JPA specificatie met zijn Hibernate implementatie zet deze opvragingen om in Standard Query Language (SQL) die uitgevoerd wordt op de onderliggende databank. SQL is een query taal die toelaat om gegevens uit verschillende tabellen op te vragen in de databank, op deze manier kan JPAQL beschouwd worden als een query taal om verschillende objecten uit het objectmodel op te vragen.

Hoofdstuk 2 Doelstellingen 2.1 Visualisatie van een relationeel databankmodel Toepassingen zoals DbVisualizer laten toe om een visualisatie te geven van een databankmodel, en de data opgeslagen in een databank. Deze toepassingen geven een weergave van de verschillende tabellen in de databank, en de onderlinge relaties tussen de verschillende tabellen. Ook de data die in de verschillende tabellen opgeslagen wordt kan op een eenvoudige manier visueel worden weergegeven. Figuur 2.1: Visualisatie van een relationeel databankmodel door DbVisualizer Deze toepassingen kunnen eenvoudig gebruikt worden om SQL commando s uit te testen. Ook bij het aanmaken van een databankmodel kan een visualisatie een grote hulp zijn. Tijdens het aanmaken van het model kan stapsgewijs nagekeken worden of de relaties tussen de tabellen correct zijn. 9

Hoofdstuk 2. Doelstellingen 10 2.2 Visualisatie van een objectmodel Het doel van deze masterproef is een applicatie te ontwikkelen die ons toelaat een objectmodel te visualiseren. Deze applicatie geeft informatie en relaties tussen verschillende klassen weer. Ook is er de mogelijkheid om door middel van JPAQL commando s objecten op te vragen, en deze visueel terug te. De ontwikkelde applicatie vertrekt vanuit een aangeleverd objectmodel, en geeft daaruit een visueel beeld van het objectmodel. Hierbij krijgt de gebruiker een beeld van de klasseinformatie, de attributen en methoden van de aangeleverde klassen. Ook de informatie van de gebruikte JPA annotaties wordt weergegeven. Deze applicatie levert de mogelijkheid om via een JPAQL commander, queries uit te voeren en de opgevraagde objecten weer te geven. Dit maakt de applicatie geschikt om JPAQL commando s uit te testen, alvorens ze in een applicatie te gebruiken. Het doel van de ontwikkelde applicatie is een hulp te zijn voor Java ontwikkelaars die met een aangeleverd objectmodel een applicatie dienen te ontwerpen. Het aangeleverde objectmodel kan bekeken worden en doorzocht worden op het niveau van de objecten. De ontwikkelaar dient op deze manier niet op de hoogte te zijn van de manier waarop de persistente objecten gelinkt zijn naar de databank. De applicatie ontwikkeld in deze masterproef kan ook gebruikt worden om te controleren of een objectmodel op een juiste manier aangevuld is met JPA annotaties. Net zoals men bij programma s als DbVisualizer kan kijken of de relaties tussen de verschillende tabellen correct zijn, kan men bij deze applicatie nakijken of relaties tussen objecten juist geïmplementeerd zijn, en of de onderliggende databank relaties gevolgd worden, bij het opvragen van objecten.

Deel II Gebruikte technologieën 11

Hoofdstuk 3 Maven Maven is een projectmanagement framework, dat ondersteuning biedt bij het ontwikkelen van grote projecten. Het is een ontwikkel-tool die hulpmiddelen biedt voor het beheer van een project. In deze masterproef worden vooral de mogelijkheden om het compileren, deployen en testen van de applicatie te vereenvoudigen gebruikt. Ook de mogelijkheden voor een eenvoudiger beheer van gebruikte externe libraries worden veelvuldig gebruikt, en zullen dan ook besproken worden. Verder biedt Maven ook een structuur aan onze applicatie die ons op een eenvoudige manier toelaat testcode, applicatiecode en gegenereerde class-files te scheiden van elkaar. Als laatste wordt gebruik gemaakt van de mogelijkheid om Maven een site 1 te laten genereren over dit project. Deze site werd de uiteindelijke website voor deze masterproef. 3.1 Een Maven project aanmaken In deze paragraaf wordt kort overlopen hoe een eerste Maven project aangemaakt wordt, van hieruit wordt verder besproken hoe bepaalde Maven functionaliteiten gebruikt werden in deze masterproef. Om een Maven project aan te maken, wordt het ingebouwde archetype mechanisme gebruikt. An archetype is defined as an original pattern or model from which all other things of the same kind are made. (Mav, 2009) Volgend commando levert ons een nieuw project op: mvn archetype:create -DgroupId="be.hogent.iii" -DartifactId="projectnaam" Hier wordt een nieuw project volgens de standaard gebruikte mapstructuur gecreëerd. Deze structuur wordt weergegeven in figuur 3.1. 1 http://webs.hogent.be/~040978tm/thesis 12

Hoofdstuk 3. Maven 13 Figuur 3.1: Directory structuur na creatie met behulp van archetype De directorystructuur toont de map src die de bronbestanden van ons project bevat. Deze bevat een map main\java voor de broncode van de applicatie, onderverdeeld in verschillende packages. Verder is ook de map main\resources voor configuratiebestanden aanwezig. De map test bevat de bronbestanden voor de gebruikte JUnit testklassen. In de mapsite komen de verschillende bron- en configuratiebestanden voor de website te staan. In de target map komen de gegenereerde bestanden terecht, hier zijn verschillende mappen voor de sitebestanden, de gegenereerde testresultaten en de gecompileerde class bestanden. Het hart van de configuratie van het gecreëerde Maven project bevind zich in het pom.xml bestand dat aangemaakt wordt. Dit bevat alle configuratiegegevens voor een project. <p r o j e c t> <modelversion>4. 0. 0</ modelversion> <groupid>be. hogent. i i i</ groupid> <a r t i f a c t I d>projectnaam</ a r t i f a c t I d> <packaging>j a r</ packaging> <version>1.0 SNAPSHOT</ version> <name>maven Quick S t a r t Archetype</name> <u r l>h t t p : //maven. apache. org</ u r l> <dependencies> <dependency> <groupid>j u n i t</ groupid> <a r t i f a c t I d>j u n i t</ a r t i f a c t I d> <version>3. 8. 1</ version> <scope>t e s t</ scope>

Hoofdstuk 3. Maven 14 </ dependency> </ dependencies> </ p r o j e c t> Code 3.1: Maven s Project Object Model. Dit Project Object Model (POM) bevat alle belangrijke informatie van het project. De meeste elementen hierin zijn zeer eenvoudig en geven beschrijvende informatie over het project. In de volgende paragraaf wordt dieper ingegaan op het dependencies element. 3.2 Het gebruik van dependencies Bij de installatie en het eerste gebruik van Maven, zal Maven een lokale repository opstellen, en daar verschillende libraries in opslaan, afhankelijk van de dependencies in het POM. In dit voorbeeld zal Maven in de standaard centrale Maven repository op zoek gaan naar de nodige bestanden om de JUnit afhankelijkheid te gebruiken. Deze zal hij dan downloaden naar de lokale repository alwaar hij de nodige jarbestanden zal bewaren. Op die manier gebruikt Maven voor elk project dezelfde lokale repository en zal niet voor elk afzonderlijk project de nodige externe bestanden opnieuw worden opgehaald. Het voordeel bij deze aanpak is dat de gebruikte dependencies enkel moeten weergegeven worden in pom.xml, zoals in codevoorbeeld 3.1. Maven zorgt ervoor dat de niet aanwezige dependencies gedownload worden naar de lokale repository. 3.3 Site generatie met Maven Maven beschikt ook over een eenvoudig systeem om een website over het project aan te maken. dit wordt veel gebruikt bij open source toepassingen om een projectwebsite 2 aan te maken. Om een site aan te maken gebruikt Maven verschillende bronnen om de informatie op te halen. Enerzijds wordt gebruik gemaakt van het pom.xml bestand om projectinformatie op te halen. Maven heeft verschillende tags die informatie meegeven aan het project. In het pom.xml bestand kan een naam, beschrijving, een lijst van programmeurs, de website,... meegegeven worden. Ook kunnen verschillende plugins gedefinieerd worden die gebruikt kunnen worden om testrapporten en Java documentatie te genereren. Het belangrijkste bestand bevindt zich in de map src/site en heeft als naam site.xml. Hierin wordt de structuur van onze site bepaald, indien men niet voldoende heeft aan de standaard website. De configuratie van dit bestand bepaalt de structuur van de website. 2 Bvb.: http://maven.apache.org

Hoofdstuk 3. Maven 15 <p r o j e c t name= Caribou V i s u a l i s a t i o n > <publishdate p o s i t i o n= r i g h t /> <body> <menu name= C a r i b o u V i s u a l i s a t i o n > <item name= Home h r e f= / index. html /> <item name= What i s C a r i b o u V i s u a l i s a t i o n h r e f= / p r o j e c t summary. html /> <item name= Wie? h r e f= /team l i s t. html /> <item name= Downloads h r e f= /download. html /> <item name= Logboek h r e f= / logboek. html /> <item name= L i c e n s e h r e f= / l i c e n s e. html /> </menu> </ body> </ p r o j e c t> Code 3.2: Configuratiebestand van de website In dit bestand worden de gebruikt pagina s gelinkt, aan een inhoudsopgave die we in onze site gebruiken. Hierbij worden enerzijds automatisch gecreëerde pagina s aangemaakt, alsook zelf gemaakte pagina s. Eigen pagina s kunnen op verschillende manieren aangemaakt worden. Externe pagina s of bestanden kunnen rechtstreeks in de website gelinkt worden. Deze externe resources dienen daarvoor in de map /src/site/resources geplaatst te worden. Een tweede mogelijkheid is om zelf pagina s aan te maken in Maven s eigen Almost Plain Text (APT) formaat. Dit is een wiki-achtige markup-taal die door Maven kan omgezet worden naar Hypertext Markup Language (HTML)-pagina s. Deze pagina s worden door Maven in de website ingevoegd.

Hoofdstuk 4 JPA 4.1 Inleiding In paragraaf 1.3 werd aangehaald dat de Java Persistence API (JPA) specificatie met Hibernate als implementatie een Object/Relational Mapping (ORM) oplossing biedt om met persistente objecten om te gaan. Het gebruik van JPA in een applicatie bestaat uit drie stappen: Het objectmodel aanmaken en de mapping bepalen door de nodige annotaties aan te brengen. Een configuratiebestand maken, met instellingen over de gebruikte databank en eigenschappen om met deze verbindingen op te zetten. Het gebruik van de Hibernate EntityManager om objecten aan te maken, te wijzigen en op te zoeken. 4.2 Mapping door annotaties Met JPA-annotaties wordt de relatie tussen het objectmodel en de relationele databank aangeduid. In deze paragraaf wordt dieper ingegaan op de verschillende annotaties. Als een objectmodel gemapt dient te worden naar een databankmodel kunnen vier onderdelen onderscheiden worden. 1. Een klasse mappen naar één of meerdere tabellen. 2. De attributen naar de verschillende kolommen linken. 3. Relaties tussen objecten omzetten naar relaties gebruikt in een databankmodel. 16

Hoofdstuk 4. JPA 17 4. Overerving en polymorfisme mappen naar een databankmodel. Hierbij wordt vertrokken van een top-down benadering. Er wordt vertrokken vanuit een bestaand objectmodel dat gelinkt dient te worden aan een databank, waarbij er weinig of geen vereisten zijn voor de onderliggende databank. Deze methode laat de vrijheid om de verschillende annotaties te verklaren. Uiteraard kunnen ook andere benaderingen gebruikt worden 1. Een bottom-up benadering vertrekt vanuit een opgelegde databankmodel waarna men dan de annotaties invult, zodat de objecten dan volgens dit schema gemapt worden naar de databank. In dit hoofdstuk wordt dieper ingegaan op het gebruik van JPA aan de hand van voorbeeld 4.1. Dit objectmodel wordt gemapt naar een databankmodel. Figuur 4.1: Klassediagram van een objectmodel dat gemapt wordt naar een databankmodel 4.2.1 Annotaties op klassen Klassen waarvan de objecten gemapt moeten worden naar de databank, moeten aangeduid worden als een entiteit. JPA maakt voor deze aanduiding gebruik van annotaties, een toevoeging in Java 5.0. Om een klasse aan te duiden als entiteit dient men deze aan te duiden met de @Entity annotatie. Verder kan onder meer de naam van de databanktabel gespecificeerd worden met de annotatie @Table. @Entity @Table ( name = PERSOON ) public class Persoon { } Code 4.1: Mapping van een klasse 1 De databank kan dan ook automatisch gegenereerd worden met de hbm2ddl tool.

Hoofdstuk 4. JPA 18 Een klasse kan ook beschouwd worden als onderdeel van een andere klasse. Daarvoor kan de @Embeddable annotatie gebruikt worden. 4.2.2 Annotaties op velden en/of attributen Om alle informatie van een klasse te bewaren, dienen ook de attributen van een klasse in de databank opgeslagen te worden. Eenvoudige attributen van standaard Java Development Kit (JDK) types, worden automatisch omgezet naar het overeenkomstige databanktype. Hiervoor is het voldoende om de attributen aan te duiden met een @Column annotatie. Binnen een databank dient elke tabel voorzien te zijn van een primaire sleutel. Daarom dient minstens één attribuut aangeduid te worden als primaire sleutel van de tabel. Deze kan automatisch worden ingevuld met de juiste annotaties, ook kunnen andere attributen aangeduid worden als secundaire sleutels. @Id @GeneratedValue ( s t r a t e g y = GenerationType.AUTO) @Column( name = PERSOON ID ) private long i d ; @Column( name = PERSOON NAAM ) private S t r i n g naam ; Code 4.2: Annotaties op attributen Deze annotaties kunnen rechtstreeks op de attributen aangebracht maken, of op de methoden die toegang geven tot de waarden, de zogenaamde getter-methoden. Afhankelijk waar de annotaties zich bevinden, vragen de onderliggende JPA-klassen hun waarden rechtstreeks aan de attributen, of vragen ze de waarde op via de geannoteerde methoden. 4.2.3 Relaties tussen klassen De mapping van een klasse en zijn attributen naar de juiste kolommen in de databank is voor de meeste objectmodellen niet voldoende. Binnen verschillende klassen bestaan afhankelijkheden naar andere klassen. Een klasse kan een heeft-een relatie hebben met een andere klasse, of een lijst van objecten van een andere klassen bevatten. Deze relaties moeten we omzetten, naar de bestaande relaties in een databank. Een databank kan één-op-één, veel-op-één, of veel-op-veel relaties bevatten. Verder moet er gespecificeerd worden of deze relaties, uni- of bidirectioneel dienen te zijn.

Hoofdstuk 4. JPA 19 Een één-op-één relatie In het voorgaande voorbeeld is te zien dat de klasse Persoon een relatie met zichzelf heeft. Dit dient omgezet te worden naar een één-op-één relatie in de databank. In een databankmodel wordt dit geïmplementeerd door een kolom toe te voegen die een verwijzing bevat naar de primaire sleutel van de Persoon die de echtgenoot voorstelt. Dit is ook duidelijk te zien in de manier waarop de annotaties dienen ingevuld te worden. @Entity @Table ( name = PERSOON ) public class Persoon { @OneToOne( cascade = CascadeType.ALL) @JoinColumn ( name = ECHTGENOOT ID ) private Persoon echtgenoot ; } Code 4.3: Annotaties op een één-op-één relatie Er wordt een @OneToOne annotatie gebruikt om de relatie aan te duiden. De @JoinColumn annotatie duidt de naam van de kolom aan die daarvoor gebruikt wordt. Dit geeft een databankmodel zoals te zien in figuur 4.2. Figuur 4.2: Een één-op-één relatie in een databankmodel Een één-op-veel relatie Een object van de klasse Persoon kan een inwoner zijn van een object van de klasse Huis. Een Huis kan echter meerdere inwoners hebben. Dit is te zien in het klassediagram op figuur 4.1, waar een Huis een collectie van inwoners bevat. Om dit in een databankmodel weer te geven, wordt aan een Persoon-tabel een kolom toegevoegd die de primaire sleutel van een Huis bevat. @Entity @Table ( name = PERSOON ) public class Persoon {

Hoofdstuk 4. JPA 20 } @ManyToOne( f e t c h = FetchType.EAGER) @JoinColumn ( name= PERSOON HUIS ID, referencedcolumnname= HUIS ID ) private Huis h u i s ; Code 4.4: Annotaties op een één-op-veel relatie Er wordt een @ManyToOne annotatie gebruikt om de relatie aan te duiden. De @JoinColumn annotatie duidt de naam van de kolom aan die daarvoor gebruikt wordt. Dit geeft een databankmodel zoals te zien in figuur 4.3. We duiden het type aan van de relatie die we willen definiëren, in dit geval dus een @Many- ToOne relatie. En aan de @JoinColumn annotatie worden de kolommen meegegeven die de data van de relatie moet bevatten. Aan de andere kant van de relatie dient enkel aangeduid te worden dat de relatie bestaat en door welk attribuut ze gespecificeerd wordt. @Entity @Table ( name = HUIS ) public class Huis { @OneToMany(mappedBy = h u i s ) private C o l l e c t i o n <Persoon> bewoners = new ArrayList<Persoon >();} Code 4.5: Annotaties op een één-op-veel relatie Op deze manier wordt een databankmodel bekomen zoals in figuur 4.3. Figuur 4.3: Een één-op-veel relatie in het databankmodel Een veel-op-veel relatie Ook veel-op-veel relaties kunnen aangeduid worden met behulp van JPA. In een databank kunnen we deze relatie enkel definiëren door een tussentabel in te voegen. Op deze manier moet deze relatie dan ook aangeduid worden in het objectmodel. In het gebruikte objectmodel is te zien dat een object van de klasse Huisdier verschillende Persoon objecten als eigenaar kan hebben, en dat een object van de klasse Persoon verschillende objecten van de klasse Huisdier kan bevatten. Deze relatie wordt geannoteerd volgens codevoorbeeld 4.6.

Hoofdstuk 4. JPA 21 De annotatie @ManyToMany wordt gebruikt om de relatie aan te duiden. De annotatie @JoinTable zorgt voor een nieuwe tabel in de databank. Deze bestaat enkel uit verwijzingen naar de primaire sleutels van de objecten die bij elkaar horen. @Entity @PrimaryKeyJoinColumn ( name = HUISDIER ID ) @Table ( name = HUISDIER ) public class H u i s d i e r extends Dier { @ManyToMany( f e t c h = FetchType.EAGER) @JoinTable ( name = HUISDIER EIGENAAR, joincolumns = { @JoinColumn ( name = HUISDIER ID ) }, inversejoincolumns = { @JoinColumn (name = PERSOON ID ) } ) private C o l l e c t i o n <Persoon> e i g e n a a r s = new ArrayList<Persoon >(); } Code 4.6: Mapping van een klasse In het databankmodel van figuur 4.4 is duidelijk te zien dat er een extra tabel in de databank wordt ingevoegd. In de andere klasse die bij de relatie betrokken is, dient enkel aangeduid te worden door welk attribuut de relatie gespecificeerd wordt, zoals in codevoorbeeld 4.5. Figuur 4.4: Een veel-op-veel relatie 4.2.4 Overerving en polymorfisme Ten slotte dient nog de overerving tussen de klasse Dier en Huisdier geïmplementeerd te worden. Hiervoor wordt de @Inheritance annotatie gebruikt in de superklasse. Hibernate heeft verschillende technieken ingebouwd om ervoor te zorgen dat de juiste objecten uit de databank opgehaald worden. Het strategy attribuut van de @Inheritance annotatie bepaalt welke strategie gevolgd wordt, om het databankmodel te bepalen. Deze strategie bepaalt welke SQL statements uitgevoerd worden. Deze keuze heeft meestal dan ook enkel

Hoofdstuk 4. JPA 22 belang indien men aan een vast databankmodel dient te voldoen, of kan een invloed hebben op de performantie van de uitgevoerde queries. In deze masterproef wordt hier echter niet dieper op ingegaan. @Entity @Inheritance ( s t r a t e g y = InheritanceType. JOINED) @Table ( name= DIER ) public class Dier {... } Code 4.7: Annotaties op een superklasse 4.3 Configuratie van JPA De JPA functionaliteit dient ook nog informatie te krijgen over welke klassen geannoteerd zijn. Alsook dienen connectiegegevens aanwezig te zijn, om de gebruikte databank te kunnen lokaliseren, en een connectie op te zetten. Deze informatie wordt opgeslagen in een XMLbestand. Default wordt dit bestand opgeslagen in de META-INF map. <p e r s i s t e n c e xmlns= h t t p : // java. sun. com/xml/ ns / p e r s i s t e n c e x m l n s : x s i= h t t p : //www. w3. org /2001/XMLSchema i n s t a n c e x s i : s c h e m a L o c a t i o n= h t t p : // java. sun. com/xml/ ns / p e r s i s t e n c e h t t p : // java. sun. com/xml/ ns / p e r s i s t e n c e / p e r s i s t e n c e 1 0. xsd version= 1. 0 > <! p e r s i s t e n c e. xml > <p e r s i s t e n c e u n i t name= h e l l o w o r l d > <p r o p e r t i e s> <! Scan f o r annotated c l a s s e s and Hibernate mapping XML f i l e s > <property name= h i b e r n a t e. a r c h i v e. a u t o d e t e c t i o n value= c l a s s /> <property name= h i b e r n a t e. connection. d r i v e r c l a s s value= com. mysql. jdbc. Driver /> <property name= h i b e r n a t e. connection. password value= m a l l e z i e /> <property name= h i b e r n a t e. connection. u r l value= j d b c : m y s q l : // l o c a l h o s t / t e s t /> <property name= h i b e r n a t e. connection. username value= r o o t /> <property name= h i b e r n a t e. d i a l e c t value= org. h i b e r n a t e. d i a l e c t. MySQLInnoDBDialect /> <property name= h i b e r n a t e. hbm2ddl. auto value= c r e a t e /> </ p r o p e r t i e s>

Hoofdstuk 4. JPA 23 </ p e r s i s t e n c e u n i t> </ p e r s i s t e n c e> Code 4.8: Voorbeeld van persistence.xml configuratiebestand 4.4 Opslaan en opvragen van objecten

Hoofdstuk 5 Spring Spring is een open-source framework dat tot doel heeft om de eenvoudige J2EE applicaties te ontwikkelen. Elke java-applicatie kan echter voordelen hebben bij Spring. Spring heeft verschillende hulpmiddelen om unit testen te vereenvoudigen. Spring zorgt voor een losse koppeling tussen klassen. Spring zorgt voor minder, en dus makkelijkere code, en biedt hulpklassen aan voor een verscheidenheid aan veelgebruikte technologieën. Spring is a lightweight dependency injection and aspect-oriented container and framework (Walls & Breidenbach, 2008) In deze masterproef gebruiken we vooral de losse koppeling die door Spring verkregen wordt, door dependecy injection te gebruiken. Alsook de hulpklassen die Spring bevat om met minder code JPA opdrachten uit te voeren. 5.1 Dependency injection 5.2 JPA en Spring 24

Bibliografie (2009). Introduction to archetypes. http://maven.apache.org/guides/introduction/ introduction-to-archetypes.html. Geraadpleegd: maart 2009. Bauer, C. & King, G. (2007). Java Persistance with Hibernate. Manning, second edition. Biswas, R. & Ort, E. (2006). The java persistence api - a simpler programming model for entity persistence. http://java.sun.com/developer/technicalarticles/j2ee/jpa/. Geraadpleegd: januari 2009. Johnson, R., Hoeller, J., Arendsen, A., Risberg, T., & Sampaleanu, C. (2005). Professional Java Development with the Spring Framework. Wiley Publishing, first edition. Massol, V. & Husted, T. (2004). JUnit in action. Manning, first edition. Massol, V., van Zyl, J., Porter, B., Casey, J., & Sanchez, C. (2008). Better Builds with Maven. DevZuz, first edition. Walls, C. & Breidenbach, R. (2008). Spring in action. Manning, second edition. 25