Spring Data JPA — From Object to Table

Notebook Summary#

Copy this into a notebook. Everything here is unpacked in the Detailed Notes below.

Detailed Study Notes#

You've been handed the backend for BuyBuddy, a small e-commerce app. It has to remember customers, products, and orders long after the server restarts, so all of it lives in a MySQL database. The instinct is to open an editor and start writing SQL: INSERT INTO customer…, then the code to open a connection, run the statement, read the result set row by row, close everything, map each column back into a Java field, and repeat that for every table and every operation. Do this for Customer, Product, and Order, times create/read/update/delete, and most of your codebase becomes plumbing that has nothing to do with e-commerce. Spring Data JPA exists to delete that plumbing.

2.1 · The stack, who does what#

The database access ecosystem is a stack of layers, each one thinner and more convenient than the one below it. The confusion this lesson exists to clear up is that "Spring Data JPA," "JPA," and "Hibernate" get used as if they mean the same thing. They don't; they sit at different heights in the same tower.

• Spring Data Framework (the Spring Data family) — the parent project. It's an umbrella of sub-frameworks, each implementing a Data Access Layer for one kind of database.
• Spring Data JPA — the family member for relational databases. It gives you high-level repository interfaces and removes the boilerplate.
• JPA (Java Persistence API) — a specification: a contract describing how Java objects should map to database rows. It defines behaviour but implements none of it. Think of it as an interface.
• ORM (Object-Relational Mapping) — the general technique of translating between objects and relational tables. Write an Employee class, get an employee table.
• Hibernate — the most popular ORM framework, and here the JPA provider: the concrete class that implements the JPA interface and does the real mapping.
• JDBC — the low-level Java API that sends SQL to the database and reads results. Hibernate uses JDBC under the hood.

2.2 · Wiring MySQL to Spring Boot#

Before any entities exist, the application needs to know which database to talk to and how to log in. That configuration lives in application.properties. Spring Boot reads it at startup and hands the connection details to Hibernate.

spring.application.name=buy-buddy-backend

spring.datasource.url=jdbc:mysql://localhost:3306/buybuddy_mysql_db
spring.datasource.username=root
spring.datasource.password=rootpassword

# How Hibernate handles DDL (table creation / alteration)
spring.jpa.hibernate.ddl-auto=update

The ddl-auto=update line is the one that feels magical: on startup, Hibernate inspects your entity classes and creates or alters the matching tables to fit. You get schema management for free, driven by your Java code.

mysql -u root -p
CREATE DATABASE buybuddy_mysql_db;

Then run the app with ./gradlew bootrun. The distinction to hold onto: you create the empty database; Hibernate fills it with tables.

2.3 · Entities, turning a class into a table#

An entity is an ordinary Java class that you've marked so JPA will store its objects as rows in a table. You describe the mapping with annotations, and the ORM does the translation both ways: your object becomes an INSERT, and a row you read back becomes an object.

The core annotations#

package com.example.buy_buddy_backend;

import javax.persistence.*;

@Entity
@Table(name = "customer")
public class Customer {

    @Id
    @GeneratedValue
    private Long id;

    @Column(name = "customer_name")
    private String name;

    private String email;   // no annotation -> column "email"
}

Notice email has no annotation and still becomes a column named email: annotations are for overriding defaults, not for switching mapping on. The one you almost always want explicitly is @Id, because every table needs a primary key.

2.4 · Mapping relationships#

A relationship is a connection between two tables that says how their rows relate. Relationships are how you organize data without repeating it: instead of copying a customer's details onto every order, an order just points back to one customer.

There are three shapes, and picking the right one is the whole game:

Mapping BuyBuddy's requirements onto these shapes:

• "A customer can place many orders" → Customer to Order is One-to-Many (and Order to Customer is Many-to-One, the mirror image).
• "An order contains many products and a product appears in many orders" → Order to Product is Many-to-Many, which needs a junction table linking the two.

The relationship annotations#

Two more you'll see in the entity code: @JoinColumn names the foreign-key column in a relationship, and on the many-to-many, a join annotation names the columns pointing into the junction table. The deck also notes Lombok annotations (like @Getter/@Setter) generate the getters and setters so the entity class stays short. [+]

