logo

TechCodeview

Spring Boot JPA

Vad är JPA?

Spring Boot JPA är en Java-specifikation för hantering relationella data i Java-applikationer. Det tillåter oss att komma åt och bevara data mellan Java-objekt/klass och relationsdatabas. JPA följer Kartläggning av objektrelationer (ORM). Det är en uppsättning gränssnitt. Det ger också en körtid EntityManager API för bearbetning av frågor och transaktioner på objekten mot databasen. Den använder ett plattformsoberoende objektorienterat frågespråk JPQL (Java Persistent Query Language).

När det gäller uthållighet täcker det tre områden:

insättning sortera java
  • Java Persistence API
    • Objekt-relationellmetadata
  • Själva API:et, definierat i uthållighet paket

Den gemensamma parlamentariska församlingen är inte ett ramverk. Den definierar ett koncept som kan implementeras av vilket ramverk som helst.

Varför ska vi använda JPA?

JPA är enklare, renare och mindre arbetskrävande än JDBC, SQL och handskriven mappning. JPA är lämplig för icke-prestandaorienterade komplexa applikationer. Den största fördelen med JPA framför JDBC är att i JPA representeras data av objekt och klasser medan data i JDBC representeras av tabeller och poster. Den använder POJO för att representera beständiga data som förenklar databasprogrammering. Det finns några andra fördelar med JPA:

  • JPA undviker att skriva DDL på en databasspecifik dialekt av SQL. Istället för detta tillåter den mappning i XML eller med Java-anteckningar.
  • JPA låter oss undvika att skriva DML på den databasspecifika dialekten SQL.
  • JPA tillåter oss att spara och ladda Java-objekt och grafer utan något DML-språk alls.
  • När vi behöver utföra frågor JPQL tillåter det oss att uttrycka frågorna i termer av Java-entiteter snarare än den (native) SQL-tabellen och kolumnerna.

JPA-funktioner

Det finns följande funktioner i JPA:

  • Det är ett kraftfullt arkiv och anpassat objekt-mapping abstraktion.
  • Den stödjer för uthållighet mellan butiker . Det betyder att en enhet delvis kan lagras i MySQL och Neo4j (Graph Database Management System).
  • Det genererar dynamiskt frågor från frågemetodens namn.
  • Domänbasklasserna tillhandahåller grundläggande egenskaper.
  • Det stöder transparent revision.
  • Möjlighet att integrera anpassad förvarskod.
  • Det är lätt att integrera med Spring Framework med det anpassade namnutrymmet.

JPA arkitektur

JPA är en källa för att lagra affärsenheter som relationsenheter. Den visar hur man definierar en POJO som en enhet och hur man hanterar entiteter med relation.

Följande figur beskriver JPA:s klassnivåarkitektur som beskriver kärnklasserna och gränssnitten för JPA som definieras i javax uthållighet paket. JPA-arkitekturen innehåller följande enheter:

    Uthållighet:Det är en klass som innehåller statiska metoder för att få en EntityManagerFactory-instans.EntityManagerFactory:Det är en fabriksklass av EntityManager. Den skapar och hanterar flera instanser av EntityManager.EntityManager:Det är ett gränssnitt. Den kontrollerar beständighetsoperationerna på objekt. Det fungerar för Query-instansen.Entitet:Entiteterna är persistensobjekten som lagras som en post i databasen.Persistensenhet:Den definierar en uppsättning av alla entitetsklasser. I en applikation hanterar EntityManager-instanser den. Uppsättningen av entitetsklasser representerar data som finns i ett enda datalager.Enhetstransaktion:Den har en en till en relation med klassen EntityManager. För varje EntityManager underhålls verksamheten av EntityTransaction-klassen.Fråga:Det är ett gränssnitt som implementeras av varje JPA-leverantör för att erhålla relationsobjekt som uppfyller kriterierna.
Spring Boot jpa

JPA klassrelationer

Klasserna och gränssnitten som vi har diskuterat ovan upprätthåller en relation. Följande figur visar förhållandet mellan klasser och gränssnitt.

Spring Boot jpa
  • Relationen mellan EntityManager och EntiyTransaction är en till en . Det finns en EntityTransaction-instans för varje EntityManager-operation.
  • Relationen mellan EntityManageFactory och EntiyManager är en till många . Det är en fabriksklass till EntityManager-instansen.
  • Relationen mellan EntityManager och Query är en till många . Vi kan köra valfritt antal frågor genom att använda en instans av EntityManager-klassen.
  • Relationen mellan EntityManager och Entity är en till många . En EntityManager-instans kan hantera flera Entities.

JPA:s genomförande

JPA är ett API med öppen källkod. Det finns olika företagsleverantörer som Eclipse, RedHat, Oracle, etc. som tillhandahåller nya produkter genom att lägga till JPA i dem. Det finns några populära JPA-implementeringsramverk som t.ex Hibernate, EclipseLink, DataNucleus, etc. Det är också känt som Kartläggning av objektrelationer (ORM) verktyg.

Objektrelationsmappning (ORM)

