Vlad Mihalcea

introduktion

hvis du undrer dig over, hvorfor og hvornår du skal bruge JPA eller Hibernate, så vil denne artikel give dig et svar på dette meget almindelige spørgsmål. Fordi jeg har set dette spørgsmål stillet meget ofte på/r / java Reddit-kanalen, besluttede jeg, at det er værd at skrive et dybtgående svar om styrker og svagheder ved JPA og dvaletilstand.

selvom JPA har været en standard, siden den først blev udgivet i 2006, er det ikke den eneste måde, du kan implementere et dataadgangslag ved hjælp af Java. Vi vil diskutere fordele og ulemper ved at bruge JPA eller andre populære alternativer.

hvorfor og hvornår JDBC blev oprettet

i 1997, Java 1.1 introducerede jdbc (Java Database Connectivity) API, som var meget revolutionerende for sin tid, da det gav mulighed for at skrive dataadgangslaget en gang ved hjælp af et sæt grænseflader og køre det på enhver relationsdatabase, der implementerer JDBC API uden at skulle ændre din applikationskode.

JDBC API tilbød en Connection grænseflade til at kontrollere transaktionsgrænserne og oprette enkle kvm-udsagn via Statement API eller forberedte udsagn, der giver dig mulighed for at binde parameterværdier via PreparedStatement API.

så forudsat at vi har en post databasetabel, og vi vil indsætte 100 rækker, her er hvordan vi kunne nå dette mål med JDBC:

int postCount = 100;int batchSize = 50;try (PreparedStatement postStatement = connection.prepareStatement(""" INSERT INTO post ( id, title ) VALUES ( ?, ? ) """)) { for (int i = 1; i <= postCount; i++) { if (i % batchSize == 0) { postStatement.executeBatch(); } int index = 0; postStatement.setLong( ++index, i ); postStatement.setString( ++index, String.format( "High-Performance Java Persistence, review no. %1$d", i ) ); postStatement.addBatch(); } postStatement.executeBatch();} catch (SQLException e) { fail(e.getMessage());}

mens vi udnyttede multi-line tekstblokke og prøv-med-ressourcer blokke for at eliminere PreparedStatement close opkaldet, er implementeringen stadig meget detaljeret. Bemærk, at bind-parametrene starter fra 1, ikke 0, som du måske er vant til fra andre velkendte API ‘ er.

for at hente de første 10 rækker skal vi muligvis køre en forespørgsel via PreparedStatement, som returnerer et ResultSet, der repræsenterer det tabelbaserede forespørgselsresultat. Men da applikationer bruger hierarkiske strukturer, som JSON eller DTOs til at repræsentere forældre – barn-foreninger, er de fleste applikationer nødvendige for at omdanne JDBC ResultSet til et andet format i dataadgangslaget, som illustreret af følgende eksempel:

int maxResults = 10;List<Post> posts = new ArrayList<>();try (PreparedStatement preparedStatement = connection.prepareStatement(""" SELECT p.id AS id, p.title AS title FROM post p ORDER BY p.id LIMIT ? """)) { preparedStatement.setInt(1, maxResults); try (ResultSet resultSet = preparedStatement.executeQuery()) { while (resultSet.next()) { int index = 0; posts.add( new Post() .setId(resultSet.getLong(++index)) .setTitle(resultSet.getString(++index)) ); } }} catch (SQLException e) { fail(e.getMessage());}

igen er dette den bedste måde, vi kunne skrive dette med JDBC, da vi bruger tekstblokke, prøv-med-ressourcer og en flydende API til at bygge Post objekter.

ikke desto mindre er JDBC API stadig meget detaljeret og, endnu vigtigere, mangler mange funktioner, der kræves, når man implementerer et moderne dataadgangslag, som:

• en måde at hente objekter direkte fra forespørgselsresultatet sæt. Som vi har set i eksemplet ovenfor, skal vi gentage ReusltSet og udtrække kolonneværdierne for at indstille objektegenskaberne Post.
• en gennemsigtig måde at batch udsagn uden at skulle omskrive dataadgangskoden, når du skifter fra standard ikke-batching tilstand til at bruge batching.
• støtte til optimistisk låsning
• en pagination API, der skjuler den underliggende database-specifikke top-N og næste-N forespørgsel syntaks

hvorfor og hvornår Hibernate blev oprettet

i 1999 udgav Sun J2EE (Java Enterprise Edition), som tilbød et alternativ til JDBC, kaldet Entity Beans.

da Entity Beans imidlertid var notorisk langsomme, overkomplicerede og besværlige at bruge, besluttede Gavin King i 2001 at oprette en ORM-ramme, der kunne kortlægge databasetabeller til POJOs (almindelige gamle Java-objekter), og sådan blev Hibernate født.

da Hibernate var mere let end Enhedsbønner og mindre detaljeret end JDBC, blev Hibernate mere og mere populær, og det blev snart den mest populære Java-persistensramme og vandt over JDO, iBatis, Oracle TopLink og Apache cayenne.

hvorfor og hvornår blev JPA oprettet?

læring fra Hibernate-projektets succes besluttede Java EE-platformen at standardisere vejen Hibernate og Oracle TopLink, og sådan blev JPA (Java Persistence API) født.

JPA er kun en specifikation og kan ikke bruges alene, hvilket kun giver et sæt grænseflader, der definerer standard persistens API, som implementeres af en JPA-udbyder, som Hibernate, EclipseLink eller openjpa.

når du bruger JPA, skal du definere tilknytningen mellem en databasetabel og dens tilknyttede Java-objektobjekt:

@Entity@Table(name = "post")public class Post { @Id private Long id; private String title; public Long getId() { return id; } public Post setId(Long id) { this.id = id; return this; } public String getTitle() { return title; } public Post setTitle(String title) { this.title = title; return this; }}

