Spring Boot - Learn Java by Examples

Using Lombok in Spring Boot to Reduce Boilerplate Code

By Wayan in Spring Boot Last modified: July 16, 2025 0 Comment

Lombok is an excellent library for reducing boilerplate code in Java applications, including Spring Boot projects. It provides useful annotations that simplify mundane tasks like generating getters, setters, constructors, hashCode, equals, and toString methods.

Here’s how to use Lombok in a Spring Boot project to make your code cleaner and more concise:

Steps to Use Lombok in Spring Boot

Add Lombok Dependency
Add the Lombok dependency to your (for Maven) or build.gradle (for Gradle). pom.xml
Maven:

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version> <!-- Check for the latest version -->
    <scope>provided</scope>
</dependency>

Enable Annotation Processing
Ensure that annotation processing is enabled in your IDE (e.g., IntelliJ IDEA).
In IntelliJ IDEA:
- Go to File > Settings > Build, Execution, Deployment > Compiler > Annotation Processors.
- Check Enable annotation processing.
Add Lombok Annotations in Your Code
Use Lombok annotations in your classes to reduce boilerplate code. The most commonly used annotations are described below.

Commonly Used Lombok Annotations

@Getter and @Setter
Automatically generates getter and setter methods for your fields.

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class User {
    private Long id;
    private String name;
}

@ToString
Automatically generates a toString() method for the class.

import lombok.ToString;

@ToString
public class User {
    private Long id;
    private String name;
}

@EqualsAndHashCode
Generates equals() and hashCode() methods.

import lombok.EqualsAndHashCode;

@EqualsAndHashCode
public class User {
    private Long id;
    private String name;
}

@NoArgsConstructor, @AllArgsConstructor, @RequiredArgsConstructor
Generates constructors:
- @NoArgsConstructor: No-args constructor.
- @AllArgsConstructor: All-args constructor.
- @RequiredArgsConstructor: Constructor for required fields (final fields or fields with @NonNull annotation).
```
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.RequiredArgsConstructor;

@NoArgsConstructor
@AllArgsConstructor
@RequiredArgsConstructor
public class User {
    private Long id;
    @NonNull
    private String name;
}
```
@Data
A shorthand annotation that combines @Getter, @Setter, @ToString, @EqualsAndHashCode, and @RequiredArgsConstructor.
```
import lombok.Data;

@Data
public class User {
    private Long id;
    private String name;
}
```

@Builder
Enables the builder pattern for the class.

import lombok.Builder;

@Builder
public class User {
    private Long id;
    private String name;
}

@Slf4j
Adds a static logger variable (log) for logging purposes.

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class UserService {
    public void performAction() {
        log.info("Performing some action...");
    }
}

Example: Lombok in a Spring Boot Entity

Below is an example of a Spring Boot entity class that uses Lombok annotations:

package com.example.demo.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.Data;
import lombok.NoArgsConstructor;

@Entity
@Data
@NoArgsConstructor
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;
}

Logging Example

Service class adding logging with Lombok’s @Slf4j:

package com.example.demo.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class UserService {
    public void processUser() {
        log.info("Processing user...");
    }
}

Advantages of Using Lombok

Significant reduction in boilerplate code, making your classes cleaner and easier to read.
Easier maintenance since redundant code is removed.
Integration with Spring Boot makes it seamless to use.

Understanding @Entity, @Repository, and @Service in Spring Boot

By Wayan in Spring Boot Last modified: July 12, 2025 0 Comment

In Spring Boot (and the larger Spring Framework), the annotations @Entity, @Repository, and @Service play a key role in structuring and organizing applications using the principles of dependency injection and inversion of control. Here’s an overview of each:

1. `@Entity`

Definition: The @Entity annotation is used in Java Persistence API (JPA) to define a class as a persistent entity. This means the class maps to a table in the database.
Key Features:
- Marks a POJO (Plain Old Java Object) as a JPA entity.
- Each annotated class is associated with a database table, and each instance of the class represents a row in that table.
- Requires a primary key, typically annotated with @Id.
Example:

package org.kodejava.spring;

import jakarta.persistence.Entity;
import jakarta.persistence.Id;

@Entity
public class Employee {
    @Id
    private Long id;
    private String name;
    private String role;

    // Getters and setters
}

Usage Context: This annotation is part of Jakarta EE (or JPA) and is generally used for classes that model database tables.

