Brainscape's Knowledge GenomeTM


Top Flashcards (Certified)
All Flashcards

JMC > Module 4: Java Persistence API > Flashcards

Module 4: Java Persistence API Flashcards

1
Q

Wat is een relationele database?

A

Een database dat hun data opslaat in tabellen die onderling relaties met elkaar hebben.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
2
Q

Wat is een Primary Key?

A

Een eigenschap van een tabel waarmee een rij geidentificeerd kan worden.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
3
Q

Wat is een verplicht eigenschap van een tabel?

A

Hij moet een Primary Key (PK) hebben

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
4
Q

Over hoeveel kolommen mag een Primary Key bestaan?

A

op een of meerdere kolommen

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
5
Q

Waarom tabellen indexen?

A

Hiermee is het mogelijk om het databasesysteem te optimaliseren door data sneller te kunnen ophalen.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
6
Q

Wat is een stored procedure?

A

Stored procedures zijn opgeslagen query’s die in de databaselaag zelf zitten. Deze kunnen vervolgens aangeroepen worden vanuit andere query’s of op basis van een preconditie.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
7
Q

Wat is een view?

A

Views zijn opgeslagen queries die zich gedragen als tabellen. Hiermee kun je bijvoorbeeld data uit diverse tabellen samenbrengen in een nieuwe (virtuele) tabel.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
8
Q

Wat is een schema?

A

Tabellen (met indexen en relaties), stored procedures en views worden samen ondergebracht in een schema.

Een schema kan worden gebruikt om de data te scheiden en bijvoorbeeld authorisatie toe te passen.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
9
Q

Waar staat SQL voor?

A

Structured Query Language

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
10
Q

Waar staat JDBC voor?

A

Java Database Connectivity

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
11
Q

Waar wordt JDBC voor gebruikt?

A

Om een verbinding met een database te maken.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
12
Q

Waar wordt SQL voor gebruikt?

A

Om data uit een database op te halen middels queries

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
13
Q

Hoe kunnen we een verbinding maken met een Database binnen Java? (welke klasse en functie?)

A

Door gebruik te maken van JDBC en de klasse DriverManager met de functie getConnection().

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
14
Q

Waarom is de standaard JDBC-implementatie niet toereikend in de praktijk?

A

Een relationeel model valt niet direct 1:1 over te nemen naar het object model in een applicatie.

(Dit noemen we ook wel object-relational mismatch)

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
15
Q

Wat zijn de onvolkomendheden van Object-relational mismatch?

A
  • Granulariteit
  • Overerving
  • Identiteit
  • Relaties
  • Navigatie
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
16
Q

Wat is ORM en waar staat het voor?

A

Object-relational mapping (ORM)

Met een ORM wordt automatisch gemapped tussen het objectenmodel en het databasemodel. Zodra een query op de DB wordt uitgevoerd, zorgt een ORM er voor dat het resultaat van je query omgezet wordt naar een of meerdere Java-objecten.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
17
Q

Welke specificatie heeft Java voor de implementatie van een ORM?

A

Java Persistence API (JPA).

Er zijn verschillende implementaties die aan deze specificatie voldoen.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
18
Q

Hoe worden JPA implementaties ook wel genoemd?

A

JPA-providers

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
19
Q

Hoe wordt een nieuwe entiteit toegevoegd aan de Persistence Context?

A

Middels de persist() methode

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
20
Q

Hoe zorgen we ervoor dat een entiteit tijdelijk uit de Persistence Context verwijderd wordt?

A

Een entiteit kun je ook detachen met de detach-methode. Dit zorgt ervoor dat de context niet langer naar wijzigingen kijkt. We noemen de entiteit dan gedetacht.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
21
Q

Hoe zorgen we ervoor dat een gedetachte entiteit weer wordt gemanaged fdoor de Persistence Context (PC)?

A

Zodra je een gedetachte entiteit weer wilt meenemen in de context, kun je deze mergen. Vanaf dit moment is de entiteit weer gemanaged. Dit kun je doen met de merge-methode.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
22
Q

Hoe verwijderen we een entiteit uit de Persistence Context (PC)?

A

Als je een entiteit permanent uit de context wilt verwijderen, gebruik je de remove-methode. Dit zorgt ervoor dat de entiteit wordt verwijderd en eventuele relaties worden verbroken.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
23
Q

Uit welke package komen de meeste JPA klassen?

A

javax.persistence

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
24
Q

De mapping van objecten naar entiteiten wordt gedaan in de ____

A