bagefter kan vi omskrive det forrige eksempel, som gemte 100 post records ser sådan ud:

for (long i = 1; i <= postCount; i++) { entityManager.persist( new Post() .setId(i) .setTitle( String.format( "High-Performance Java Persistence, review no. %1$d", i ) ) );}

for at aktivere jdbc-batchindsatser skal vi bare levere en enkelt konfigurationsegenskab:

<property name="hibernate.jdbc.batch_size" value="50"/>

når denne egenskab er angivet, kan Hibernate automatisk skifte fra ikke-batching til batching uden at behøve nogen dataadgangskodeændring.

og for at hente de første 10 post rækker kan vi udføre følgende:

int maxResults = 10;List<Post> posts = entityManager.createQuery(""" select p from post p order by p.id """, Post.class).setMaxResults(maxResults).getResultList();

hvis du sammenligner dette med JDBC-versionen, vil du se, at JPA er meget lettere at bruge.

fordele og ulemper ved at bruge JPA og Hibernate

JPA, generelt, og Hibernate, i særdeleshed, tilbyder mange fordele.

• du kan hente enheder eller Dto ‘ er. Du kan endda hente hierarkisk forældre-barn DTO projektion.
• du kan aktivere jdbc-batching uden at ændre dataadgangskoden.
• du har støtte til optimistisk låsning.
• du har en pessimistisk låseabstraktion, der er uafhængig af den underliggende databasespecifikke syntaks, så du kan erhverve en læse-og SKRIVELÅS eller endda en SPRINGLÅS.
• du har en database-uafhængig pagination API.
• du kan angive en List af værdier til en in-forespørgselsklausul, som forklaret i denne artikel.
• du kan bruge en stærkt konsistent cachelagringsløsning, der giver dig mulighed for at aflaste den primære node, som for rea-skrive-transaktioner kun kan kaldes lodret.
• du har indbygget support til revisionslogning via Hibernate Envers.
• du har indbygget understøttelse af multitenancy.
• du kan generere et indledende skemascript fra enhedens tilknytninger ved hjælp af Hibernate hbm2ddl-værktøjet, som du kan levere til et automatisk skemaoverførselsværktøj, f.eks.
• ikke kun at du har frihed til at udføre en oprindelig forespørgsel, men du kan også bruge formateringen til at omdanne JDBC ResultSet til JPA-enheder eller Dto ‘ er.

ulemperne ved at bruge JPA og Hibernate er følgende:

• selvom det er meget nemt at komme i gang med JPA, kræver det en betydelig tidsinvestering at blive ekspert, fordi du udover at læse sin manual stadig skal lære, hvordan databasesystemer fungerer, standardstandarden og den specifikke smag, der bruges af din projektrelationsdatabase.
• der er nogle mindre intuitive adfærd, der kan overraske begyndere, som flush operation order.
• kriterierne API er temmelig verbose, så du skal bruge et værktøj som Codota til at skrive dynamiske forespørgsler lettere.

det samlede samfund og populære integrationer

JPA og Hibernate er ekstremt populære. Ifølge 2018 Java ecosystem report af Snyk bruges Hibernate af 54% af hver Java-udvikler, der interagerer med en relationsdatabase.

dette resultat kan bakkes op af Google Trends. Hvis vi f.eks. sammenligner Google ‘ s tendenser i forhold til dens vigtigste konkurrenter, kan vi se, at JPA er mange gange mere populær og ikke viser tegn på at miste sin dominerende markedsandelsposition.

at være så populær giver mange fordele, som:

• Spring Data JPA integration fungerer som en charme. Faktisk er en af de største grunde til, at JPA og Hibernate er så populære, fordi Spring Boot bruger Spring Data JPA, som igen bruger Hibernate bag kulisserne.
• hvis du har noget problem, er der en god chance for, at disse 30k Hibernate-relaterede Stackoverløbssvar og 16K JPA-relaterede Stackoverløbssvar giver dig en løsning.
• der er 73K Hibernate tutorials tilgængelige. Kun min side alene tilbyder over 250 JPA-og Hibernate-tutorials, der lærer dig, hvordan du får mest muligt ud af JPA og Hibernate.
• der er mange videokurser, du også kan bruge, som mit højtydende Java Persistens video kursus.
• der er over 300 bøger om Hibernate på , hvoraf den ene er min højtydende Java Persistensbog også.

JPA-alternativer

en af de største ting ved Java-økosystemet er overflod af rammer af høj kvalitet. Hvis JPA og Hibernate ikke passer godt til din brugssag, kan du bruge en af følgende rammer:

• MyBatis, som er en meget let ramme for forespørgsel mapper.
• forespørgsler, som giver dig mulighed for at opbygge forespørgsler dynamisk.
• Jook, som giver en Java-metamodel til de underliggende tabeller, lagrede procedurer og funktioner og giver dig mulighed for at opbygge en KVKL-forespørgsel dynamisk ved hjælp af en meget intuitiv DSL og på en typesikker måde.

så brug det, der fungerer bedst for dig.

online værksteder

hvis du nød denne artikel, vil jeg vædde på, at du vil elske min kommende 4-dages 4 timers højtydende Java Persistens online værksted

konklusion

i denne artikel så vi, hvorfor JPA blev oprettet, og hvornår du skulle bruge den. Mens JPA bringer mange fordele, har du mange andre alternativer af høj kvalitet at bruge, hvis JPA og Hibernate ikke fungerer bedst til dine nuværende applikationskrav.

og nogle gange, som jeg forklarede i denne gratis prøve af min højtydende Java Persistensbog, behøver du ikke engang at vælge mellem JPA eller andre rammer. Du kan nemt kombinere JPA med en ramme som Jook for at få det bedste fra begge verdener.