Spring Boot 4-microservices en REST-API's · Les

Inleiding tot Spring Data JPA

Krijg inzicht in de voordelen van Spring Data JPA en maak een databaseverbinding voor uw applicatie.

Les 2 van 611 stappen

Inleiding tot Spring Data JPA is een gratis Spring Boot 4-microservices en REST-API's-les op CoddyKit. Dit is les 2 van 6. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Spring Boot 4-microservices en REST-API's. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Spring Boot 4-microservices en REST-API's bevat in totaal 6 lessen.

Wat is persistentie van gegevens?

Stel je een applicatie voor die gebruikersvoorkeuren, productgegevens of blogberichten moet onthouden. Als deze gegevens telkens verdwijnen wanneer de app wordt gesloten, is de app niet erg nuttig!

Persistentie van gegevens is het vermogen van een applicatie om gegevens permanent op te slaan. Dit betekent dat de gegevens behouden blijven, zelfs nadat de applicatie is gestopt of het apparaat is uitgeschakeld. Databases zijn de meest gebruikte hulpmiddelen om dit te bereiken.

Interactie tussen Java en databases

In Java gebeurt interactie met databases traditioneel via JDBC (Java Database Connectivity), een API op laag niveau. Hoewel deze krachtig is, kan de code behoorlijk uitgebreid zijn.

Om dit eenvoudiger te maken, is de standaard JPA (Java Persistence API) ontstaan. JPA biedt een aanpak met ORM (Object-Relational Mapping), waarmee je met databasetabellen kunt werken via gewone Java-objecten. Zo is er minder directe interactie met SQL nodig.

Maak kennis met Spring Data JPA!

Spring Data JPA is een krachtige module binnen het grotere Spring Data-project. De module bouwt voort op de JPA-standaard om databasetoegang in Spring-applicaties nog eenvoudiger en efficiënter te maken.

Het belangrijkste doel is om de standaardcode die nodig is voor veelvoorkomende bewerkingen voor gegevenstoegang aanzienlijk te verminderen, zodat je je kunt richten op de bedrijfslogica van je applicatie.

Waarom Spring Data JPA geweldig is

Spring Data JPA biedt verschillende aantrekkelijke voordelen:

Minder standaardcode: Je hoeft geen basismethoden voor CRUD (Create, Read, Update, Delete) te schrijven.
Automatische generatie van query's: Definieer methodenamen (bijvoorbeeld findByEmail) en Spring Data JPA genereert automatisch de SQL-query.
Naadloze integratie met Spring: Het integreert perfect met andere Spring-functies, zoals dependency-injectie en transactiebeheer.
Ondersteuning voor verschillende databases: Werkt met populaire relationele databases, zoals H2, MySQL, PostgreSQL en Oracle.

Essentiële afhankelijkheden

Om Spring Data JPA in een Spring Boot-project te gebruiken, moet je specifieke afhankelijkheden toevoegen aan je pom.xml (voor Maven) of build.gradle (voor Gradle).

De twee belangrijkste die we voor een basisconfiguratie gebruiken zijn:

spring-boot-starter-data-jpa: Dit is de kernafhankelijkheid. Deze brengt JPA, Hibernate (de standaardimplementatie van JPA) en Spring Data JPA zelf binnen.
h2: Een database in het geheugen. Deze is uitstekend geschikt voor ontwikkeling en tests, omdat hij lichtgewicht en eenvoudig in te stellen is zonder een afzonderlijke databaseserver.

`pom.xml` configureren

Zo voeg je deze afhankelijkheden meestal toe aan je pom.xml-bestand. De spring-boot-starter-parent beheert de versies voor je.

Let op <scope>runtime</scope> voor H2. Dit betekent dat H2 tijdens de uitvoering nodig is, maar niet voor het compileren van je code.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.5</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <groupId>com.coddykit</groupId>
  <artifactId>jpa-intro</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>jpa-intro</name>
  <description>Intro to Spring Data JPA</description>
  <properties>
    <java.version>17</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

