18.3.2. Creating a REST Controller

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>

In this first step, you need to include the necessary dependencies for Spring Boot in your project's pom.xml file if you are using Maven as your build tool. The spring-boot-starter-web dependency is crucial as it includes everything needed to build web applications using Spring, such as RESTful services. By adding this dependency, you tell Maven to download and include all the required libraries automatically.

Think of this step as gathering all your tools before starting a DIY project. Just like you would retrieve tools like hammers, nails, and screws to build a shelf, in programming, you need to gather the right libraries (dependencies) to build your RESTful API.

public class Employee {
private int id;
private String name;
private String department;
// Getters and setters
}

In this step, you define an Employee class that will represent the data structure of the employee resource in your API. This class contains fields for the employee's ID, name, and department. By defining getters and setters, you make it possible to encapsulate the employee data and manipulate it. This class will serve as the template for creating and manipulating Employee objects.

Imagine you are designing a blueprint for a house. Just like that blueprint outlines the different rooms and dimensions, this Employee class serves as a blueprint for what constitutes an employee in your application. It outlines key attributes like ID, name, and department that every employee will have.

@RestController
@RequestMapping("/api/employees")
public class EmployeeController {
private List<Employee> employeeList = new ArrayList<>();

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

@PostMapping
public Employee addEmployee(@RequestBody Employee employee) {
employeeList.add(employee);
return employee;
}

@PutMapping("/{id}")
public Employee updateEmployee(@PathVariable int id, @RequestBody Employee updatedEmployee) {
for (Employee emp : employeeList) {
if (emp.getId() == id) {
emp.setName(updatedEmployee.getName());
emp.setDepartment(updatedEmployee.getDepartment());
return emp;
}
}
return null;
}

@DeleteMapping("/{id}")
public String deleteEmployee(@PathVariable int id) {
employeeList.removeIf(emp -> emp.getId() == id);
return "Employee deleted successfully.";
}
}

In this step, you create a controller class named EmployeeController. This class is annotated with @RestController, indicating that it will handle HTTP requests and send responses. The @RequestMapping annotation specifies the base URL for all the endpoints in this controller. Inside the class, you maintain a list of employees and define several methods for handling different HTTP requests:

• getAllEmployees(): Handles GET requests to retrieve all employees.
• addEmployee(): Handles POST requests to add a new employee.
• updateEmployee(): Handles PUT requests to update an existing employee using their ID.
• deleteEmployee(): Handles DELETE requests to remove an employee by ID.

Think of the EmployeeController as a restaurant manager who takes customer orders and interacts with the kitchen staff. Just like the manager takes different types of requests—such as asking for the menu (GET), ordering food (POST), changing an order (PUT), or canceling an order (DELETE)—the controller processes different HTTP requests and manages the employee data accordingly.

--