Het verschil tussen JPA, Hibernate en EclipseLink

1. Inleiding

In deze tutorial bespreken we Hibernate en de Java Persistence API (JPA) - met een focus op de verschillen daartussen.

Goed begin met te onderzoeken wat JPA is, hoe het wordt gebruikt en wat de kernconcepten zijn erachter.

Vervolgens bekijken we hoe Hibernate en EclipseLink in de afbeelding passen.

2. Object-relationele mapping

Voordat we ingaan op JPA, is het belangrijk om het concept van Object-Relational Mapping, ook wel ORM genoemd, te begrijpen.

Object-relationele mapping is eenvoudig het proces waarbij een Java-object rechtstreeks in een databasetabel wordt bewaard. Gewoonlijk wordt de naam van het object dat wordt behouden, de naam van de tabel en wordt elk veld binnen dat object een kolom. Als de tabel is ingesteld, komt elke rij overeen met een record in de applicatie.

3. Een inleiding tot de PPV

De Java Persistence API, of JPA, is een specificatie die het beheer van relationele gegevens in een Java-applicatie definieert. De API brengt een reeks concepten in kaart die definieert welke objecten binnen de applicatie moeten worden behouden en hoe deze moeten worden behouden.

Het is belangrijk op te merken dat JPA is slechts een specificatie en dat het een implementatie nodig heeft om te werken - maar daarover later meer.

Laten we nu enkele van de kernconcepten van de PPV bespreken die een implementatie moet omvatten.

3.1. Entiteit

De javax.persistence.Entity class definieert welke objecten in de database moeten worden bewaard. Voor elke permanente entiteit maakt JPA een nieuwe tabel aan binnen de gekozen database.

Bovendien moeten alle gekozen entiteiten een primaire sleutel definiëren die wordt aangeduid met de @ID kaart annotatie. Samen met de @GeneratedValue annotatie, definiëren we dat de primaire sleutel automatisch moet worden gegenereerd wanneer het record in de database wordt bewaard.

Laten we eens kijken naar een snel voorbeeld van een entiteit die wordt beschreven door JPA.