Automatische configuratie van de databaseverbinding

Een van de handigste functies van Spring Boot is automatische configuratie. Wanneer Spring Boot spring-boot-starter-data-jpa en een databasestuurprogramma (zoals H2) op het classpath vindt, configureert het automatisch een DataSource.

Een DataSource bepaalt in feite hoe je applicatie verbinding maakt met de database. Daardoor hoef je vaak niet zelf code te schrijven voor verbindingspools of de databaseconfiguratie; Spring Boot regelt verstandige standaardinstellingen voor je.

`application.properties` voor H2

Hoewel automatische configuratie handig is, wil je de database-instellingen vaak aanpassen. Dit doe je meestal in bestanden als application.properties of application.yml.

Zo configureer je een H2-database in het geheugen en schakel je de ingebouwde webconsole in. Die is erg handig om tijdens de ontwikkeling de inhoud van je database te bekijken:

spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

Onze eerste Spring Boot-app

Nu de benodigde afhankelijkheden en databaseconfiguratie aanwezig zijn, kan onze Spring Boot-applicatie worden gestart en verbinding maken met de H2-database. Deze eenvoudige klasse start de applicatie.

Na het uitvoeren kun je de H2-console meestal openen via http://localhost:8080/h2-console met de hierboven geconfigureerde inloggegevens.

package com.coddykit.jpaintro;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class JpaIntroApplication {

  public static void main(String[] args) {
    SpringApplication.run(JpaIntroApplication.class, args);
    System.out.println("Spring Boot application started with H2 database!");
    // The application will keep running until manually stopped.
    // If h2 console is enabled, you can visit:
    // http://localhost:8080/h2-console
    // Use JDBC URL: jdbc:h2:mem:testdb, User: sa, Password: password
  }
}

Korte controle: kernafhankelijkheid

Welke van de volgende afhankelijkheden is voornamelijk verantwoordelijk voor het toevoegen van Spring Data JPA en de onderliggende JPA-implementatie (zoals Hibernate) aan een Spring Boot-project?

Beantwoord dit in de interactieve les

Samenvatting: kennismaking met Spring Data JPA

Goed gedaan! In deze les heb je je eerste stappen gezet op het gebied van persistentie van gegevens met Spring Boot.

We hebben begrepen waarom persistentie van gegevens cruciaal is voor applicaties.
We hebben Spring Data JPA geïntroduceerd als een krachtig hulpmiddel om database-interacties te vereenvoudigen.
Je hebt geleerd over het toevoegen van essentiële afhankelijkheden, zoals spring-boot-starter-data-jpa en h2.
We hebben onze H2-database in het geheugen geconfigureerd met application.properties en gezien hoe Spring Boot de DataSource automatisch configureert.
Tot slot heb je een eenvoudige Spring Boot-applicatie uitgevoerd met H2 klaar voor gebruik!

Vervolgens gaan we dieper in op het definiëren van entiteiten en repositories om echt met onze database te kunnen werken!

Gratis beginnen

Leer Java met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 24
Lessen: 93

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Inleiding tot Spring Data JPA” gratis?

Ja — de volledige tekst van “Inleiding tot Spring Data JPA” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Spring Boot 4-microservices en REST-API's wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Spring Boot 4-microservices en REST-API's bevat in totaal 6 lessen.

Wat leer ik in “Inleiding tot Spring Data JPA”?

Krijg inzicht in de voordelen van Spring Data JPA en maak een databaseverbinding voor uw applicatie. Je oefent met Spring Boot 4-microservices en REST-API's door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Spring Boot 4-microservices en REST-API's te beginnen?

Ervaring vooraf is niet nodig. Spring Boot 4-microservices en REST-API's op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 6.

Hoe lang duurt de les “Inleiding tot Spring Data JPA”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Spring Boot 4-microservices en REST-API's?

Ja. Elke les over Spring Boot 4-microservices en REST-API's bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Spring Boot 4-microservices en REST-API's