Introduktion

I den här handledningen diskuterar vi Hibernate och Java Persistence API (JPA) – med fokus på skillnaderna mellan dem.

Vi börjar med att utforska vad JPA är, hur det används och de centrala begreppen bakom det.

Sedan tar vi en titt på hur Hibernate och EclipseLink passar in i bilden.

Object-Relational Mapping

Innan vi dyker ner i JPA är det viktigt att förstå begreppet Object-Relational Mapping – även känt som ORM.

Object-Relational Mapping är helt enkelt processen att persistera vilket Java-objekt som helst direkt till en databastabell. Vanligtvis blir namnet på det objekt som lagras namnet på tabellen och varje fält i objektet blir en kolumn. När tabellen är upprättad motsvarar varje rad en post i programmet.

En introduktion till JPA

Java Persistence API, eller JPA, är en specifikation som definierar hanteringen av relationsdata i ett Java-program. API:et kartlägger en uppsättning begrepp som definierar vilka objekt i applikationen som ska persisteras och hur de ska persisteras.

Det är viktigt att notera här att JPA bara är en specifikation och att den behöver en implementering för att fungera – men mer om det senare.

Nu diskuterar vi några av de centrala JPA-koncepten som en implementering måste täcka.

3.1. Entity

Klassen javax.persistence.Entity definierar vilka objekt som ska persisteras till databasen. För varje persisterad entitet skapar JPA en ny tabell i den valda databasen.

Den valda entiteten bör dessutom definiera en primärnyckel som anges av @Id-annotationen. Tillsammans med @GeneratedValue-annotationen definierar vi att primärnyckeln ska genereras automatiskt när posten persisteras till databasen.

Låt oss ta en snabb titt på ett snabbt exempel på en entitet som beskrivs av JPA.

@Entitypublic class Car { @GeneratedValue @Id public long id; // getters and setters}

Håll i minnet att detta för närvarande inte kommer att ha någon effekt på applikationen – JPA tillhandahåller inte någon implementeringskod.

3.2. Field Persistence

Ett annat centralt koncept i JPA är field persistence. När ett objekt i Java definieras som en entitet persisteras alla fält i det automatiskt som olika kolumner i entitetstabellen.

Om det finns ett fält i ett persisterat objekt som vi inte vill persistera till databasen kan vi deklarera fältet som transient med @Transient-annotationen.

3.3. Relationer

Nästan specificerar JPA hur vi ska hantera relationer mellan olika databastabeller i vårt program. Som vi har sett hanterar JPA detta med hjälp av annotationer. Det finns fyra relationsannotationer som vi måste tänka på:

  1. @OneToOne
  2. @OneToMany
  3. @ManyToOne
  4. @ManyToMany

Låt oss ta en titt på hur detta fungerar:

@Entitypublic class SteeringWheel { @OneToOne private Car car // getters and setters}

I vårt exempel ovan beskriver SteeringWheel-klassen ett ett till ett-förhållande med vår Car-klass från tidigare.

3.4. Entity Manager

Slutligen specificerar klassen javax.persistence.EntityManager operationer till och från databasen. EntityManager innehåller vanliga CRUD-operationer (Create, Read, Update och Delete) som persisteras till databasen.

JPA Implementations

Med JPA-specifikationen som definierar hur och vad vi ska persistera behöver vi nu välja en implementationsleverantör som levererar den nödvändiga koden. Utan en sådan leverantör skulle vi behöva implementera alla relevanta klasser för att överensstämma med JPA, och det är mycket arbete!

Det finns många leverantörer att välja mellan, och var och en har sina egna för- och nackdelar. När vi fattar ett beslut om vilken vi ska använda bör vi ta hänsyn till några av följande punkter:

  1. Projektets mognad – hur länge har leverantören funnits och hur väldokumenterad är den?
  2. Underprojekt – har leverantören några användbara underprojekt för vår nya tillämpning?
  3. Support från gemenskapen – finns det någon som kan hjälpa oss när vi hamnar i ett kritiskt fel?
  4. Benchmarking – hur prestandamässigt är implementationen?

Vi kommer inte att gå in på djupet när det gäller benchmarking av olika JPA-leverantörer, men JPA Performance Benchmark (JPAB) innehåller värdefulla insikter om detta.

Med det sagt, låt oss ta en kort titt på några av de främsta leverantörerna av JPA.

Hibernate

I sin kärna är Hibernate ett verktyg för objektrelationell mappning som tillhandahåller en implementering av JPA. Hibernate är en av de mest mogna JPA-implementationerna som finns, med en enorm gemenskap som stöder projektet.

Det implementerar alla javax.persistence-klasser som vi tittade på tidigare i artikeln samt tillhandahåller funktionalitet utöver JPA – Hibernate-verktyg, validering och sökning. Även om dessa Hibernate-specifika API:er kan vara användbara behövs de inte i tillämpningar som bara kräver JPA:s basfunktionalitet.

Låt oss ta en snabb titt på vad Hibernate erbjuder med @Entity-annotationen.

Samtidigt som den uppfyller JPA-kontraktet lägger @org.hibernate.annotations.Entity till ytterligare metadata som går utöver JPA-specifikationen. Detta gör det möjligt att finjustera enhetsbevaringen. Låt oss till exempel titta på några annotationer som Hibernate erbjuder och som utökar funktionaliteten hos @Entity:

  1. @Table – låter oss ange namnet på den tabell som skapats för entiteten
  2. @BatchSize – anger batchstorleken när man hämtar entiteter från tabellen

Det är också värt att notera några av de extra funktioner som JPA inte specificerar, och som kan visa sig vara användbara i större applikationer:

  1. Anpassningsbara CRUD-statements med @SQLInsert-, @SQLUpate- och @SQLDelete-annotationerna
  2. Stöd för mjuk borttagning
  3. Immuterbara enheter med @Immutable-annotationen

För en djupare djupdykning i Hibernate- och Java- persistens – gå över till vår handledningsserie om Spring persistens.

EclipseLink

EclipseLink, som byggs av Eclipse Foundation, tillhandahåller en JPA-implementation med öppen källkod. Dessutom har EclipseLink stöd för ett antal andra persistensstandarder som Java Architecture for XML Binding (JAXB).

Simpelt uttryckt, i stället för att persistera ett objekt till en databasrad, mappar JAXB det till en XML-representation.

Nästan, genom att jämföra samma @Entity-annotationsimplementation, ser vi att EclipseLink erbjuder återigen olika tillägg. Medan det inte finns någon annotation för @BatchSize som vi såg tidigare, erbjuder EclipseLink andra alternativ som Hibernate inte gör.

Till exempel:

  1. @ReadOnly – anger att entiteten som ska persisteras är skrivskyddad
  2. @Struct – definierar klassen som ska mappas till en databas av typen ”struct”

Om du vill läsa mer om vad EclipseLink har att erbjuda, kan du gå över till vår guide om EclipseLink med Spring.

Slutsats

I den här artikeln har vi tittat på Java Persistence API, eller JPA.

Slutligt har vi undersökt hur det skiljer sig från Hibernate och EclipseLink.

By: adminPosted on

Lämna ett svar

Din e-postadress kommer inte publiceras.