I ORM kallas mappningen av Java-objekt till databastabeller och vice versa Objekt-relationell kartläggning. ORM-mappningen fungerar som en brygga mellan en relationsdatabas (tabeller och register) och Java-applikation (klasser och objekt).

I följande figur är ORM-lagret ett adapterlager. Den anpassar språket för objektgrafer till språket i SQL och relationstabeller.

Spring Boot jpa

ORM-lagret finns mellan applikationen och databasen. Den konverterar Java-klasserna och -objekten så att de kan lagras och hanteras i en relationsdatabas. Som standard blir namnet som kvarstår namnet på tabellen och fält blir kolumner. När en applikation väl har konfigurerats motsvarar varje tabellrad ett objekt.

JPA-versioner

Tidigare versioner av EJB definierar beständighetslagret kombinerat med affärslogikskiktet som använder javax.ejb.EntityBean Gränssnitt. EJB-specifikationen inkluderar definitionen av JPA.

När EJB 3.0 introducerades separerades persistensskiktet och specificerades som JPA 1.0 (Java Persistence API). Specifikationerna för detta API släpptes tillsammans med specifikationerna för JAVA EE5 den 11 maj 2006 med JSR 220.

2019 bytte JPA namn till Jakarta uthållighet . Den senaste versionen av JPA är 2.2 . Den stöder följande funktioner:

  • Java 8, data och tid API
  • CDI-injektion i AttributeConvertes
  • Det gör kommentarer @Repeatable

Skillnaden mellan JPA och Hibernate

JPA: JPA är en Java-specifikation som används för att komma åt, hantera och bevara data mellan Java-objekt och relationsdatabas. Det är en standardmetod för ORM.

Övervintra: Det är ett lätt ORM-verktyg med öppen källkod som används för att lagra Java-objekt i relationsdatabassystemet. Det är en leverantör av JPA. Den följer ett gemensamt tillvägagångssätt från den gemensamma parlamentariska församlingen.

Följande tabell beskriver skillnaderna mellan JPA och Hibernate.

java logotyp
JPA Övervintra
JPA är en Java-specifikation för kartläggning av relationsdata i Java-applikation. Hibernate är en ORM ramverk som handlar om datapersistens.
JPA tillhandahåller inga implementeringsklasser. Det ger implementeringsklasser.
Den använder plattformsoberoende frågespråk som kallas JPQL (Java Persistence Query Language). Den använder sitt eget frågespråk som heter HQL (Hibernate Query Language).
Det definieras i javax.persistence paket. Det definieras i org.hibernate paket.
Det är implementerat i olika ORM-verktyg som Hibernate, EclipseLink, etc. Hibernate är leverantör av PSD.
JPA använder EntityManager för att hantera datas beständighet. I Hibernate används Session för att hantera datas beständighet.

Spring Boot Starter Data JPA

Spring Boot ger startberoende spring-boot-starter-data-jpa för att effektivt koppla Spring Boot-applikationen med relationsdatabasen. Spring-boot-starter-data-jpa använder internt spring-boot-jpa-beroendet.

 org.springframework.boot spring-boot-starter-data-jpa 2.2.2.RELEASE

Spring Boot JPA Exempel

Låt oss skapa en Spring Boot-applikation som använder JPA för att ansluta till databasen. I följande exempel har vi använt in-memory databas Apache Derby.

Apache Derby: Det är en öppen källkod, inbäddad relationsdatabas implementerad helt i Java. Den är tillgänglig under Apache License 2.0. Det finns följande fördelar med Apache Derby:

  • Det är lätt att installera, distribuera och använda.
  • Den är baserad på Java-, JDBC- och SQL-standarder.
  • Den tillhandahåller en inbäddad JDBC-drivrutin som låter oss bädda in Derby i vilken Java-baserad lösning som helst.
  • Den stöder även klient/server-läge med Derby Network Client JDBC-drivrutinen och Derby Network Server.

Spring Boot kan automatiskt konfigurera en inbäddad databas som t.ex H2, HSQL, och Derbydatabaser . Vi behöver inte tillhandahålla några anslutningsadresser. Vi behöver bara inkludera ett byggberoende på den inbäddade databasen som vi vill använda.

I Spring Boot kan vi enkelt integrera Apache Derby-databasen bara genom att lägga till Derby beroende i filen pom.xml.

 org.apache.derby derby runtime

Steg 1: Open Spring Initializr https://start.spring.io/ .

Steg 2: Välj den senaste versionen av Spring Boot 2.3.0 (SNAPSHOT)

Steg 3: Tillhandahålla Grupp namn. Vi har tillhandahållit com.javatpoint.

Steg 4: Tillhandahålla Artefakt Id. Vi har tillhandahållit apache-derby-exempel .

Steg 5: Lägg till beroenden: Spring Web, Spring Data JPA, och Apache Derby Database .

arraylist i java

Steg 6: Klicka på Generera knapp. När vi klickar på knappen Generera lindar den in projektet i en Jar-fil och laddar ner den till det lokala systemet.

Spring Boot jpa

Steg 7: Extrahera Jar-filen och klistra in den i STS-arbetsytan.

