Spring Data JPA with MySQL: A Step-by-Step Tutorial

This tutorial will guide you through the process of setting up and using Spring Data JPA with MySQL in a Spring Boot application.


  • JDK 17 or later
  • MySQL Database
  • Maven or Gradle
  • IDE (IntelliJ IDEA, Eclipse, etc.)

Step 1: Set Up a Spring Boot Project

1.1 Create a New Spring Boot Project

Use Spring Initializr to create a new project with the following dependencies:

  • Spring Web
  • Spring Data JPA
  • MySQL Driver

Download and unzip the project, then open it in your IDE.

1.2 Configure application.properties

Set up the application properties for your project to connect to a MySQL database. This file is located in the src/main/resources directory.

# src/main/resources/application.properties

# MySQL Database configuration

# JPA configuration


  • Configures the connection to the MySQL database.
  • Enables SQL logging.
  • Sets up JPA to update the database schema automatically.
  • Specifies the Hibernate dialect for MySQL.

Step 2: Define the Entity Class

2.1 Create the Product Entity

Create an entity class to represent a product in the database.

package com.example.demo.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

public class Product {

    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;

    // Getters and setters
    public Long getId() {
        return id;

    public void setId(Long id) {
        this.id = id;

    public String getName() {
        return name;

    public void setName(String name) {
        this.name = name;

    public double getPrice() {
        return price;

    public void setPrice(double price) {
        this.price = price;


  • @Entity: Specifies that the class is an entity and is mapped to a database table.
  • @Id and @GeneratedValue: Indicates the primary key and its generation strategy.

Step 3: Create the Repository Interface

3.1 Create the ProductRepository

Create a repository interface to perform CRUD operations on the Product entity.

package com.example.demo.repository;

import com.example.demo.entity.Product;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

public interface ProductRepository extends JpaRepository<Product, Long> {


  • @Repository: Indicates that the interface is a Spring Data repository.
  • JpaRepository<Product, Long>: Provides CRUD operations for the Product entity.

Step 4: Create Service and Controller Layers

4.1 Create the ProductService

Create a service class to handle business logic related to products.

package com.example.demo.service;

import com.example.demo.entity.Product;
import com.example.demo.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

public class ProductService {

    private ProductRepository productRepository;

    public List<Product> getAllProducts() {
        return productRepository.findAll();

    public Optional<Product> getProductById(Long id) {
        return productRepository.findById(id);

    public Product createProduct(Product product) {
        return productRepository.save(product);

    public void deleteProduct(Long id) {


  • @Service: Marks the class as a service component in Spring.
  • ProductRepository: Injected to interact with the database.

4.2 Create the ProductController

Create a REST controller to expose endpoints for interacting with products.

package com.example.demo.controller;

import com.example.demo.entity.Product;
import com.example.demo.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

public class ProductController {

    private ProductService productService;

    public List<Product> getAllProducts() {
        return productService.getAllProducts();

    public Optional<Product> getProductById(@PathVariable Long id) {
        return productService.getProductById(id);

    public Product createProduct(@RequestBody Product product) {
        return productService.createProduct(product);

    public void deleteProduct(@PathVariable Long id) {


  • @RestController: Marks the class as a REST controller.
  • @RequestMapping("/products"): Maps the controller to /products endpoint.
  • @GetMapping, @PostMapping, @DeleteMapping: Maps HTTP GET, POST, and DELETE requests respectively.
  • @RequestBody: Binds the HTTP request body to the Product parameter.
  • @PathVariable: Binds the URI template variable to the method parameter.

Step 5: Running and Testing the Application

5.1 Run the Application

Run the Spring Boot application using your IDE or the command line:

./mvnw spring-boot:run

5.2 Test the Endpoints

Use a tool like Postman or your browser to test the endpoints.

Create a Product

  • URL: http://localhost:8080/products
  • Method: POST
  • Body:
        "name": "Sample Product",
        "price": 100.0

Get All Products

  • URL: http://localhost:8080/products
  • Method: GET

Get a Product by ID

  • URL: http://localhost:8080/products/{id}
  • Method: GET

Delete a Product

  • URL: http://localhost:8080/products/{id}
  • Method: DELETE


In this tutorial, you have learned how to configure and use Spring Data JPA with MySQL in a Spring Boot 3.2 application. We covered:

  • Setting up a Spring Boot project with Spring Data JPA and MySQL.
  • Defining an entity class and repository.
  • Creating service and controller layers.
  • Running and testing the application using REST endpoints.

By following these steps, you can effectively manage and interact with a MySQL database in your Spring Boot applications using Spring Data JPA.