Spring Boot CRUD Example with PostgreSQL

In this tutorial, we will create a Spring Boot CRUD (Create, Read, Update, Delete) application with a PostgreSQL database. We will cover setting up the project, configuring PostgreSQL, creating the necessary entities and repositories, implementing the service layer, and creating RESTful controllers to handle CRUD operations using a Product entity.


Before we start, ensure you have the following:

  • Java Development Kit (JDK) installed
  • Apache Maven installed
  • PostgreSQL installed and running
  • An IDE (such as IntelliJ IDEA, Eclipse, or VS Code) installed

Step 1: Setting Up the Project

1.1 Create a Spring Boot Project

  1. Open Spring Initializr:

  2. Configure Project Metadata:

    • Project: Maven Project
    • Language: Java
    • Spring Boot: Select the latest version of Spring Boot
    • Group: com.example
    • Artifact: spring-boot-postgresql-crud
    • Name: spring-boot-postgresql-crud
    • Description: Spring Boot CRUD example with PostgreSQL
    • Package Name: com.example.springbootpostgresqlcrud
    • Packaging: Jar
    • Java Version: 17 (or your preferred version)
    • Click Next.
  3. Select Dependencies:

    • On the Dependencies screen, select the dependencies you need. For a basic Spring Boot CRUD application, you can start with:
      • Spring Web
      • Spring Data JPA
      • PostgreSQL Driver
    • Click Next.
  4. Generate the Project:

    • Click Generate to download the project zip file.
    • Extract the zip file to your desired location.
  5. Open the Project in Your IDE:

    • Open your IDE and import the project as a Maven project.

1.2 Project Structure

After importing the project, you will see the following structure in your IDE:

├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── springbootpostgresqlcrud
│   │   │               ├── SpringBootPostgresqlCrudApplication.java
│   │   │               ├── controller
│   │   │               ├── model
│   │   │               ├── repository
│   │   │               └── service
│   ├── main
│   │   └── resources
│   │       ├── application.properties
│   └── test
│       └── java
│           └── com
│               └── example
│                   └── springbootpostgresqlcrud
│                       └── SpringBootPostgresqlCrudApplicationTests.java
└── pom.xml

Step 2: Configuring PostgreSQL

2.1 Create a PostgreSQL Database

  1. Open your PostgreSQL client (pgAdmin, command line, etc.).
  2. Create a new database named springbootdb:
    CREATE DATABASE springbootdb;

2.2 Configure Spring Boot to Use PostgreSQL

Open the application.properties file located in the src/main/resources directory and add the following configuration:

# PostgreSQL Database configuration

# JPA settings

Replace yourusername and yourpassword with your PostgreSQL credentials.

Step 3: Creating the Entity

3.1 Create the Product Entity

In the model package, create a new Java class named Product:

package com.example.springbootpostgresqlcrud.model;

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 String description;
    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 String getDescription() {
        return description;

    public void setDescription(String description) {
        this.description = description;

    public double getPrice() {
        return price;

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

Step 4: Creating the Repository

4.1 Create the ProductRepository Interface

In the repository package, create a new Java interface named ProductRepository:

package com.example.springbootpostgresqlcrud.repository;

import com.example.springbootpostgresqlcrud.model.Product;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

public interface ProductRepository extends JpaRepository<Product, Long> {

Step 5: Creating the Service

5.1 Create the ProductService Interface

In the service package, create a new Java interface named ProductService:

package com.example.springbootpostgresqlcrud.service;

import com.example.springbootpostgresqlcrud.model.Product;

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

public interface ProductService {
    List<Product> getAllProducts();
    Optional<Product> getProductById(Long id);
    Product saveProduct(Product product);
    Product updateProduct(Product product);
    void deleteProduct(Long id);

5.2 Implement the ProductService Interface

In the service package, create a new Java class named ProductServiceImpl:

package com.example.springbootpostgresqlcrud.service;

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

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

public class ProductServiceImpl implements ProductService {

    private ProductRepository productRepository;

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

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

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

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

    public void deleteProduct(Long id) {

Step 6: Creating the Controller

6.1 Create the ProductController Class

In the controller package, create a new Java class named ProductController:

package com.example.springbootpostgresqlcrud.controller;

import com.example.springbootpostgresqlcrud.model.Product;
import com.example.springbootpostgresqlcrud.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
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 ResponseEntity<Product> getProductById(@PathVariable Long id) {
        Optional<Product> product = productService.getProductById(id);
        return product.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());

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

    public ResponseEntity<Product> updateProduct(@PathVariable Long id, @RequestBody Product productDetails) {
        Optional<Product> productOptional = productService.getProductById(id);
        if (productOptional.isPresent()) {
            Product product = productOptional.get();
            return ResponseEntity.ok(productService.updateProduct(product));
        } else {
            return ResponseEntity.notFound().build();

    public ResponseEntity<Void> deleteProduct(@PathVariable Long id) {
        Optional<Product> product = productService.getProductById(id);
        if (product.isPresent()) {
            return ResponseEntity.noContent().build();
        } else {
            return ResponseEntity.notFound().build();

Step 7: Running the Application

  1. Run the Application:
    • Open the SpringBootPostgresqlCrudApplication class in the `src/main/java/com/example/springboot

postgresqlcrud` directory.

  • Click the green Run Button in your IDE or use the terminal to run the application:
    ./mvnw spring-boot:run
  1. Verify the Application:
    • Open your web browser or a tool like Postman and navigate to http://localhost:8080/api/products.

You can now perform CRUD operations on the Product entity using the following endpoints:

  • GET /api/products: Get all products
  • GET /api/products/{id}: Get product by ID
  • POST /api/products: Create a new product
  • PUT /api/products/{id}: Update an existing product
  • DELETE /api/products/{id}: Delete a product


In this tutorial, we have walked through the process of creating a Spring Boot CRUD application with PostgreSQL. We configured the project, set up PostgreSQL, created the necessary entities, repositories, services, and controllers, and tested the CRUD operations. This setup provides a solid foundation for developing more complex Spring Boot applications with PostgreSQL.