@Entity openbare klasse Auto {@GeneratedValue @Id openbare lange id; // getters en setters} 

Onthoud dat dit momenteel geen effect heeft op de applicatie - JPA biedt geen implementatiecode.

3.2. Veldpersistentie

Een ander kernconcept van PPV is persistentie in het veld. Wanneer een object in Java wordt gedefinieerd als een entiteit, worden alle velden erin automatisch behouden als verschillende kolommen in de entiteitstabel.

Als er een veld is binnen een persistent object dat we niet doen willen blijven in de database, kunnen we het veld transient declareren met de @Transient annotatie.

3.3. Verhoudingen

De volgende, JPA specificeert hoe we relaties tussen verschillende databasetabellen moeten beheren binnen onze applicatie. Zoals we hebben gezien, behandelt JPA dit met annotaties. Er zijn vier relatieannotaties waarmee we rekening moeten houden:

  1. @Een op een
  2. @Een te veel
  3. @ManyToOne
  4. @Veel te veel

Laten we eens kijken hoe dit werkt:

@Entity openbare klasse SteeringWheel {@OneToOne privéauto auto // getters en setters}

In ons voorbeeld hierboven is de Stuur klasse beschrijft een een-op-een relatie met onze Auto klas van vroeger.

3.4. Entiteitsbeheerder

eindelijk, de javax.persistence.EntityManager-klasse specificeert bewerkingen van en naar de database. De EntityManager bevat algemene bewerkingen voor maken, lezen, bijwerken en verwijderen (CRUD) die in de database worden bewaard.

4. JPA-implementaties

Met de JPA-specificatie die definieert hoe en wat we moeten volhouden, zijn we nu u moet een implementatieprovider kiezen om de benodigde code te leveren. Zonder zo'n provider zouden we alle relevante klassen moeten implementeren om te voldoen aan JPA, en dat is een veel van werk!

Er zijn tal van providers om uit te kiezen, met elk hun eigen voor- en nadelen. Bij het nemen van een beslissing waarop we moeten gebruiken overweeg een paar van de volgende punten:

  1. Project volwassenheid - hoe lang bestaat de provider al, en hoe goed gedocumenteerd is het?
  2. Deelprojecten - heeft de aanbieder nog bruikbare deelprojecten? voor onze nieuwe applicatie?
  3. Maatschappelijke hulp - is daar iedereen die ons kan helpen als we met een kritieke bug eindigen?
  4. Benchmarking - hoe performant is de implementatie?

Hoewel we niet dieper ingaan op de benchmarking van verschillende PPV-providers, bevat JPA Performance Benchmark (JPAB) hier waardevol inzicht in.

Laten we, met dat uit de weg, een korte blik werpen op enkele van de topaanbieders van JPA.

5. Slaapstand

In de kern, Hibernate is een object-relationele mapping-tool die een implementatie van JPA biedt. Hibernate is een van de meest volwassen JPA-implementaties rond, met een enorme gemeenschap die het project steunt.

Het implementeert alle javax.persistenceklassen die we eerder in het artikel hebben bekeken, en die functionaliteit bieden die verder gaat dan JPA - Hibernate-tools, validatie en zoeken. Hoewel deze Hibernate-specifieke API's nuttig kunnen zijn, zijn ze niet nodig in applicaties die alleen de basis JPA-functionaliteit nodig hebben.

Laten we eens kijken wat Hibernate te bieden heeft met de @Entiteit annotatie.

Bij het nakomen van het PPV-contract, @ org.hibernate.annotations.Entity voegt extra metadata toe die verder gaan dan de JPA-specificatie. Hierdoor kan de persistentie van de entiteit worden verfijnd. Laten we bijvoorbeeld eens kijken naar enkele annotaties die worden aangeboden door Hibernate die de functionaliteit van @Entiteit:

  1. @Tafel sta ons toe om specificeer de naam van de tafel gemaakt voor de entiteit
  2. @Seriegroottespecificeert de batchgrootte bij het ophalen van entities van de tafel

Het is ook vermeldenswaard dat enkele van de extra functies die de PPV niet specificeert, nuttig kunnen zijn in grotere toepassingen:

  1. Aanpasbare CRUD-statements met de @SQLInsert, @SQLUpate en @SQLDelete annotaties
  2. Ondersteuning voor zacht verwijderen
  3. Onveranderlijke entiteiten met de @Onveranderlijk annotatie

Ga voor een diepere duik in Hibernate en Java-persistentie naar onze tutorialserie Spring persistence.

6. EclipseLink

EclipseLink, gebouwd door de Eclipse Foundation, biedt een open source JPA-implementatie. Bovendien biedt EclipseLink ondersteunt een aantal andere persistentiestandaarden zoals Java Architecture for XML Binding (JAXB).

Simpel gezegd, in plaats van een object vast te houden aan een databaserij, wijst JAXB het toe aan een XML-weergave.

Vervolgens door hetzelfde te vergelijken @Entiteit annotatie implementatie zien we dat EclipseLink weer verschillende extensies aanbiedt. Hoewel er geen annotatie is voor @Seriegrootte zoals we eerder zagen, EclipseLink biedt andere opties die Hibernate niet biedt.

Bijvoorbeeld:

  1. @ReadOnly - geeft aan dat de entiteit die moet worden bewaard, alleen-lezen is
  2. @Struct - definieert de klasse die moet worden toegewezen aan een ‘struct'-type van een database

Om meer te lezen over wat EclipseLink te bieden heeft, ga je naar onze gids over EclipseLink met lente.

7. Conclusie

In dit artikel hebben we gekeken naar de Java Persistence API of JPA.

Ten slotte hebben we onderzocht hoe het verschilt van Hibernate en EclipseLink.