@PutMapping and @DeleteMapping in Spring Boot - Performance & Optimization

Performance: @PutMapping and @DeleteMapping

MEDIUM IMPACT

These annotations affect server request handling speed and network payload size, impacting how fast the client sees updates or deletions.

Updating or deleting resources via REST endpoints

Spring Boot

@PutMapping("/resource/{id}")
public ResponseEntity<?> updateResource(@PathVariable Long id, @RequestBody Resource resource) {
    // update logic
    return ResponseEntity.ok().build();
}

@DeleteMapping("/resource/{id}")
public ResponseEntity<?> deleteResource(@PathVariable Long id) {
    // delete logic
    return ResponseEntity.noContent().build();
}

Using correct HTTP verbs clarifies intent, enables better caching, and reduces unnecessary data transfer, improving responsiveness.

📈 Performance GainReduces network overhead and improves client-side caching, lowering interaction delay.

Updating or deleting resources via REST endpoints

Spring Boot

@PostMapping("/updateResource")
public ResponseEntity<?> updateResource(@RequestBody Resource resource) {
    // update logic
    return ResponseEntity.ok().build();
}

@PostMapping("/deleteResource")
public ResponseEntity<?> deleteResource(@RequestParam Long id) {
    // delete logic
    return ResponseEntity.ok().build();
}

Using @PostMapping for update and delete operations misuses HTTP verbs, causing caching issues and unclear intent, which can slow client-server interaction and increase network overhead.

📉 Performance CostIncreases network latency due to improper caching and forces clients to revalidate more often.

Performance Comparison

Pattern	Server Processing	Network Overhead	Caching Impact	Verdict
Using @PostMapping for update/delete	Standard processing	Higher due to unclear intent	Poor caching, more revalidation	[X] Bad
Using @PutMapping and @DeleteMapping correctly	Optimized for intent	Lower due to proper semantics	Better caching, less revalidation	[OK] Good

Rendering Pipeline

These annotations define HTTP methods that the server uses to route requests. Proper use affects how quickly the server processes requests and sends responses, impacting client interaction speed.

→Server Request Routing

→Request Processing

→Response Generation

⚠️ BottleneckRequest Processing when server logic is inefficient or uses incorrect HTTP methods causing extra validation.

Core Web Vital Affected

INP

These annotations affect server request handling speed and network payload size, impacting how fast the client sees updates or deletions.

Optimization Tips

1Use @PutMapping for updating existing resources to improve caching and clarity.

2Use @DeleteMapping for deleting resources to reduce network overhead and improve client understanding.

3Avoid using @PostMapping for update or delete operations to prevent caching issues and increased latency.

Performance Quiz - 3 Questions

Why is using @PutMapping better than @PostMapping for updating resources?

A Because POST is only for creating resources and cannot update.

B Because PUT clearly signals an update operation, enabling better caching and network efficiency.

C Because PUT requests are always faster than POST requests.

D Because POST requests do not support request bodies.

DevTools: Network

How to check: Open DevTools, go to Network tab, perform update or delete requests, and inspect the HTTP method and response headers.

What to look for: Check that requests use PUT or DELETE methods and observe caching headers to confirm efficient network usage.

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