2. `@Repository`

Definition: The @Repository annotation indicates that the class is a repository, which is responsible for interacting with the database.
Key Features:
- Used for Data Access Objects (DAO).
- It helps encapsulate the interaction with the database from the rest of the application.
- It automatically translates exceptions thrown by the persistence layer into Spring’s unchecked exceptions (like DataAccessException).
Example:

package org.kodejava.spring;

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

@Repository
public interface EmployeeRepository extends JpaRepository<Employee, Long> {
    // Custom database queries (if needed)
}

Usage Context: Typically, @Repository is used to annotate interfaces or classes that handle data persistence, often enhanced by Spring Data JPA for reducing boilerplate code.

3. `@Service`

Definition: The @Service annotation marks a class as a business service that contains the application’s business logic.
Key Features:
- Indicates that the class is a “service” component in the Service layer.
- Helps clearly separate business logic from other concerns, such as data persistence or presentation.
- Works in conjunction with @Component to allow dependency injection.
Example:

package org.kodejava.spring;

import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class EmployeeService {
    private final EmployeeRepository repository;

    // Constructor injection of the repository
    public EmployeeService(EmployeeRepository repository) {
        this.repository = repository;
    }

    public List<Employee> getAllEmployees() {
        return repository.findAll();
    }

    public Employee saveEmployee(Employee employee) {
        return repository.save(employee);
    }
}

Usage Context: Typically used to encapsulate and reuse business logic.

Summary of Their Responsibilities in an Application Layer:

@Entity: Maps a Java class to a database table (used in the Data Model layer).
@Repository: Handles database operations (typically at the Data Access layer).
@Service: Contains business logic (used in the Service layer).

How These Work Together:

These annotations correspond to different tiers in a common layering structure of a Spring Boot application:
1. Entity: Represents data (e.g., Employee).
2. Repository: Provides the CRUD operations for entities using JPA (e.g., EmployeeRepository).
3. Service: Manages the application’s business logic and interactions (e.g., EmployeeService).

By using these annotations together, you achieve a clean separation of concerns, making the application easier to maintain, test, and scale.

How to Connect Your Spring Boot App to MySQL or PostgreSQL

By Wayan in Spring Boot Last modified: July 7, 2025 0 Comment

Here’s a guide on how to connect your Spring Boot application to a MySQL or PostgreSQL database. These steps assume you are already familiar with basic Spring Boot concepts.

1. Add the Necessary Dependencies

Open your (for Maven) or build.gradle (for Gradle), and add the database driver and Spring Boot starter dependencies: pom.xml
Maven:

<!-- MySQL Driver -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>

<!-- PostgreSQL Driver -->
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>

<!-- Spring Data JPA -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

2. Configure `application.yml` or `application.properties`

Set up the database connection details based on the database you’re using. Here’s an example configuration for both MySQL and PostgreSQL:

For MySQL:

application.properties:

spring.datasource.url=jdbc:mysql://localhost:3306/your_database_name
spring.datasource.username=your_username
spring.datasource.password=your_password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# JPA Properties (Optional, but recommended)
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
spring.jpa.hibernate.ddl-auto=update

application.yml:

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/your_database_name
    username: your_username
    password: your_password
    driver-class-name: com.mysql.cj.jdbc.Driver

  jpa:
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL8Dialect
    hibernate:
      ddl-auto: update

For PostgreSQL:

application.properties:

spring.datasource.url=jdbc:postgresql://localhost:5432/your_database_name
spring.datasource.username=your_username
spring.datasource.password=your_password
spring.datasource.driver-class-name=org.postgresql.Driver

# JPA Properties (Optional, but recommended)
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
spring.jpa.hibernate.ddl-auto=update

application.yml:

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/your_database_name
    username: your_username
    password: your_password
    driver-class-name: org.postgresql.Driver

  jpa:
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
    hibernate:
      ddl-auto: update

Important Notes:

Replace your_database_name, your_username, and your_password with your actual database details.
spring.jpa.hibernate.ddl-auto=update ensures automatic table creation based on your entity classes but should not be used in production.

3. Create a JPA Entity and Repository

Define a sample entity and repository to test the database connection.
Entity Example:

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

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;

    // Getters and Setters
}

Repository Example:

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

public interface UserRepository extends JpaRepository<User, Long> {
}

4. Test the Connection

