How to Connect PostgreSQL Database with Spring Boot

-

Introduction :

Database connectivity is one of the most important aspects of any Spring Boot application. Whether you are building a REST API, an e-commerce platform, or an enterprise application, you need a database to store and retrieve data.

In this article, we will learn how to connect a PostgreSQL database with a Spring Boot application using Spring Data JPA.



Why PostgreSQL?

PostgreSQL is a powerful open-source relational database known for its reliability, performance, and advanced features. It is widely used in enterprise applications and works seamlessly with Spring Boot.

Benefits of PostgreSQL

  • Open-source and free

  • High performance

  • ACID compliant

  • Supports complex queries

  • Enterprise-grade security

Prerequisites

Before getting started, make sure you have:

  • Java 17 or later

  • Spring Boot 3.x

  • PostgreSQL Installed

  • Maven

  • IDE (IntelliJ IDEA, Eclipse, or VS Code)

Step 1: Create a PostgreSQL Database

Open PostgreSQL and create a database:

CREATE DATABASE springboot_db;

Verify that the database has been created successfully.

Step 2: Add Required Dependencies

Add the following dependencies to your pom.xml file:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
</dependency>

Step 3: Configure Database Properties

Add the following configuration to application.properties:

spring.datasource.url=jdbc:postgresql://localhost:5432/springboot_db
spring.datasource.username=postgres
spring.datasource.password=password

spring.datasource.driver-class-name=org.postgresql.Driver

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

Property Explanation

  • spring.datasource.url → Database connection URL

  • spring.datasource.username → PostgreSQL username

  • spring.datasource.password → PostgreSQL password

  • ddl-auto=update → Automatically updates tables

  • show-sql=true → Displays SQL queries in console

Step 4: Create an Entity Class

@Entity
@Table(name = "employee")
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private String department;

    // Getters and Setters
}

Instead of manualy writing getter and setter methods, we can use Lombok Annotations such as @Getter
and @Setter. Otherwise we can use @Data Annotation.

It helps reduce boilerplate code and improves readability, especially in large Spring Boot applications.

Step 5: Create Repository Interface

@Repository
public interface EmployeeRepository
        extends JpaRepository<Employee, Long> {
}

Spring Data JPA automatically provides CRUD operations.

Step 6: Run the Application

Start the Spring Boot application.

If the configuration is correct:

  • Application starts successfully

  • Database connection is established

  • Employee table is created automatically

How Spring Boot Connects to PostgreSQL

  1. Spring Boot reads datasource properties.

  2. Creates a database connection.

  3. Hibernate initializes entity mappings.

  4. Tables are created or updated.

  5. Application interacts with PostgreSQL through JPA repositories.

Understanding Key JPA Annotations

  • @Entity : Marks a class as a JPA entity.
  • @Table : Maps the entity to a database table.
  • @Id : Defines the primary key.
  • @GeneratedValue : Generates primary key values automatically.
  • @Column : Maps a field to a table column.

The following annotations are commonly used while creating JPA entities:

These annotations help Hibernate understand how Java objects should be mapped to database tables.

Why Use Spring Data JPA with PostgreSQL?

Benefits :
  • Reduces boilerplate code
  • Automatic table creation and updates
  • Easy CRUD operations
  • Integration with Hibernate
  • Improved developer productivity

Spring Data JPA works seamlessly with PostgreSQL and provides an easy way to interact with relational databases.

Common Errors and Solutions

1. Connection Refused

Cause:
PostgreSQL server is not running.

Solution:
Start PostgreSQL service.

2. Password Authentication Failed

Cause:
Incorrect username or password.

Solution:
Verify database credentials.

3. Database Does Not Exist

Cause:
Incorrect database name.

Solution:
Create the database or update the URL.

Real-World Use Cases

PostgreSQL is commonly used in:

  • Banking Applications

  • E-Commerce Platforms

  • Healthcare Systems

  • Enterprise Applications

  • Learning Management Systems

Common Interview Questions

1. Why is PostgreSQL preferred in enterprise applications?

Because it is reliable, scalable, secure, and supports advanced database features.

2. What is Spring Data JPA?

Spring Data JPA simplifies database operations by reducing boilerplate code.

3. What does ddl-auto=update do?

It automatically updates database tables based on entity changes.

4. Which dependency is required for PostgreSQL?

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
</dependency>

5. What is the default PostgreSQL port?

5432 port

Conclusion :

Connecting PostgreSQL with Spring Boot is straightforward using Spring Data JPA. By configuring datasource properties and adding the required dependencies, developers can quickly establish database connectivity and focus on building business logic.

What's Next?

In this article, we learned how to connect a PostgreSQL database with a Spring Boot application using Spring Data JPA.

In the next article, we will learn how to create JPA Entity and Repository classes in Spring Boot and understand how they interact with PostgreSQL databases to perform data operations efficiently.

Comments

Post a Comment

Popular posts from this blog

React Basics – How to Create Component

-
  Introduction (Story) : When I started learning React, I was confused about how components actually work. I saw many examples, but things became clear only when I created my own first component. In this blog, I will explain how to create a simple React component step by step in an easy way. What is a Component in React? A component is a reusable piece of UI in React. It helps in breaking the application into smaller, manageable parts. Tools Required : Node.js React (Create React App / Vite) VS Code  Step 1: Create React App : Run the following command: Where you want create the react project, then we have to create new folder and there you can open the cmd and run below command npx create-react-app my-app Navigate to project folder: cd my-app npm start Step 2: Create Your First Component Create a file named Hello.js import React from 'react' ; function Hello () { return <h1> Hello, Welcome to React! </h1> ; } export default Hello ; Step 3: ...
Read more

How to Build REST API using Spring Boot (Step-by-Step Guide)

-
Introduction  (Story + Experience)  : When I started learning Spring Boot, I found REST APIs a bit confusing. I watched multiple tutorials, but I didn’t fully understand how backend systems actually work. Things became clear when I tried building a simple REST API on my own. In this blog, I will share the same step-by-step process that helped me understand REST APIs in a practical way. What is REST API? A REST API allows communication between frontend and backend systems using HTTP methods like GET, POST, PUT, and DELETE. In real-world applications, REST APIs are used to send and receive data between client and server. Tools Required  : - Java - Spring Boot - IntelliJ / VS Code - Postman Step 1: Create Spring Boot Project  : Go to Spring Initializr and create a project with the following dependencies: - Spring Web - Spring Data JPA - PostgreSQL Driver Step 2: Create Controller  : @RestController @RequestMapping("/api") public class HelloController {   ...
Read more

Spring Boot @RequestParam Annotation Explained with Real-Time Examples

-
Image
 Introduction : As a Java Full Stack Developer, I have worked on several Spring Boot applications where APIs needed to receive data from users. One annotation that I frequently used in REST APIs is @RequestParam . In many real-world applications, users need to search, filter, sort, or paginate data. For example, an employee management system may allow users to search employees by department, status, or employee ID. In such cases, @RequestParam provides a simple and efficient way to pass data from the client to the server through URL query parameters. When I started learning Spring Boot, I often got confused between @RequestParam , @PathVariable , and @RequestBody . However, after working on multiple projects, I understood the purpose of each annotation and when to use them effectively. In this article, I will explain the @RequestParam annotation with practical examples, project use cases, common mistakes, best practices, and interview questions. What is @RequestParam? The @Reques...
Read more