2.5 · Repositories, database access with no code#

A repository is an interface that gives you CRUD operations for one entity, and Spring writes the implementation for you. This is the payoff of the whole framework: you declare what you want, never how.

You get a repository by writing an interface that extends JpaRepository, parameterized with the entity type and its ID type:

import org.springframework.data.jpa.repository.JpaRepository;

public interface CustomerRepository extends JpaRepository<Customer, Long> {

    // Custom query, no body needed.
    // Spring parses the method name into a query.
    Customer findByEmail(String email);
}

That's the entire file. No class, no SQL, no connection handling. By extending JpaRepository<Customer, Long> you inherit save, findById, findAll, delete, and more. The <Customer, Long> pair tells Spring which entity and which primary-key type it's working with.

the request path through a Spring Boot app

2.6 · CRUD operations in practice#

CRUD is the four things you ever do to stored data: Create, Read, Update, Delete. Spring Data JPA ships ready-made methods for all four, so a whole service method is often one line.

// Create (C)
User user = new User("John", "john.doe@example.com");
userRepository.save(user);

// Read (R)
Optional<User> found = userRepository.findById(1L);
List<User> allUsers = userRepository.findAll();

// Update (U): load, mutate, save again
User user = userRepository.findById(1L).get();
user.setEmail("new.email@example.com");
userRepository.save(user);

// Delete (D)
userRepository.deleteById(1L);

Tying it together, the deck's Postman demo posts a customer, two products, then an order referencing them by id ({"customerId": 1, "productIds": [1, 2]}), and the request travels Controller → Service → Repository → Database. That single POST exercises the M:N mapping, the repository layer, and a save in one shot.

2.7 · Interview & Practice Q&A#

2.8 · Key Takeaways#

• One stack, distinct roles: Spring Data JPA (convenience) → JPA (spec) → Hibernate (provider) → JDBC (SQL) → MySQL.
• Entities are annotated plain classes. @Entity + @Id is the minimum; other annotations only override defaults.
• Relationships come from the requirements. Many on both sides = M:N + junction table; one-to-many otherwise.
• Repositories are empty interfaces. Extend JpaRepository<E, Id> and Spring generates the code, including derived query methods from method names.
• CRUD is one-liners. save covers both create and update; findById returns an Optional; the request flows Controller → Service → Repository → DB.

Microexercises#

You can recognise these annotations now. These drills prove you can write them. Attempt each before opening the walkthrough.

3.1 · Build the Order entity and its repository#

package com.example.buy_buddy_backend.model;

import javax.persistence.*;
import java.util.List;

@Entity
@Table(name = "orders")   // "order" is a reserved SQL word
public class Order {

    @Id
    @GeneratedValue
    private Long id;

    @ManyToOne
    @JoinColumn(name = "customer_id")
    private Customer customer;

    @ManyToMany
    @JoinTable(name = "order_product", joinColumns = @JoinColumn(name = "order_id"), inverseJoinColumns = @JoinColumn(name = "product_id"))
    private List<Product> products;
}

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;

public interface OrderRepository extends JpaRepository<Order, Long> {

    // Derived query: SELECT * FROM orders WHERE customer_id = ?
    List<Order> findByCustomerId(Long customerId);
}

3.2 · Diagnose the broken update#

public Customer updateEmail(Long id, String newEmail) {
    Customer c = customerRepository.findById(id).get();
    Customer updated = new Customer();
    updated.setEmail(newEmail);
    return customerRepository.save(updated);
}

public Customer updateEmail(Long id, String newEmail) {
    Customer c = customerRepository.findById(id).orElseThrow(() -> new RuntimeException("Customer not found: " + id));
    c.setEmail(newEmail);          // mutate the loaded entity
    return customerRepository.save(c);  // has an id -> UPDATE
}

Built from the JAVA-301 Session 4 deck (44 slides). No separate voice transcript was provided, so scope follows the full deck. Items marked [+] are added context beyond the slides; none change the taught material.