ORM, Entities, and Basic Mapping

Your Spring Boot API stores its data in an in-memory Map: everything disappears on restart. You need a relational database (PostgreSQL, MySQL…). Writing SQL by hand for every object is long and repetitive: an ORM (Object-Relational Mapping) bridges your Java classes and the tables.

• JPA (Jakarta Persistence, package jakarta.persistence) is the standard specification: annotations and interfaces.
• Hibernate is the most widely used implementation, and the one Spring Boot configures by default. This course uses Spring Boot 4.1 with Java 25: Hibernate 7 implements Jakarta Persistence 3.2 there.
• Spring Data JPA adds automatically generated repositories on top (lesson 2).

Configuration

Add spring-boot-starter-data-jpa, its test starter spring-boot-starter-data-jpa-test (test scope, for @DataJpaTest, lesson 5), and your database driver (org.postgresql:postgresql, or com.h2database:h2 for an in-memory test database). Spring Initializr adds these dependencies when you choose Spring Data JPA and H2 (-d dependencies=web,data-jpa,h2). Then, in application.properties:

spring.datasource.url=jdbc:postgresql://localhost:5432/boutique
spring.datasource.username=boutique
spring.datasource.password=${DB_PASSWORD}
spring.jpa.hibernate.ddl-auto=update     # create-drop, update, validate, none
spring.jpa.show-sql=true                 # shows the generated SQL (development)
spring.jpa.open-in-view=false            # recommended, see lesson 4

ddl-auto controls schema generation: create-drop (recreated at every startup), update (adds what is missing), validate (checks without modifying), none. In production, use validate or none and versioned migrations (lesson 5).

A first entity

package fr.boutique.produit;

import jakarta.persistence.*;
import java.math.BigDecimal;
import java.time.LocalDateTime;

@Entity                                  // persistent class
@Table(name = "produit")                 // optional: explicit table name
public class Produit {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // id generated by the database
    private Long id;

    @Column(nullable = false, length = 100)
    private String nom;

    @Column(nullable = false, precision = 10, scale = 2)
    private BigDecimal prix;             // never use double for money

    @Enumerated(EnumType.STRING)         // stores "ACTIF", not 0
    private StatutProduit statut = StatutProduit.ACTIF;

    private LocalDateTime dateCreation;  // column date_creation

    protected Produit() { }              // required by JPA

    public Produit(String nom, BigDecimal prix) {
        this.nom = nom;
        this.prix = prix;
        this.dateCreation = LocalDateTime.now();
    }

    public Long getId() { return id; }
    public String getNom() { return nom; }
    public void setNom(String nom) { this.nom = nom; }
    // other getters / setters...
}

enum StatutProduit { ACTIF, ARCHIVE }

Key points:

• JPA requires a no-argument constructor (at least protected) and a non-final class: Hibernate instantiates the object and then fills in the fields, and creates proxies for lazy loading. That is why a record cannot be an entity; it remains ideal for DTOs.
• The identifier is an object type (Long): null means “not yet saved”.
• @Enumerated(EnumType.STRING) is essential: with the default ORDINAL, inserting a value in the middle of the enum would silently corrupt existing data.

Naming and types

Spring Boot configures a naming strategy that converts camelCase to snake_case: dateCreation becomes date_creation, the class LigneCommande the table ligne_commande. Java types map to SQL types: Long → bigint, String → varchar(255) by default, BigDecimal → numeric, LocalDate → date, LocalDateTime → timestamp, boolean → boolean. Primitive types (int, boolean) produce not null columns.

With show-sql=true, look at the generated create table at startup: it is the best way to check your mapping.