Create a test controller or service to interact with the UserRepository and validate the connection.
Example RestController:

import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {

    private final UserRepository userRepository;

    public UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @GetMapping
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
}

5. Run the Application

Start your Spring Boot application, and it should connect to the configured database. You can debug or use a tool like Postman to test the defined endpoints.

6. (Optional) Use Flyway or Liquibase for Database Migrations

For better database version control, it’s advisable to use Flyway or Liquibase instead of relying on spring.jpa.hibernate.ddl-auto. This ensures better management of your database schema in production environments.

Getting Started with Spring Data JPA and Hibernate in Spring Boot

By Wayan in Spring Boot Last modified: July 6, 2025 0 Comment

To get started with Spring Data JPA and Hibernate in a Spring Boot application, follow these steps:

1. Add Required Dependencies

Include spring-boot-starter-data-jpa and h2 (or any other database) dependencies in your pom.xml (for Maven projects).

Maven:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

2. Configure the Application Properties

Set up the database configurations in application.properties or application.yaml. Below is an example for H2 database:
application.properties:

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

3. Create an Entity Class

Create a Java class annotated with @Entity to represent your database table. Also, use mapping annotations (@Id, @GeneratedValue, etc.) to configure the primary key and other relationships.

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

@Entity
public class Employee {

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

    private String name;
    private String department;
    private Double salary;

    // Constructors, Getters, and Setters
    public Employee() {}

    public Employee(String name, String department, Double salary) {
        this.name = name;
        this.department = department;
        this.salary = salary;
    }

    // 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 getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }
}

4. Create a Spring Data JPA Repository

Create an interface for the repository that extends JpaRepository

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

public interface EmployeeRepository extends JpaRepository<Employee, Long> {
    // You can define custom query methods here if needed
}

5. Create a Spring Boot Service

Add a service layer to encapsulate business logic and interact with the repository.

import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class EmployeeService {

    private final EmployeeRepository employeeRepository;

    public EmployeeService(EmployeeRepository employeeRepository) {
        this.employeeRepository = employeeRepository;
    }

    public List<Employee> getAllEmployees() {
        return employeeRepository.findAll();
    }

    public Employee saveEmployee(Employee employee) {
        return employeeRepository.save(employee);
    }
}

6. Create a Controller

Now, create a REST Controller to expose APIs for interacting with your service.

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

import java.util.List;

@RestController
@RequestMapping("/employees")
public class EmployeeController {

    @Autowired
    private EmployeeService employeeService;

    @GetMapping
    public List<Employee> getAllEmployees() {
        return employeeService.getAllEmployees();
    }

    @PostMapping
    public Employee createEmployee(@RequestBody Employee employee) {
        return employeeService.saveEmployee(employee);
    }
}

7. Run the Application

Run your Spring Boot application (@SpringBootApplication annotated class) and test your REST endpoints.

GET /employees → Retrieve all employees
POST /employees → Add a new employee (pass JSON body)

Example JSON for the POST request:

{
    "name": "John Doe",
    "department": "Engineering",
    "salary": 65000.00
}

8. Testing

You can use tools like Postman, Curl, or Spring Boot DevTools to verify that your application works as expected.

9. Switching to a Production Database

Replace the H2 configurations with your production database configurations (e.g., MySQL, PostgreSQL).
For example, using MySQL:

Dependencies:

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

application.properties:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.jpa.database-platform=org.hibernate.dialect.MySQLDialect

This basic setup is a starting point.

Troubleshooting Common Errors in Your First Spring Boot Application

By Wayan in Spring Boot Last modified: July 5, 2025 0 Comment

When starting your first Spring Boot application, you might encounter some common errors. Here’s a guide on how to troubleshoot them effectively.

1. Port Already in Use

Error Message:

     java.net.BindException: Address already in use: JVM_BIND

Cause: Another application (or another instance of your app) is already using the default Spring Boot port (8080).
Solution:
- Run your application on a different port by adding the following entry in application.properties or application.yml:
  application.properties:

       server.port=8081

application.yml:

       server:
         port: 8081

Alternatively, stop the process currently using the port (8080) by running the command:
- Linux/macOS: sudo lsof -t -i:8080 | xargs kill -9
- Windows: Use netstat -ano to find the process using the port and then kill it in Task Manager.

2. Dependency Issues

Error Message:

     Could not resolve dependencies for project
     or
     ClassNotFoundException

