Introduction
Spring boot is the most effective and broadly used framework for creating Java-based applications. In this blog, we will display how to work with spring boot tasks and that’s the first-class practice for working with spring boot. Here I mention some topics to make your spring boot application more efficient and scalable. Let’s start by understanding the things to keep in mind while creating a Spring Boot application and learn about the best practices that should be followed.
Prerequisites
- Good knowledge of Core Java
- Basic knowledge about spring boot
- Basic knowledge about creating REST API with Spring Boot application
1. Proper packaging style
A proper packaging style in a spring boot application makes better organization, readability, and maintainability of your code. Below is an example of packaging style:
The proper packaging style will help to understand the flow of the application and make coding easy, here in the picture you can see I created different packages such as the model package for contains the data models or entity classes. These classes usually represent database tables and are annotated with JPA/Hibernate annotations, the repository package contains an interface for data access typically JPA repositories or DAO (Data Access Object) classes responsible for performing CRUD operations on the database, the service package contains the service layers where the business logic resides, the controller package contains the REST controllers, which handle HTTP requests and return responses, the exception package is for custom exceptions and global error handling. It ensures consistent error responses when something goes wrong in the application.
2. Use Lombok
Lombok is a Java library that can reduce code using its annotations, such as @Data, @Value, @Constructure, etc. Using Lombok in your Spring Boot project simplifies your code by reducing boilerplate code for tasks like creating getters, setters, constructors, toString(), etc.
Add the following dependency in your pom.xml:
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.36</version>
<scope>provided</scope>
</dependency>
Example :
How to use Lombok in our application, here is an example:
package com.example.user.model;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long userId;
private String firstName;
private String email;
}
In this example, I used Lombok annotations like @Data to generate Getter, setter, toString, equals, and hashCode, @AllArgsConstructor for constructure with all fields, and @NoArgsConstructor for default constructure.
3. Use slf4j logging
SLF4J stands for Simple Logging Facade for Java. Logging is most important for every Java developer. If our application is in manufacturing, logging is used to test the go with the flow, and whilst an error occurs, it facilitates identifying where the difficulty is. Using SLF4J for logging in a Spring Boot application is a great practice for developing customizable and standardized log messages.
Example:
Here is an Example How to use @Slf4j in the application used to log.info(“Hello World”) instead of System.out.print(“Hello World”).
package com.example.user.controller;
import com.example.user.model.User;
import com.example.user.services.UserServices;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@Slf4j
@RestController
@RequestMapping("/users")
public class UserController {
private final UserServices userService;
public UserController(UserServices userService) {
this.userService = userService;
}
@PostMapping()
public User createUser(@RequestBody User user) {
log.info("Inside the controller : Adding new user");
return userService.createUser(user);
}
}
4. Use custom exception handling with a global exception handler
When you want to handle errors consistently throughout your application while avoiding overloading your controllers and services with exception-handling code, using a Global Exception Handler in Spring Boot is a best practice. Spring boot provides two main tools for global exception handling.
Here is an example of a global exception handler class
package com.example.user.exception;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.Map;
@RestControllerAdvice
public class UserNotFoundAdvice {
@ResponseBody
@ExceptionHandler(UserNotFoundException.class)
@ResponseStatus(HttpStatus.NOT_FOUND)
public Map<String,String> exceptionHandler(UserNotFoundException userNotFoundException){
Map<String,String> errorMap = new HashMap<>();
errorMap.put("errorMessage",userNotFoundException.getMessage());
return errorMap;
}
}
In this example, we use to create a global exception handler class with some annotations such as the @RestControllerAdvice for REST APIs, and @ExceptionHandler for specifies the type of exception to handle.
5. Remove unnecessary codes, variables, methods, and classes.
In the application commented part is not necessary then so remove and which variable declared but not to be used in the application that removed because it acquires the memory.
Example:
package com.example.user.controller;
import com.example.user.model.User;
import com.example.user.services.UserServices;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@Slf4j
@RestController
@RequestMapping("/users")
public class UserController {
private final UserServices userService;
public UserController(UserServices userService) {
this.userService = userService;
}
@PostMapping()
public User createUser(@RequestBody User user) {
log.info("Inside the controller : Adding new user");
return userService.createUser(user);
}
// not to use
/* @GetMapping("/{id}")
public User getUserById(@PathVariable("id") Long id) {
log.info("Inside the controller : getting user by id");
return userService.getUserById(id);
} */
}
We can see from this example that the commented section is not required, hence deleting it from the application will affect its performance.
6. Use proper naming convention
When we create applications in Java with Spring Boot, following the proper naming convention for classes, applications, variables, strategies, constants, and database fields is crucial for keeping code clarity and consistency while growing Java software using Spring Boot.
1.Classes : For class names, use PascalCase, where each word begins with a capital letter.
Example: EmployeeService, LeaveCotroller.
2. Packages : For package names, use lowercase letters, and separate words with dots (.).
Example: com.example.employee, com.example.department.
3.Methods : For method names, use camelcase, where the first word starts with a lowercase letter, and subsequent words start with an uppercase letter.
Example: getEmployee(), createNewUser.
4. Variables : For variable names, use camelcase, where the first word starts with a lowercase letter, and subsequent words start with an uppercase letter.
Example: employeeId, employeeName.
5. Constants : For constants names, use SCREAMING_SNAKE_CASE, where all letters are uppercase and words are separated by underscores.
Example: MAX_EMPLOYEE_SALARY, DEFAULT_LEAVE_STATUS.
6. Database Fields : For database filed names, use snake_case, where all letters are lowercase and words are separated by underscores.
Example: employee_id, employee_name.
7. Enum : For enum names, use PascalCase.
Example: Enum name: LeaveStatus
Enum values: PENDING, APPROVED, REJECTED
8. Interface : For interface names, use PascalCase, where each word begins with a capital letter.
Example: EmployeeService, EmployeeRepository.
7. Use Sonarlint
SonarLint is a popular static code analysis tool that helps developers produce cleaner, better code by finding and fixing problems early in the development process, This plugin communicates with your integrated development environment (IDE), such as IntelliJ IDEA, Eclipse, or Visual Studio Code, with possible coding errors, and standard Security Risks. It also provides violation reports in real-time. Using SonarLint, you can dramatically improve your coding practices, eliminate bugs, and optimize code from the beginning of your development process, ensuring clean, secure, and capable application repair will be provided.
8. Use HTTP status codes appropriately
When developing a REST API in a Spring Boot utility, the use of the right HTTP request codes is critical to provide clean communication between the server and clients. HTTP popularity codes are truly the result of the server’s attempt to method the request. Effective use of these rules helps clients handle responses more efficiently and enhances the overall API experience.
Here are the best practices for using HTTP status codes in Spring Boot applications:
- 200 Success Codes for successful data retrieval(GET).
- 201 Created for resource created successfully (POST).
- 204 No Content for successful response with no content (DELETE)
- 400 Bad Requests for malformed requests or validation errors
- 401 Unauthorized for a missing or invalid authentication token
- 403 Forbidden for insufficient permission to access the resources
- 404 Not Found for a resource does not exist
- 500 Internal Server Error for unexpected server-side error
- 502 Bad Gateway for failing to communicate with the upstream server
9. Validate input data
Validating input data is an important part of all applications since it ensures that the data entered by users or other systems is correct, reliable, and safe. Spring Boot provides a variety of techniques for effectively validating input data.
Here is an example of how to validate data in the application :
Step 1: Add validation in the application to add the following dependency in the pom.xml.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
<version>3.4.0</version>
</dependency>
Step 2: Add some validation in the entity class:
package com.example.Product.model;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Pattern;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
public class Category {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long categoryId;
@NotNull(message = "Invalid Name: Name is NULL")
@Pattern(regexp="^[A-Za-z]*$",message = "Invalid Input")
private String name;
}
In this example, I used the @NotNull validation annotation to ensure that users did not submit empty or invalid names. We validate fields in the application using annotations such as @NotNull, @NotEmpty, @NotBlank, @Size, @Min, @Max, @Email, and @Pattern.
10. Secure Your spring boot application
Spring Boot includes built-in support for powerful security features such as Spring Security, making it easier to implement authentication, authorization, and other security controls. Securing a Spring Boot application is critical to protecting unauthorized access, data theft, and other problems with security.
To use spring security in your application, add the following dependency to the pom.xml file.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
<version>3.4.0</version>
</dependency>
Conclusion
In this blog, we showed how Spring Boot developers implemented best practices to ensure a robust, maintainable, and secure application. Efficient logging, custom exception handling, proper use of HTTP status code, and proper input validation improve application reliability by following proper packaging styles, using tools such as Lombok and Sonarlint, naming convention, removing unnecessary code, increasing code readability and scalability.