Steg 8: Importera projektmappen till STS.

Arkiv -> Importera -> Befintliga Maven-projekt -> Bläddra -> Välj mappen apache-derby-exempel -> Slutför

Det tar lite tid att importera.

Steg 9: Skapa ett paket med namnet com.javatpoint.model i mappen src/main/java.

Steg 10: Skapa en klass med namnet UserRecord i paketet com.javatpoint.model och gör följande:

  • Definiera tre variabler id, namn, och e-post .
  • Generera Getters och Setter.
    Högerklicka på filen -> Källa -> Generera Getters och Setters
  • Definiera en standardkonstruktor.
  • Markera klassen som en Entitet genom att använda anteckningen @Entitet.
  • Mark Id som primärnyckel genom att använda anteckningen @Id.

UserRecord.java 

 package com.javatpoint.model; import javax.persistence.Entity; import javax.persistence.Id; @Entity public class UserRecord { @Id private int id; private String name; private String email; //default conatructor public UserRecord() { } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } }

Steg 11: Skapa ett paket med namnet com.javatpoint.controller i mappen src/main/java.

jdbc jdbc

Steg 12: Skapa en Controller-klass med namnet UserController i paketet com.javatpoint.controller och gör följande:

  • Markera klassen som en kontrollant genom att använda anteckningen @RestController.
  • Autowired klassen Användarservice genom att använda anteckningen @Autowired .
  • Vi har definierat två mappningar, en för få alla användare och den andra för Lägg till användare.

UserController.java 

 package com.javatpoint.controller; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; import com.javatpoint.model.UserRecord; import com.javatpoint.service.UserService; import java.util.List; @RestController public class UserController { @Autowired private UserService userService; @RequestMapping('/') public List getAllUser() { return userService.getAllUsers(); } @RequestMapping(value='/add-user', method=RequestMethod.POST) public void addUser(@RequestBody UserRecord userRecord) { userService.addUser(userRecord); } }

Steg 13: Skapa ett paket med namnet com.javatpoint.service i mappen src/main/java.

Steg 14: Skapa en serviceklass med namnet Användarservice i paketet com.javatpoint.service och gör följande:

  • Markera klassen som tjänst genom att använda anteckningen @Service.
  • Autowired till UserRepository
  • Definiera en metod getAllUsers() som returnerar en lista över
  • Definiera ett annat metodnamn Lägg till användare() som sparar användarposten.

UserService.java 

 package com.javatpoint.service; import java.util.List; import java.util.ArrayList; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import com.javatpoint.model.UserRecord; import com.javatpoint.repository.UserRepository; @Service public class UserService { @Autowired private UserRepository userRepository; public List getAllUsers() { ListuserRecords = new ArrayList(); userRepository.findAll().forEach(userRecords::add); return userRecords; } public void addUser(UserRecord userRecord) { userRepository.save(userRecord); } }

Steg 15: Skapa ett paket med namnet com.javatpoint.repository i mappen src/main/java.

Steg 16: Skapa ett förvarsgränssnitt med namnet UserRepository i paketet com.javatpoint.repository och sträcker sig CrudRepository .

UserRepository.java

namnkonvention för java 
 package com.javatpoint.repository; import org.springframework.data.repository.CrudRepository; import com.javatpoint.model.UserRecord; public interface UserRepository extends CrudRepository { }

Steg 17: Öppna nu ApacheDerbyExampleApplication.java fil. Det skapas som standard när vi konfigurerar en applikation.

ApacheDerbyExampleApplication.java 

 package com.javatpoint; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class ApacheDerbyExampleApplication { public static void main(String[] args) { SpringApplication.run(ApacheDerbyExampleApplication.class, args); } }

Nu har vi ställt in alla nödvändiga klasser och paket enligt kraven. Observera att vi inte har tillhandahållit några anslutnings-URL för databasen. Efter att ha slutfört alla ovanstående steg ser projektkatalogen ut så här:

Spring Boot jpa

Låt oss köra programmet.

Steg 18: Öppna ApacheDerbyExampleApplication.java fil och kör den som Java Application.

Steg 19: Öppna webbläsaren och anropa URL:en http://localhost:8080/. Det returnerar en tom lista eftersom vi inte har lagt till någon användare i listan.

För att lägga till en användare i databasen skickar vi en POSTA begära genom att använda Brevbärare .

Steg 20: Öppna Brevbärare och gör följande:

  • Välj POSTA
  • Anropa URL:en http://localhost:8080/add-user.
  • Klicka på Kropp
  • Välj Innehållstyp som JSON (applikation/json).
  • Infoga data som vill infogas i databasen. Vi har infogat följande data:
 { 'id': '001', 'name': 'Tom', 'email': '[email protected]' }
  • Klicka på Skicka knapp.
Spring Boot jpa

När vi klickar på knappen Skicka visas det Status: 200 OK . Det betyder att begäran har genomförts.

Steg 21: Öppna webbläsaren och anropa URL:en http://localhost:8080. Den returnerar användaren som vi har infogat i databasen.

Spring Boot jpa
Ladda ner Apache-derbyexempelprojekt