persistence unit

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
25
Hoe kan je een persistence unit definiëren?
- persistence.xml bestand in de META-INF-map | - Annotaties
26
Wat is JPQL en waar wordt het voor gebruikt?
Java Persistence Query Language Om objecten uit een database te halen gebruikt JPA zijn eigen querytaal (JPQL). Deze lijkt op SQL maar is meer object-geörienteerd. Zo kun je onder andere van database-entiteiten eigenschappen ophalen door de punt-notatie.
27
Om JPA in Spring te gebruiken, moeten er een aantal beans gedefinieerd worden. Welke moet je definiëren?
- DataSource - EntityManager - TransactionManager
28
Wat is de verantwoordelijkheid van de Data source bean?
De data source zorgt voor een connectie naar je database. Deze verbinding komt tot stand door de driver, URL en eventueel een gebruikersnaam en wachtwoord mee te geven. Daarnaast zorgt de datasource ervoor dat de verbinding in de connectiepool verwerkt wordt.
29
Wat is een Connectiepool?
Zodra je je applicatie opstart wordt er een verzameling connecties aangemaakt. Aangezien het maken van een databaseverbinding een kostbare operatie is, worden deze niet bij iedere query opnieuw gemaakt, maar blijven ze onderhouden tot het moment dat je de applicatie stopt. Deze verbindingen samen noemen we de connectiepool (CP).
30
Wat is de verantwoordelijkheid van de Entity manager bean?
Een entity manager (EM) regelt de API voor het toevoegen en verwijderen van entiteiten. De manager verzorgt ook een persistence context. Een entity manager kan uitsluitend gemaakt worden via een factory.
31
Wat is de verantwoordelijkheid van de Transactiemanager bean?
Een reeks samenhangende bewerkingen op entiteiten wordt een transactie genoemd. Om de integriteit en atomiciteit van een database te kunnen waarborgen, worden deze transacties bijgehouden in een transactiemanager (TM). In het geval van een databasefout zou deze manager een rollback uit kunnen voeren om de vorige staat te herstellen.
32
Wat doet de Spring annotatie @Transactional?
Transactioneel wordt gebruikt om meer dan één schrijfactie op een database te combineren als een enkele atomaire bewerking. Als er iets fout gaat, draait Spring de bewerking terug met een rollback.
33
Wat is Dirty checking?
Bij Dirty checking detecteert hibernate automatisch of een object is gewijzigd (of niet) en moet worden bijgewerkt. Dirty checking stelt de gebruiker of ontwikkelaar in staat om tijdrovende schrijfacties voor databases te vermijden.
34
Wat is de Spring feature Transparent persistence?
Transparante persistentie is het opslaan en ophalen van persistente gegevens met weinig of geen werk van u, de ontwikkelaar.
35
Wat is Optimistic locking?
Om concurrency te bevorderen bied JPA een mechanisme genaamd optimistic locking. Als je dit gebruikt houdt JPA een versionering bij van iedere entiteit die gepersist is in de database. Bij iedere wijziging van de entiteit past JPA vervolgens dit versienummer aan.
36
Waar kan je de @Version-annotatie voor gebruiken?
Om aan te geven op welke eigenschap van je entiteit JPA Optimistic locking moet toepassen kun je de @Version-annotatie gebruiken. Je kunt hiervoor een numeriek veld gebruiken, maar een tijd kan ook.
37
Wat doet de JPA annotatie @Entity?
Voor iedere entiteit die je wilt persisten naar de database dien je de @Entity-annotatie te gebruiken. Hiermee word je klasse in JPA geregistreerd. Je kunt ook een naam meegeven aan de annotatie, waardoor je een andere naam voor je entiteit dan voor je klasse kunt gebruiken.
38
Wat doet de JPA annotatie @Table?
Standaard genereert JPA een tabelnaam voor je op basis van je klassenaam. Het is mogelijk om dit te overriden door de @Table-annotatie te gebruiken. Ook is het mogelijk om hiermee de tabel in een andere database en/of schema te creëren.
39
Wat doet de JPA annotatie @Id?
De @Id-annotatie markeert een veld als een primair sleutelveld.
40
Wat doet de JPA annotatie @GeneratedValue?
Standaard wordt de identiteit op het gekozen veld gegenereerd op basis van de meest efficiënte manier voor het gekozen databasesysteem. Mocht je dit toch willen overriden, kun je de @GeneratedValue-annotatie gebruiken om een andere methode te kiezen. Hiervoor heb je de keuze uit AUTO (standaard), IDENTITY (auto increment), SEQUENCE (voor een niet-standaard increment) of TABLE (waarbij je een extra tabel gebruikt).
41
Wat doet de JPA annotatie @Column?
Wordt gebruikt om de toegewezen kolom op te geven voor een persistente eigenschap of veld. Als er geen kolomannotatie is opgegeven, zijn de standaardwaarden van toepassing.
42
Wat doet de JPA annotatie @Enumerated?
Specificeert dat een persistente eigenschap of veld moet worden bewaard als een enum type.
43
Wat doet de JPA annotatie @Transient
Mocht je een bepaalde eigenschap van je entiteit niet willen opslaan binnen een veld in je database, dan kun je de @Transient-annotatie gebruiken.
44
Wat is Liquibase?
Liquibase is een open-source database-onafhankelijke bibliotheek voor het volgen, beheren en toepassen van wijzigingen in databaseschema's.
45
Waarom Liquibase gebruiken?
Liquibase biedt een schema changelog. Dit is een overzicht van de schemawijzigingen in de loop van de tijd. Het stelt de databaseontwerper in staat om wijzigingen in het schema op te geven en maakt programmatische upgrade of downgrade van het schema op aanvraag mogelijk.
46
Wat doet de JPA annotatie @Inheritance?
Met de @Inheritance annotatie is het binnen JPA mogelijk om op verschillende manieren overerving van eigenschappen te verwerken in het entiteitenmodel.
47
Wat doet de volgende @Inheritance strategie? @Inheritance(strategy = InheritanceType.SINGLE_TABLE)
Bij deze strategie worden alle eigenschappen van alle mogelijke subklassen in een enkele tabel geplaatst. Inherent aan deze aanpak is het feit dat hierdoor velden in sommige rijen null zijn.
48
Met gebruik van @Inheritance(strategy = InheritanceType.SINGLE_TABLE) Moet JPA voor iedere rij weten welk type entiteit is opgeslagen. Hoe kan dat worden gedaan?
Met de @DiscriminatorColumn en de @DiscriminatorValue-annotaties
49
Wat doet de volgende @Inheritance strategie? @Inheritance(strategy = InheritanceType.JOINED)
Deze strategie zorgt ervoor dat er aparte tabellen worden aangemaakt voor subklassen. Daarnaast bestaat er een tabel waarin alle gemeenschappelijke eigenschappen van de subklassen zitten.
50
Wat doet de volgende @Inheritance strategie? @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
De Table Per Class-strategie wijst elke entiteit toe aan zijn tabel die alle eigenschappen van de entiteit bevat, inclusief de overgeërfde.
51
Welke @Inheritance strategie gebruiken we in welke situatie?
- single table strategy: best performance - Joined strategy: data consistency - table per class: ...
52
Welke drie opties zijn er om overerving te gebruiken in JPA?
- @Inheritance-annotatie - @MappedSuperclass-annotatie - Embeddables (@Embeddable)
53
Wat is een @Embeddable?
Een embeddable is een aparte klasse die je als eigenschap kunt meegeven aan entiteiten. Hierdoor kun je een groep eigenschappen in 1 keer in een andere klasse te importeren. Een embeddable is GEEN entiteit en kan je dus niet individudeel opslaan.
54
Hoe kunnen we de naamgeving van ingevoegde eigenschappen van een Embeddable aanpassen?
Middels de @AttributeOverride-annotatie
55
Wat is het verschil tussen @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) en @MappedSuperClass?
Met @Inheritance kunnen we het object nog gebruiken als los entiteit, met @MappedSuperClass niet.
56
Als de owning side niet direct te bepalen is (bidirectionele relatie), hoe kunnen we deze dan toch bepalen?
We spreken af dat de owning side de kant is waar de foreign key aanwezig is.
57
Waarom is een unidirectionele 1:N-relatie af te raden?
Dit levert performanceproblemen op
58
Welk mechnisme biedt JPA voor het ophalen van een entiteit die een relatie heeft met andere entiteiten?
Lazy fetching en eager fetching.
59
Wat is het nadeel van lazy fetching?
Het leidt tot meer nieuwe query's als de entiteiten wel nodig zijn.
60
Welke fetching mechanismen zijn de standaard voor de verschillende relaties?
Voor 1:1-relaties en N:1-relaties is de standaard om deze eager in te laden. Voor 1:N-relaties en N:N-relaties is de standaard om deze lazy in te laden.
61
Hoe kunnen we het fetching gedrag overriden?
Door de eigenschap fetch toe te kennen aan de relatie-annotatie. @OneToMany(fetch = FetchType.EAGER)
62
Hoe kunnen we de naam van de foreign key-kolom in de tabel aanpassen?
Met de @JoinColumn annotatie en de name-eigenschap.
63
Hoe kunnen we de naam van de foreign key-kolom in de tabel aanpassen?
Met de @JoinColumn annotatie en de name-eigenschap.
64
Hoe kunnen we de naam van de koppeltabel aanpassen?
Met de @JoinTable-annotatie.
65
Hoe kunnen we de ids van twee entiteiten met een 1:1 relatie synchroniseren?
Met de @MapsId- annotatie. Zodra je op deze relatie een @JoinColumn-annotatie toevoegt, zal JPA er automatisch voor zorgen dat beide entiteiten hetzelfde id als primaire sleutel krijgen.
66
Wat betekent cascading?
Cascading zegt iets over het gedrag van child-objecten zodra de state van hun parent wijzigt. Een voorbeeld hiervan is het verwijderen van reacties op een blogartikel. Zodra een blogartikel wordt verwijderd, is het vaak wenselijk om ook achtergebleven reacties te verwijderen, aangezien deze anders niet inzichtelijk meer zouden zijn en dus geen functie meer hebben. Mocht dit niet gedaan worden, dan zouden we kunnen spreken van orphans (weesrecords).
67
Welke cascading opties zijn er?
persist, remove, refresh, detach, all.
68
Waar moet cascading worden gedefinieerd?
Bij de parent (inverse side) van de relatie. Andersom zou dit een code smell introduceren en mogelijk tot bugs kunnen leiden.
69
Waat staat JPQL voor?
Java Persistence Query language
70
Wat is JPQL?
JPQL is Java Persistence Query Language gedefinieerd in JPA-specificatie. Het is een platformonafhankelijke taal en wordt gebruikt om query's op entiteiten te maken om op te slaan in een relationele database. JPQL is ontwikkeld op basis van SQL-syntaxis.
71
Wat is het voordeel van JPQL?
JPQL maakt het mogelijk de query's uit te drukken in termen van Java-entiteiten in plaats van de (native) SQL-tabellen en kolommen.
72
Welke type queries bestaan er?
- Native query's - Dynamic query's - Named query's
73
Wat is een Native query?
Native query's maken gebruik van plain SQL. Dit zorgt ervoor dat ze direct op de database worden uitgevoerd, zonder tussenkomt van ORM.
74
Wat is het nadeel van een native query?
Een nadeel is dat native queries databasespecifiek zijn. Als je dit veel gebruikt in je code, wordt je applicatie meer databasegebonden en dus minder portable.
75
Wat is een Dynamic query?
Een Dynamic Query is een query dat gebruikmaakt van JPQL...
76
Wat is het voordeel van een Native query?
Native queries hoeven niet geparsed en gecompileerd te worden naar SQL tijdens run-time en zijn dus snel.
77
Wat is het nadeel van een Dynamic query?
Een dynamic query moet tijdens run-time worden geparsed en gecompileerd, wat een kostbare operatie is.
78
Wat is een Named query?
Named queries zijn queries die gebruikmaken van JPQL. Named queries worden gedefinieerd boven de entiteit klasse.
79
Wat is het verschil tussen een Named query en een Dynamic query?
Named queries worden opgezet tijdens build-time terwijl Dynamic queries worden opgetuigt tijdens run-time.
80
Wat gebeurd er onder water bij gebruik van de @Transactional annotatie?
Spring maakt dynamisch een proxy die dezelfde interface(s) implementeert als de klasse die je annoteert. En wanneer klanten uw object callen, worden de oproepen onderschept en wordt het gedrag geïnjecteerd via het proxymechanisme
81
Wat is een gevaar van cascading?
Zodra een blogartikel wordt verwijderd, is het vaak wenselijk om ook achtergebleven reacties te verwijderen, aangezien deze anders niet inzichtelijk meer zouden zijn en dus geen functie meer hebben. Mocht dit niet gedaan worden, dan zouden we kunnen spreken van orphans (weesrecords).
82
Wat zijn de voor en nadelen van ORM?
Met een ORM krijg je namelijk een automatische 'vertaling' tussen je objectenmodel en je databasemodel. ORM heeft de neiging traag te zijn.
83
Wat is de Persistence Context?
De persistentiecontext is de verzameling van alle persistente (beheerde) objecten van een EntityManager.
84
Wat is de verantwoordelijkheid van de Persistence Context?
Om ervoor te zorgen dat een database-entiteitsobject wordt vertegenwoordigd door niet meer dan één in-memory entiteitsobject binnen dezelfde EntityManager.
85
Wat is het nadeel van de SINGLE TABLE inheritance strategie?
Je kan geen gebruikmaken van NOT NULL constraints.

JMC (11 decks)

Brainscape helps you reach your goals faster, through stronger study habits.
© 2025 Bold Learning Solutions. Terms and Conditions