@PutMapping and @DeleteMapping in Spring Boot - Mini Project: Build & Apply

Using @PutMapping and @DeleteMapping in Spring Boot

📖 Scenario: You are building a simple Spring Boot REST API to manage a list of books in a library. You want to allow users to update book details and delete books using HTTP methods.

🎯 Goal: Create a Spring Boot controller with endpoints to update a book's information using @PutMapping and delete a book using @DeleteMapping.

📋 What You'll Learn

Create a Book class with id, title, and author fields.

Create a BookController class with a list of books as initial data.

Add a @PutMapping method to update a book by id.

Add a @DeleteMapping method to delete a book by id.

💡 Why This Matters

🌍 Real World

Updating and deleting resources via REST APIs is common in web applications like library systems, inventory management, and user profiles.

💼 Career

Understanding @PutMapping and @DeleteMapping is essential for backend developers working with Spring Boot to build RESTful services.

1

Create initial book data

Create a BookController class with a List<Book> called books initialized with these exact books: new Book(1, "1984", "George Orwell") and new Book(2, "Brave New World", "Aldous Huxley").

Spring Boot

import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.ArrayList;

@RestController
public class BookController {
    // Your code here
}

Hint

Use List.of() inside new ArrayList<>() to create the initial list.

2

Add a configuration variable for book count

Inside BookController, add a private integer variable called nextId and set it to 3 to track the next book ID.

Spring Boot

import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.ArrayList;

@RestController
public class BookController {
    private List books = new ArrayList(List.of(
        new Book(1, "1984", "George Orwell"),
        new Book(2, "Brave New World", "Aldous Huxley")
    ));
    // Your code here
}

Hint

Declare nextId as a private integer and assign it the value 3.

3

Add @PutMapping method to update a book

Add a method annotated with @PutMapping("/books/{id}") named updateBook that takes @PathVariable int id and @RequestBody Book updatedBook. Use a for loop with variables book and update the matching book's title and author if book.getId() == id. Return the updated book.

Spring Boot

import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.ArrayList;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;

@RestController
public class BookController {
    private List books = new ArrayList(List.of(
        new Book(1, "1984", "George Orwell"),
        new Book(2, "Brave New World", "Aldous Huxley")
    ));
    private int nextId = 3;

    // Your code here
}

Hint

Use @PutMapping with path /books/{id}. Loop through books to find the book with matching id and update its fields.

4

Add @DeleteMapping method to delete a book

Add a method annotated with @DeleteMapping("/books/{id}") named deleteBook that takes @PathVariable int id. Use a for loop with index i to find the book with matching id and remove it from books. Return void.

Spring Boot

import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.ArrayList;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.DeleteMapping;

@RestController
public class BookController {
    private List books = new ArrayList(List.of(
        new Book(1, "1984", "George Orwell"),
        new Book(2, "Brave New World", "Aldous Huxley")
    ));
    private int nextId = 3;

    @PutMapping("/books/{id}")
    public Book updateBook(@PathVariable int id, @RequestBody Book updatedBook) {
        for (Book book : books) {
            if (book.getId() == id) {
                book.setTitle(updatedBook.getTitle());
                book.setAuthor(updatedBook.getAuthor());
                return book;
            }
        }
        return null;
    }

    // Your code here
}

Hint

Use @DeleteMapping with path /books/{id}. Loop with index to find and remove the book.

Practice

1. What is the primary purpose of the @PutMapping annotation in Spring Boot?

easy

A. To handle HTTP GET requests for retrieving data

B. To handle HTTP PUT requests for updating existing resources

C. To handle HTTP POST requests for creating new resources

D. To handle HTTP DELETE requests for removing resources

Solution

1. Step 1: Understand HTTP methods

   HTTP PUT is used to update existing data on the server.

2. Step 2: Match annotation to HTTP method

   @PutMapping maps HTTP PUT requests to controller methods.

3. Final Answer:

   To handle HTTP PUT requests for updating existing resources -> Option B

4. Quick Check:

   @PutMapping = update data [OK]

Hint: Put means update existing data via HTTP PUT [OK]

Common Mistakes:

• Confusing @PutMapping with @PostMapping
• Thinking @PutMapping creates new data
• Mixing HTTP methods like GET or DELETE

2. Which of the following is the correct syntax to define a method that deletes a resource by ID using @DeleteMapping?

easy

A. @DeleteMapping("/items/{id}") public void deleteItem(int id) {}

B. @DeleteMapping("/items") public void deleteItem(int id) {}

C. @DeleteMapping("/items/{id}") public void deleteItem(@PathVariable int id) {}

D. @DeleteMapping("/items") public void deleteItem(@RequestParam int id) {}

Solution

1. Step 1: Identify correct URL pattern and annotation

   To delete by ID, URL should include path variable like /items/{id} and method parameter annotated with @PathVariable.

