Java Persistence API: annotations

Java Persistence API (JPA in het kort) is eigenlijk de API die ervoor zorgt dat je je objecten kan opslaan in databases. Bijvoorbeeld je hebt een database voor liedjes. Je hebt een songs, albums en artiesten tabel. Daarin zitten bepaalde kolommen die dan per record waarden krijgen. Nu is het zo dat ik in me opleiding een basis gekregen heb van JPA. Daar leerden we enkele annotaties kennen als @Entity en @OneToMany. De annotaties zeggen dat die klasse een tabel is en dat de properties van de klasse de kolommen zijn. Nu heb je ook dat je relaties hebt tussen objecten en tabellen. Bijvoorbeeld een liedje kan in meerdere albums voorkomen en een album kan meerdere liedjes hebben. Dat is een ManyToMany relatie. Een andere relatie is een OneToMany (of ManyToOne) relatie. Voorbeeld is dat een song een artiest heeft en een artiest kan meerdere liedjes hebben. In SQL vorm en met behulp van ERD toestanden wordt dit als volgt weergegeven.

Nu is het zo dat ik al ontwikkelaar altijd eerst de database ontwerp doe en dan pas de software eromheen ga maken. Nu had ik een ERD gemaakt en alle tabellen aangemaakt en dan komt de ontwikkeling in Java. Omdat het mijn eerste grote toepassing is in Java met combinatie van een database, zat ik mij af te vragen of ik geen JPA kon gebruiken (want zelf een ORM maken neemt dan terug veel tijd in beslag). Ik had al een basis kennis in me broekzak en wist dat JPA eigenlijk nogal een eigenzinnige manier heeft van namen te geven aan tabellen en kolommen. Ook had ik geen zin om de structuur aan JPA over te laten maar JPA moest mijn structuur volgen. Dus die naam gebruiken voor die entiteit en die namen voor die kolommen en de relaties moesten zo gaan noemen. Dus ik ging op zoek hoe ik dat kon doen. Ik vond dingen als @JoinTable en @JoinColumn voor de relaties en @Table en @Column voor de namen van tabellen en kolommen.

Laat ons eens beginnen met de code te geven die Netbeans maakt als je een entiteit maakt.

Song.java
Album.java
Artiest.java

Je ziet dat er relaties zijn. In JPA moet een relatie altijd een eigenaar hebben. Je ziet dat er soms staat mappedBy en dan een naam. Dat is de naam van de klasse property die de eigenaar is van de relatie. Zo weet JPA dat aan de andere kant van de relatie naar die mappedBy moet gekeken worden om zo de corresponderende objecten te vinden.

Nu willen we dat de tabel namen en kolommen gelijken op onze ERD. Dit is belangrijk want als die database al in gebruik is door andere toepassingen, dan willen we niet dat JPA alles gaat verknoeien door zelf namen te geven. Ik heb de code nogmaals gepost met de annotaties erbij en in commentaar staat er uitleg bij.

Song.java
Album.java
Artiest.java

En nog een screenshot van de tabellen en kolommen die gemaakt zijn.

Voor meer uitleg of vragen kan je altijd een reactie nalaten hier.

2 Responses to Java Persistence API: annotations

  1. Martijn zegt:

    Leuk artikel, vooral hoe je het ERD toepast bij de ontwikkeling van je applicatie. Zeer interessant, enkel vraag ik me af wanneer je gebruik maakt van use-cases, activiteiten- en klassendiagram. Gebruik je die ook wel eens en wanneer?

    • stijn1989 zegt:

      Klassendiagram schets ik op papier. Dat doe ik enkel om te weten hoe de relaties gaan liggen in klasses.
      Use-cases doe ik ook en volg ik eigenlijk tijdens de ganse implementatie van de functionaliteit.
      Een activiteitendiagram maak ik niet, ken die ook nog niet zo goed.

      Een andere diagram die ik ook af en toe schets is de State diagram.

Geef een reactie

Vul je gegevens in of klik op een icoon om in te loggen.

WordPress.com logo

Je reageert onder je WordPress.com account. Log uit / Bijwerken )

Twitter-afbeelding

Je reageert onder je Twitter account. Log uit / Bijwerken )

Facebook foto

Je reageert onder je Facebook account. Log uit / Bijwerken )

Google+ photo

Je reageert onder je Google+ account. Log uit / Bijwerken )

Verbinden met %s

%d bloggers op de volgende wijze: