Handling CRUD Operations in the API

When building an API, one of the essential tasks is to handle CRUD (Create, Read, Update, Delete) operations. In this section, we will learn how to implement these operations in our Spring Boot API.

1. Implementing Create Operation

To implement the create operation, we need to define an endpoint that receives a POST request with the data that needs to be created. In the controller class, we can define a method with the @PostMapping annotation and specify the path for the endpoint. In this method, we can extract the data from the request body and use a service class to create the data in the database.

Here's an example of how the create operation can be implemented:

1class UserController {
2  // ...
3
4  @Autowired
5  private UserService userService;
6
7  @PostMapping("/users")
8  public ResponseEntity<User> createUser(@RequestBody User newUser) {
9      User createdUser = userService.createUser(newUser);
10      return ResponseEntity.ok(createdUser);
11  }
12
13  // ...
14}

In the above example, we define a createUser method that receives a User object as the request body. We then use the userService to create the user and return the created user in the response.

2. Implementing Read Operation

To implement the read operation, we need to define an endpoint that receives a GET request and returns the data from the database. In the controller class, we can define a method with the @GetMapping annotation and specify the path for the endpoint. In this method, we can use a service class to retrieve the data from the database.

Here's an example of how the read operation can be implemented:

1class UserController {
2  // ...
3
4  @Autowired
5  private UserService userService;
6
7  @GetMapping("/users/{id}")
8  public ResponseEntity<User> getUser(@PathVariable Long id) {
9      User user = userService.getUserById(id);
10      if (user != null) {
11          return ResponseEntity.ok(user);
12      } else {
13          return ResponseEntity.notFound().build();
14      }
15  }
16
17  // ...
18}

In the above example, we define a getUser method that retrieves the user with the specified id. If the user is found, we return the user in the response. Otherwise, we return a 404 Not Found response.

3. Implementing Update Operation

To implement the update operation, we need to define an endpoint that receives a PUT request with the updated data. In the controller class, we can define a method with the @PutMapping annotation and specify the path for the endpoint. In this method, we can extract the updated data from the request body and use a service class to update the data in the database.

Here's an example of how the update operation can be implemented:

1class UserController {
2  // ...
3
4  @Autowired
5  private UserService userService;
6
7  @PutMapping("/users/{id}")
8  public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User updatedUser) {
9      User user = userService.getUserById(id);
10      if (user != null) {
11          User updated = userService.updateUser(user, updatedUser);
12          return ResponseEntity.ok(updated);
13      } else {
14          return ResponseEntity.notFound().build();
15      }
16  }
17
18  // ...
19}

In the above example, we define an updateUser method that retrieves the user with the specified id. If the user is found, we update the user with the updated data and return the updated user in the response. Otherwise, we return a 404 Not Found response.

4. Implementing Delete Operation

To implement the delete operation, we need to define an endpoint that receives a DELETE request and deletes the data from the database. In the controller class, we can define a method with the @DeleteMapping annotation and specify the path for the endpoint. In this method, we can use a service class to delete the data from the database.

Here's an example of how the delete operation can be implemented:

1class UserController {
2  // ...
3
4  @Autowired
5  private UserService userService;
6
7  @DeleteMapping("/users/{id}")
8  public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
9      User user = userService.getUserById(id);
10      if (user != null) {
11          userService.deleteUser(user);
12          return ResponseEntity.noContent().build();
13      } else {
14          return ResponseEntity.notFound().build();
15      }
16  }
17
18  // ...
19}

In the above example, we define a deleteUser method that retrieves the user with the specified id. If the user is found, we delete the user from the database and return a 204 No Content response. Otherwise, we return a 404 Not Found response.

By implementing these CRUD operations, we can create robust APIs that allow clients to create, read, update, and delete data effectively. Make sure to handle error cases and return appropriate HTTP responses to provide a good user experience.

xxxxxxxxxx

class Main {

  public static void main(String[] args) {

    // replace with your Java logic here

    for(int i = 1; i <= 100; i++) {

      if(i % 3 == 0 && i % 5 == 0) {

          System.out.println("FizzBuzz");

      } else if(i % 3 == 0) {

          System.out.println("Fizz");

      } else if(i % 5 == 0) {

          System.out.println("Buzz");

      } else {

          System.out.println(i);

      }

    }

  }

}