Cause: Missing dependencies or inconsistencies in your pom.xml file (Maven) or build.gradle file (Gradle).
Solution:
- Ensure your dependencies are correctly added and check for typos in artifact or group IDs.
- Run mvn clean install or ./gradlew build to refresh your dependencies.

3. Spring Boot Application Fails to Start

Error Message:

     NoSuchBeanDefinitionException

Cause: There might be missing or improperly defined beans during auto-configuration.
Solution:
- Ensure you have annotated your component classes correctly:
  - @Service, @Repository, @Controller, or @RestController for Spring beans.
  - Use @ComponentScan to include the packages containing your components.
- Check for typos in package names or external configuration.

4. Property Source Errors

Error Message:

     Cannot bind to property [property name]

Cause: Your application is trying to bind a property (e.g., from or application.yml) that is missing or invalid. application.properties
Solution:
- Verify that all mandatory properties are defined in your configuration.
- For stricter validation, use @ConfigurationProperties with type-safe property binding.

5. Database Connection Errors

Error Message:

     Cannot connect to database

Cause: Incorrect database URL, username, password, or the database server is not running.
Solution:
- Verify your database properties in or application.yml: application.properties

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

Ensure the database server is running and accessible.

6. Missing `@Entity` Annotation

Error Message:

     Unable to locate persistent class

Cause: One or more of your JPA entities may be missing the @Entity annotation.
Solution:
- Ensure all entity classes are annotated with @Entity.
- Ensure that their primary keys are annotated appropriately with @Id.

7. Thymeleaf or Static Resource Not Found

Error Message:

     TemplateNotFoundException

Cause: The template file might be missing or placed in the wrong directory.
Solution:
- Thymeleaf templates should be located in src/main/resources/templates.
- Static resources (CSS, JS, etc.) should be in src/main/resources/static.

8. Circular Dependency Error

Error Message:

     Circular view path or Circular dependency detected

Cause: Circular injection of beans in the application context.
Solution:
- Use the @Lazy annotation to lazily initialize one of the beans.
- Restructure your code to eliminate the circular dependency.

9. Incorrect Main Class Declaration

Error Message:

     No qualifying bean of type [YourClassName]

Cause: The class with the @SpringBootApplication annotation is not correctly defined or is missing.
Solution:
- Ensure that your @SpringBootApplication main class is in the root package, so that Spring Boot can scan all sub-packages.

10. Version Conflicts

Error Message:

     MethodNotFound or ClassNotFoundException

Cause: Your dependency versions are incompatible.
Solution:
- Use a compatible Spring Boot starter version in your or build.gradle. pom.xml
- Check the Spring Initializer Website for recommended versions.

Tools for Troubleshooting:

Logs: Check logs carefully to locate the cause of the error.
DevTools: Use Spring Boot DevTools for automatic restarts and live reloading.
Dependency Analyzer: Check dependency conflicts using mvn dependency:tree or ./gradlew dependencies.
Debugging: Use breakpoints and IDE debugging tools.

Steps to Use Lombok in Spring Boot

Commonly Used Lombok Annotations

Example: Lombok in a Spring Boot Entity

Logging Example

Advantages of Using Lombok

1. @Entity

2. @Repository

3. @Service

Summary of Their Responsibilities in an Application Layer:

How These Work Together:

1. Add the Necessary Dependencies

2. Configure application.yml or application.properties

For MySQL:

For PostgreSQL:

3. Create a JPA Entity and Repository

4. Test the Connection

5. Run the Application

6. (Optional) Use Flyway or Liquibase for Database Migrations

1. Add Required Dependencies

2. Configure the Application Properties

3. Create an Entity Class

4. Create a Spring Data JPA Repository

5. Create a Spring Boot Service

6. Create a Controller

7. Run the Application

8. Testing

9. Switching to a Production Database

1. Port Already in Use

2. Dependency Issues

3. Spring Boot Application Fails to Start

4. Property Source Errors

5. Database Connection Errors

6. Missing @Entity Annotation

7. Thymeleaf or Static Resource Not Found

8. Circular Dependency Error

9. Incorrect Main Class Declaration

10. Version Conflicts

Tools for Troubleshooting:

1. `@Entity`

2. `@Repository`

3. `@Service`

2. Configure `application.yml` or `application.properties`

6. Missing `@Entity` Annotation