2. Step 2: Check method signature matches path variable

   @DeleteMapping("/items/{id}") public void deleteItem(@PathVariable int id) {} correctly uses @DeleteMapping with path and @PathVariable int id parameter.

3. Final Answer:

   @DeleteMapping("/items/{id}") public void deleteItem(@PathVariable int id) {} -> Option C

4. Quick Check:

   Delete by ID needs @PathVariable and matching URL [OK]

Hint: Use @PathVariable with URL {id} in @DeleteMapping [OK]

Common Mistakes:

• Omitting @PathVariable annotation
• Using @RequestParam instead of @PathVariable for path params
• Not matching method parameter to URL placeholder

3. Given the following Spring Boot controller method, what will happen when a PUT request is sent to /users/5 with a valid JSON body?

@PutMapping("/users/{id}")
public User updateUser(@PathVariable int id, @RequestBody User user) {
    user.setId(id);
    return userService.save(user);
}

medium

A. The user with ID 5 will be updated with the JSON data and returned

B. A new user will be created ignoring the ID in the URL

C. The request will fail because @RequestBody is missing

D. The user ID will not be set and cause an error

Solution

1. Step 1: Analyze method parameters and annotations

   The method uses @PutMapping with path variable id and @RequestBody user object. It sets user ID from path.

2. Step 2: Understand method behavior on PUT request

   It updates the user ID to match URL, then calls save to update and returns updated user.

3. Final Answer:

   The user with ID 5 will be updated with the JSON data and returned -> Option A

4. Quick Check:

   PUT updates resource with URL ID and JSON body [OK]

Hint: PUT with @RequestBody updates resource using URL ID [OK]

Common Mistakes:

• Assuming PUT creates new resource instead of updating
• Ignoring @PathVariable ID and using JSON ID only
• Missing @RequestBody causing request failure

4. Identify the error in this Spring Boot controller method intended to delete a user by ID:

@DeleteMapping("/users")
public void deleteUser(@PathVariable int id) {
    userService.deleteById(id);
}

medium

A. The URL does not include the path variable placeholder {id}

B. The method should use @RequestParam instead of @PathVariable

C. The method should return a value instead of void

D. The @DeleteMapping annotation is missing

Solution

1. Step 1: Check URL and method parameters

   The method expects @PathVariable int id but URL is "/users" without {id} placeholder.

2. Step 2: Understand path variable binding

   Without {id} in URL, Spring cannot bind path variable, causing error.

3. Final Answer:

   The URL does not include the path variable placeholder {id} -> Option A

4. Quick Check:

   Path variable needs matching {id} in URL [OK]

Hint: Match @PathVariable with {id} in URL path [OK]

Common Mistakes:

• Forgetting to add {id} in URL path
• Using @PathVariable without URL placeholder
• Confusing @RequestParam with @PathVariable

5. You want to implement a REST API in Spring Boot that updates a product's price only if the product exists, otherwise returns 404. Which combination of annotations and code best achieves this using @PutMapping?

hard

A. @PutMapping("/products/{id}") public Product updatePrice(@RequestParam int id, @RequestBody Product p) {
p.setId(id);
return productService.save(p);
}

B. @PutMapping("/products") public Product updatePrice(@RequestBody Product p) {
productService.save(p);
return p;
}

C. @PutMapping("/products/{id}") public void updatePrice(@PathVariable int id, @RequestBody Product p) {
productService.save(p);
}

D. @PutMapping("/products/{id}") public ResponseEntity<Product> updatePrice(@PathVariable int id, @RequestBody Product p) {
return productService.findById(id)
.map(existing -> {
existing.setPrice(p.getPrice());
productService.save(existing);
return ResponseEntity.ok(existing);
})
.orElse(ResponseEntity.notFound().build());
}

Solution

1. Step 1: Check for product existence before update

   @PutMapping("/products/{id}") public ResponseEntity<Product> updatePrice(@PathVariable int id, @RequestBody Product p) { return productService.findById(id) .map(existing -> { existing.setPrice(p.getPrice()); productService.save(existing); return ResponseEntity.ok(existing); }) .orElse(ResponseEntity.notFound().build()); } uses productService.findById(id) to check if product exists, returning 404 if not.

2. Step 2: Update price only if product found and return proper HTTP response

   The map lambda updates the price on the existing product, saves it, and returns ResponseEntity.ok(existing); orElse returns notFound().

3. Final Answer:

   @PutMapping("/products/{id}") public ResponseEntity<Product> updatePrice(@PathVariable int id, @RequestBody Product p) { return productService.findById(id) .map(existing -> { existing.setPrice(p.getPrice()); productService.save(existing); return ResponseEntity.ok(existing); }) .orElse(ResponseEntity.notFound().build()); } -> Option D

4. Quick Check:

   Check existence, update, return 404 if missing [OK]

Hint: Check existence first, then update and return ResponseEntity [OK]

Common Mistakes:

• Not checking if product exists before update
• Using @RequestParam instead of @PathVariable for ID
• Not returning 404 when product missing