Example to Test Rest API for an Employee class
Let’s explore an example that encompasses all these conditions with the Employee class and its operations.
Project Structure:
First we need to configure application.properties file.
spring.application.name=socialmediaapp
server.port=8093
spring.neo4j.uri=bolt://localhost:7687
spring.neo4j.authentication.username=neo4j
spring.neo4j.authentication.password=app12345
spring.devtools.restart.log-condition-evaluation-delta=false
Employee.java:
package com.demo.entity;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotBlank;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.Email;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "employee")
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
@NotBlank(message = "Firstname is mandatory")
private String firstName;
@NotBlank(message = "Lastname is mandatory")
private String lastName;
private String gender;
@Email(message = "Email should be valid")
@NotBlank(message = "Email is mandatory")
private String emailAddress;
@Length(min = 10, max = 10, message = "Mobile number length should be 10 digits")
private String phoneNumber;
private int age;
private Date createdDate;
private Date modifiedDate;
}
This is the Employee DAO class. It becomes an entity in the database with these fields.
EmployeeDTO.java:
package com.demo.dto;
import lombok.*;
import java.util.Date;
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
public class EmployeeDTO {
private String firstName;
private String lastName;
private String gender;
private String emailAddress;
private String phoneNumber;
private int age;
private Date createdDate;
private Date modifiedDate;
}
This is a data transfer object that communicates with frontend code.
ApiResponse.java:
package com.demo.util;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class ApiResponse {
private String message;
private int statusCode;
private Object response;
}
This is a utility class used for retrieving time; we need this one.
EmployeeService.java:
import java.io.*;
class GFG {
public static void main (String[] args) {
System.out.println("GFG!");
}
}
EmployeeServiceIMPL.java:
package com.demo.service.impl;
import com.demo.dto.EmployeeDTO;
import com.demo.dto.UserDTO;
import com.demo.entity.Employee;
import com.demo.exception.ResourceNotFoundException;
import com.demo.repository.EmployeeRepository;
import com.demo.service.EmployeeService;
import com.demo.util.ApiResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@Service
public class EmployeeServiceimpl implements EmployeeService {
@Autowired
private EmployeeRepository employeeRepository;
@Override
public ApiResponse addEmployee(EmployeeDTO employee) {
try {
if (employee == null) {
return new ApiResponse("Invalid Format of data", 400, null);
}
// Check mandatory fields
if (employee.getFirstName() == null || employee.getFirstName().isEmpty()) {
return new ApiResponse("First Name Must Not Be Null or Empty", 400, null);
}
if (employee.getLastName() == null || employee.getLastName().isEmpty()) {
return new ApiResponse("Last Name Must Not Be Null or Empty", 400, null);
}
if (employee.getEmailAddress() == null || employee.getEmailAddress().isEmpty()) {
return new ApiResponse("Email Address Must Not Be Null or Empty", 400, null);
}
// Validate email format
String emailRegex = "^(.+)@(.+)$";
Pattern pattern = Pattern.compile(emailRegex);
Matcher matcher = pattern.matcher(employee.getEmailAddress());
if (!matcher.matches()) {
return new ApiResponse("Email should be valid", 400, employee.getEmailAddress());
}
// Check for existing email
boolean emailExists = employeeRepository.existsByEmailAddress(employee.getEmailAddress());
if (emailExists) {
return new ApiResponse("Email Address Already Exists", 400, employee.getEmailAddress());
}
// Check phone number if not null
if (employee.getPhoneNumber() != null && !employee.getPhoneNumber().matches("\\d{10}")) {
return new ApiResponse("Mobile number length should be 10 digits", 400, null);
}
// Create and populate the employee entity
Employee myEmployee = new Employee();
myEmployee.setFirstName(employee.getFirstName());
myEmployee.setLastName(employee.getLastName());
myEmployee.setEmailAddress(employee.getEmailAddress());
myEmployee.setPhoneNumber(employee.getPhoneNumber());
myEmployee.setAge(employee.getAge());
myEmployee.setGender(employee.getGender());
// Handle creation and modification dates
Date currentDate = new Date();
myEmployee.setCreatedDate(currentDate);
myEmployee.setModifiedDate(currentDate);
// Save the new employee record
Employee savedEmployee = employeeRepository.save(myEmployee);
return new ApiResponse("Successfully Added Employee", 200, savedEmployee);
} catch (Exception e) {
e.printStackTrace();
return new ApiResponse("An error occurred while adding the employee", 500, null);
}
}
@Override
public ApiResponse updateEmployee(int employeeId, EmployeeDTO employee) {
Employee myemployee = employeeRepository.findById(employeeId).orElseThrow(
()->new ResourceNotFoundException("Employee Not Found"+employeeId));
if(myemployee!=null){
try{
String mobile="";
if(employee.getAge()<18){
return new ApiResponse("Age Must In Between 18",500,employee.getAge());
}
if(employee.getFirstName()!=null){
return new ApiResponse("First Name Must Not Null",500,employee.getFirstName());
}
if(employee.getLastName()!=null){
return new ApiResponse("Last Name Must Not Null",500,employee.getLastName());
}
if (employee.getEmailAddress() == null) {
return new ApiResponse("Email Address Must Not Null",500,employee.getEmailAddress());
}
if (employee.getEmailAddress() == null) {
String emailRegex = "^(.+)@(.+)$";
Pattern pattern = Pattern.compile(emailRegex);
Matcher matcher = pattern.matcher(employee.getEmailAddress());
if (!matcher.matches()) {
return new ApiResponse("Email should be valid", 400, employee.getEmailAddress());
}
}
if (employee.getPhoneNumber() != null) {
mobile = myemployee.getPhoneNumber().toString();
if (!employee.getPhoneNumber().matches("\\d{10}")) {
return new ApiResponse("Mobile number length should be 10 digits", 500, null);
}
}
Date currentDate = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
String formattedDate = dateFormat.format(currentDate);
Date current = dateFormat.parse(formattedDate);
myemployee.setModifiedDate(current);
myemployee.setEmailAddress(employee.getEmailAddress());
myemployee.setPhoneNumber(mobile);
myemployee.setAge(employee.getAge());
myemployee.setGender(employee.getGender());
myemployee.setCreatedDate(current);
myemployee.setFirstName(employee.getFirstName());
myemployee.setLastName(employee.getLastName());
Employee updateEmp = employeeRepository.save(myemployee);
return new ApiResponse("Successfully Updated Employee", 500, updateEmp);
}catch (Exception e){
e.printStackTrace();
return new ApiResponse("Invalid Format of data",500,null);
}
}
else
{
return new ApiResponse("Employee Not Found",500,null);
}
}
@Override
public ApiResponse deleteEmployee(int employeeId) {
Employee myemployee = employeeRepository.findById(employeeId).orElseThrow(
()->new ResourceNotFoundException("Employee Not Found"));
if(myemployee!=null){
employeeRepository.delete(myemployee);
return new ApiResponse("User Deleted Successfully",200,employeeId);
}
else
{
return new ApiResponse("Employee Not Found",404,null);
}
}
@Override
public ApiResponse getEmployeeById(int employeeId) {
Employee employee = employeeRepository.findById(employeeId).orElseThrow(
() -> new ResourceNotFoundException("Employee not found with ID: " + employeeId));
if(employee!=null){
return new ApiResponse("User Successfully Found with "+employeeId, 500, employee);
}
else
{
return new ApiResponse("Employee not found with ID: " + employeeId, 500, null);
}
}
@Override
public ApiResponse getAllEmployees() {
List<Employee> employees = employeeRepository.findAll();
if(employees.isEmpty()){
return new ApiResponse("User Not Founds",500,null);
}
else {
return new ApiResponse("Successfully Found",500,employees);
}
}
}
This is our service class where we need to specify all validations. These things make our API robust. Our API won’t break at any time, and we can collect 100% accurate data.
EmployeeController.java:
package com.demo.controller;
import com.demo.dto.EmployeeDTO;
import com.demo.service.EmployeeService;
import com.demo.util.ApiResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/employee")
public class EmployeeController {
@Autowired
private EmployeeService employeeService;
@PostMapping("/add")
public ApiResponse addEmployee(@RequestBody EmployeeDTO employeeDTO) {
try {
return employeeService.addEmployee(employeeDTO);
} catch (Exception e) {
e.printStackTrace();
return new ApiResponse("Invalid Details", 500, e.getMessage());
}
}
@GetMapping("/getByEmployeeId/{employeeId}")
public ApiResponse getEmployeeById(@PathVariable("employeeId") int id) {
try {
return employeeService.getEmployeeById(id);
} catch (Exception e) {
e.printStackTrace();
return new ApiResponse("Invalid Details", 500, e.getMessage());
}
}
@GetMapping("/getAllEmployee")
public ApiResponse getAllEmployees() {
try {
return employeeService.getAllEmployees();
} catch (Exception e) {
e.printStackTrace();
return new ApiResponse("Invalid Details", 500, e.getMessage());
}
}
@PutMapping("/update/{employeeId}")
public ApiResponse updateEmployee(@PathVariable("employeeId") int employeeId,
@RequestBody EmployeeDTO employeeDTO) {
try {
return employeeService.updateEmployee(employeeId, employeeDTO);
} catch (Exception e) {
e.printStackTrace();
return new ApiResponse("Invalid Details", 500, e.getMessage());
}
}
@DeleteMapping("/delete/{employeeId}")
public ApiResponse deleteEmployee(@PathVariable("employeeId") int employeeId) {
try {
return employeeService.deleteEmployee(employeeId);
} catch (Exception e) {
e.printStackTrace();
return new ApiResponse("Invalid Details", 500, e.getMessage());
}
}
}
Output:
When we save employee in database, that time we can edit each and every filed after saving the data.
First check FirstName is null or not.
Check lastName:
Check Phone Number:
Validate Email:
Add Employee:
When we delete Employee that we need to ensure those employee exits in database. A valid message will be given.
If employee found:
Employee not Found with Id:
Endpoint: http://localhost:9000/employee/getByEmployeeId/3,
Get Employee by ID.
Endpoint: http://localhost:9000/employee/getByEmployeeId/3,
When we are updating detail, at that point we need ensure its be valid.
Endpoint: http://localhost:9000/employee/update/3,
Best Practices while Making Rest APIs in Spring Boot Application
API, or Application Programming Interface, is a communication gateway between frontend and backend code. A robust API is crucial for ensuring uninterrupted functionality. In this article, we will discuss how to achieve robustness in our REST API within the Spring Boot application.
Rules :
- Use JSON as the Standard Message Format
- Error Handling
- Pagination, Filtering, and Sorting
The above considerations are crucial when building the rest of the API. Validation on the server side is paramount, especially when using annotations like @NotBlank and @NotEmpty on beans. It’s essential to verify if there are any manipulations and ensure the integrity of the Data Access Object (DAO).
Using Data Transfer Objects (DTOs) is considered a best practice. All operations should ideally involve DTOs instead of DAOs for better security. Additionally, it’s important to validate DTOs every time an action like saving or updating is performed to prevent invalid data, such as incorrect names, mobile numbers, or emails, from being processed.
Contact Us