@GetMapping, @PostMapping, @PutMapping, @DeleteMapping and @PatchMapping

#Introduction

One of the most misunderstood topics in REST API development. Many developers know @GetMapping, @PostMapping, @PutMapping, @DeleteMapping and @PatchMapping. But interviewers ask:

• Why is GET different from POST?
• What is idempotency?
• Why shouldn't GET modify data?
• What is the difference between PUT and PATCH?
• When should you return 200 vs 201 vs 204?

After this chapter you'll understand HTTP methods like a backend architect.

#What are HTTP Methods?

Every request carries an HTTP method:

GET /users/10 HTTP/1.1

The first word, GET, tells the server what operation you want it to perform.

REST API Example

Spring Mapping Annotations

@GetMapping("/users") is equivalent to @RequestMapping(value = "/users", method = RequestMethod.GET).

#1. @GetMapping — Retrieve Data

Purpose: retrieve data. Never modify data.

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return service.getUser(id);
    }
}

GET /users/10 returns:

{
  "id": 10,
  "name": "Rahul"
}

GET is a Safe Method

Safe means no modification on the server. Allowed: read, search, filter. Not allowed: insert, update, delete.

❌ Wrong:

@GetMapping("/delete/{id}")
public void delete(@PathVariable Long id) {
    repository.deleteById(id);
}

Never delete data using GET — crawlers, link prefetching and caches may call GET URLs freely. Use DELETE.

#2. @PostMapping — Create Resources

@PostMapping
public User save(@RequestBody User user) {
    return service.save(user);
}

POST /users with body:

{
  "name": "Rahul"
}

POST creates data:

#3. @PutMapping — Replace a Resource

Purpose: replace an existing resource completely.

Database: Rahul, 25. PUT request:

{
  "name": "Rohit",
  "age": 30
}

Database becomes Rohit, 30 — the entire resource is replaced.

@PutMapping("/{id}")
public User update(@PathVariable Long id, @RequestBody User user) {
    return service.update(id, user);
}

#4. @PatchMapping — Partial Update

Purpose: update only the required fields.

Database: Rahul, 25. PATCH request:

{
  "age": 26
}

Database becomes Rahul, 26 — the name is unchanged.

@PatchMapping("/{id}")
public User updateAge(@PathVariable Long id, @RequestBody User user) {
}

#5. @DeleteMapping — Delete a Resource

@DeleteMapping("/{id}")
public void delete(@PathVariable Long id) {
    service.delete(id);
}

DELETE /users/10 removes row 10.

#CRUD Mapping

Remember this table.

#Safe vs Unsafe Methods

Safe means no modification.

(HEAD and OPTIONS are also safe.)

#Idempotency

A favourite interview question.

• GET — GET /users/10 100 times: no change in the database. ✓ Idempotent.
• PUT — PUT {"name": "John"} once → John; 100 times → still John. ✓ Idempotent.
• DELETE — delete once → user removed; delete again → still deleted. ✓ Idempotent. (The second call may return 404 — the response can differ, but the state doesn't.)
• POST — POST /users twice creates two different rows (1 Rahul, 2 Rahul). ✗ Not idempotent.
• PATCH — usually not idempotent. E.g. {"salary": "+1000"} called twice changes the salary twice. Some PATCH operations (setting a field to a fixed value) are idempotent, but the HTTP specification doesn't guarantee it.

#HTTP Status Codes

For POST, prefer:

return ResponseEntity
        .status(HttpStatus.CREATED)
        .body(savedUser);

#Complete REST Controller

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping
    public List<User> getAll() {
        return service.getAll();
    }

    @GetMapping("/{id}")
    public User get(@PathVariable Long id) {
        return service.get(id);
    }

    @PostMapping
    public User save(@RequestBody User user) {
        return service.save(user);
    }

    @PutMapping("/{id}")
    public User update(@PathVariable Long id, @RequestBody User user) {
        return service.update(id, user);
    }

    @PatchMapping("/{id}")
    public User patch(@PathVariable Long id, @RequestBody UserPatchDto dto) {
        return service.patch(id, dto);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> delete(@PathVariable Long id) {
        service.delete(id);
        return ResponseEntity.noContent().build();
    }
}

Complete Request Lifecycle (POST /users)

#Enterprise Example

#Key Takeaways

• @GetMapping, @PostMapping, @PutMapping, @DeleteMapping and @PatchMapping are specialized forms of @RequestMapping.
• GET reads, POST creates, PUT replaces, PATCH partially updates, DELETE deletes.
• Know safe methods, idempotency and status codes — frequent interview topics.
• Design REST APIs around resources (nouns) and let HTTP methods express the action.
• Return appropriate status codes: 200, 201, 204, 400, 404, 409.