Spring Boot Gradle Project CRUD Example

In this tutorial, we'll build a simple CRUD (Create, Read, Update, Delete) application using Spring Boot, Spring Data JPA, H2 and Gradle. 


Ensure you have the following installed:

  • Java Development Kit (JDK) 21: Download JDK
  • Gradle: Follow the installation steps for your operating system.

Verify your installations by running the following commands in your terminal:

java -version
gradle -v

Step 1: Initialize the Project

Create a new Spring Boot project using Spring Initializr:

  1. Visit Spring Initializr.
  2. Select the following options:
    • Project: Gradle Project
    • Language: Java
    • Spring Boot: 3.2.0 (or the latest stable version)
    • Project Metadata: Fill in Group, Artifact, Name, Description, and Package Name.
    • Packaging: Jar
    • Java: 21
  3. Add dependencies:
    • Spring Web
    • Spring Boot DevTools
    • Spring Data JPA
    • H2 Database (for in-memory database)
  4. Click on "Generate" to download the project zip file.
  5. Extract the zip file to your desired directory.

Navigate to the project directory:

cd <your-project-directory>

Step 2: Configure build.gradle

Open the build.gradle file and ensure it is configured correctly with the latest Spring Boot and dependency versions.

Example build.gradle

plugins {
    id 'org.springframework.boot' version '3.2.0'
    id 'io.spring.dependency-management' version '1.1.0'
    id 'java'

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '21'

repositories {

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'com.h2database:h2'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'

test {


  • plugins: Specifies the Gradle plugins used in the project. We're using the Spring Boot plugin, the Spring dependency management plugin, and the Java plugin.
  • group and version: Define the group ID and version of the project.
  • sourceCompatibility: Sets the Java version compatibility.
  • repositories: Specifies where to fetch the project dependencies from. mavenCentral is the central repository for Maven.
  • dependencies: Lists the project dependencies, including Spring Boot, Spring Data JPA, H2 database, and Spring Boot testing libraries.

Step 3: Create the Product Entity

Create a new Java class named Product.java in the src/main/java/com/example directory.

Example Product.java

package com.example;

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;

    public Product() {

    public Product(String name, Double price) {
        this.name = name;
        this.price = 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: Marks this class as a JPA entity.
  • @Id: Specifies the primary key of the entity.
  • @GeneratedValue: Indicates that the ID should be generated automatically.
  • Constructor: Includes a default constructor and a parameterized constructor.
  • Getters and Setters: Standard methods to access and modify the fields of the entity.

Step 4: Create the Repository Layer

Create a new Java interface named ProductRepository.java in the src/main/java/com/example directory.

Example ProductRepository.java

package com.example;

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

public interface ProductRepository extends JpaRepository<Product, Long> {


  • JpaRepository: This interface extends JpaRepository, providing CRUD operations for the Product entity. The generic parameters specify the entity type (Product) and the type of its primary key (Long).

Step 5: Create the Service Layer

Create a new Java class named ProductService.java in the src/main/java/com/example directory.

Example ProductService.java

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

public class ProductService {

    private final ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;

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

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

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

    public void deleteById(Long id) {


  • @Service: Marks this class as a service layer component.
  • ProductService: Provides methods to interact with the ProductRepository for CRUD operations.
  • Autowired: Injects the ProductRepository dependency.

Step 6: Create the Controller Layer

Create a new Java class named ProductController.java in the src/main/java/com/example directory.

Example ProductController.java

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

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

public class ProductController {

    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;

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

    public ResponseEntity<Product> getProductById(@PathVariable Long id) {
        Optional<Product> product = productService.findById(id);
        return product.map(ResponseEntity::ok)
                      .orElseGet(() -> ResponseEntity.status(HttpStatus.NOT_FOUND).build());

    public ResponseEntity<Product> createProduct(@RequestBody Product product) {
        Product savedProduct = productService.save(product);
        return ResponseEntity.status(HttpStatus.CREATED).body(savedProduct);

    public ResponseEntity<Product> updateProduct(@PathVariable Long id, @RequestBody Product product) {
        Optional<Product> existingProduct = productService.findById(id);
        if (existingProduct.isPresent()) {
            Product updatedProduct = productService.save(product);
            return ResponseEntity.ok(updatedProduct);
        } else {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();

    public ResponseEntity<Void> deleteProduct(@PathVariable Long id) {
        return ResponseEntity.status(HttpStatus.NO_CONTENT).build();


  • @RestController: Marks this class as a RESTful web service controller.
  • @RequestMapping: Maps HTTP requests to handler methods of the controller.
  • @GetMapping: Handles GET requests for retrieving products.
  • @PostMapping: Handles POST requests for creating a new product.
  • @PutMapping: Handles PUT requests for updating an existing product.
  • @DeleteMapping: Handles DELETE requests for deleting a product.

Step 7: Configure Application Properties

Open the src/main/resources/application.properties file and configure the H2 database settings.

Example application.properties



  • spring.datasource.url: URL for the H2 in-memory database.
  • spring.datasource.driverClassName: Driver class name for the H2 database.
  • spring.datasource.username: Username for the database connection.
  • spring.datasource.password: Password for the database connection.
  • spring.jpa.database-platform: Dialect for the H2 database.
  • spring.h2.console.enabled: Enables the H2 database console for debugging.

Step 8: Run the Application

Run the Spring Boot application using Gradle.

./gradlew bootRun

Step 9: Running the Application

To package the application as a JAR and run it, execute the following command:

./gradlew build
java -jar build/libs/<your-application-name>.jar

Replace <your-application-name> with the actual name of your JAR file.


  • ./gradlew bootRun: Runs the Spring Boot application using the Gradle wrapper.
  • ./gradlew build: Builds the Spring Boot application and packages it as a JAR file.
  • java -jar: Runs the packaged JAR file.

Testing the API

Use Postman to test the CRUD operations. Here are some example requests:

  • Create a Product (POST request to /api/products):

      "name": "Product1",
      "price": 100.0
  • Get All Products (GET request to /api/products)

  • Get a Product by ID (GET request to /api/products/{id})

  • Update a Product (PUT request to /api/products/{id}):

      "name": "Updated Product",
      "price": 150.0
  • Delete a Product (DELETE request to /api/products/{id})


In this tutorial, we have learned how to create a simple CRUD application using Spring Boot and Gradle. We covered the creation of the Product entity, repository, service, and controller layers. We also configured the H2 in-memory database and tested the application using Postman.