I föregående kapitel gick vi igenom vad JPA och Hibernate är. I detta kapitel kommer vi att integrera en databas i vår applikation och försöka utföra CRUD-operationer (Create, Read, Update, Delete).

Exempel på arbete med en databas:

Modellanpassning

Det första vi behöver göra är att annotera modellen så att Hibernate kan arbeta med den och förstå vilken tabell den tillhör.

I @Entity(name = "books")-annoteringen gör parametern name det möjligt att ange namnet på entiteten, vilket standardmässigt är klassens namn.

Annoteringen @Table används för att ange specifika inställningar för tabellen som är kopplad till entiteten.

I vårt fall skapas denna tabell genom migrationer, så vi behöver inte skapa den manuellt.

Vi behöver också att vår entitet automatiskt genererar ett ID för att tilldela det ett unikt värde i databasen. För att uppnå detta kan vi använda annoteringen @Id på fältet som representerar vårt ID, tillsammans med annoteringen @GeneratedValue.

@Id
@GeneratedValue(strategy = GenerationType.UUID)
private String id;

Annotationerna @Id och @GeneratedValue(strategy = GenerationType.UUID) anger att id-fältet är en primärnyckel som genereras automatiskt i UUID-format.

Detta säkerställer unika strängidentifierare för varje post i tabellen, vilket är fördelaktigt för distribuerade system och garanterar global unikhet för identifierarna. UUID lagras som strängar.

Lägga till Repository

För närvarande simulerar vårt repository en databas genom att lagra alla entiteter i en List. Men tänk om jag berättade att det faktiskt är mycket enklare att använda en riktig databas!

För att interagera med en riktig databas kan vi använda JpaRepository-gränssnittet, som tillhandahåller ett brett utbud av inbyggda metoder för att arbeta med data.

I JpaRepository<Book, String> skickar vi två parametrar: Book, som representerar entitetstypen som repositoryt kommer att arbeta med, och String, som är datatypen för primärnyckeln (ID) för Book-entiteten.

Och det är allt vi behöver! Nu har vi ett fullt fungerande repository!

JpaRepository Huvudmetoder

Skapa anpassade SQL-frågor

Spring Data JPA kan automatiskt generera frågor om metoden namnges enligt ett mönster som överensstämmer med datastrukturen. Detta görs med hjälp av specifika nyckelord som anger hur frågan ska konstrueras.

Kort sammanfattning av videon

List<Book> findBookByAuthor(String author);

Denna metod genererar automatiskt en SQL-fråga som söker efter alla böcker av den angivna author. Den genererade frågan kommer att se ut så här:

SELECT * FROM book WHERE author = ?;

Hur det fungerar

Metodnamnet findBookByAuthor(String author) är konstruerat enligt följande: det börjar med prefixet findBook, vilket indikerar att metoden utför en sökning. Därefter följer ByAuthor, vilket representerar fältet i Book-entiteten som kommer att användas för sökningen.

När denna metod anropas genererar Spring Data JPA automatiskt en fråga som söker efter poster där fältet author matchar den angivna parametern.

Generera SQL-frågor med @Query

Annoteringen @Query i Spring Data JPA gör det möjligt att använda både JPQL och inbyggd SQL, vilket ger flexibilitet i valet av lämplig metod.

JPQL

JPQL (Java Persistence Query Language) fungerar med objekt och deras egenskaper.

@Query("SELECT b FROM book b WHERE b.author = :author")
List<Book> findBookByAuthor(String author);

Denna fråga söker efter alla Book-objekt där fältet author motsvarar det angivna värdet. JPQL är mer abstrakt och speglar datamodellens struktur.

Native SQL

Native SQL interagerar direkt med databas-tabeller.

@Query(value = "SELECT * FROM books WHERE author = :author", nativeQuery = true)
List<Book> findBookByAuthor(String author);

I detta fall arbetar frågan på book table, vilket möjliggör användning av specifika SQL-funktioner och optimeringar.

Välja en metod

Om du behöver en enkel fråga som överensstämmer med datamodellen, använd JPQL. Om en komplex fråga eller databasspecifika funktioner krävs, välj native SQL.

Därför ger @Query flexibilitet att enkelt växla mellan de två metoderna beroende på behov.