El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Gestionant mètodes HTTP

Següent ►
►

En aquest tema, aprendrem com gestionar els diferents mètodes HTTP en una aplicació Spring Boot. Els mètodes HTTP són fonamentals per a la comunicació entre clients i servidors en aplicacions web. Els mètodes més comuns són GET, POST, PUT, DELETE, però n'hi ha d'altres com PATCH, OPTIONS, i HEAD.

Objectius

  • Entendre els diferents mètodes HTTP i les seves funcions.
  • Aprendre a implementar aquests mètodes en controladors Spring Boot.
  • Veure exemples pràctics de cada mètode HTTP.
  • Realitzar exercicis per reforçar els conceptes apresos.

Mètodes HTTP comuns

GET

El mètode GET s'utilitza per sol·licitar dades d'un servidor. És idempotent, el que significa que múltiples sol·licituds GET no haurien de tenir efectes col·laterals.

POST

El mètode POST s'utilitza per enviar dades al servidor per crear un nou recurs. No és idempotent, ja que enviar la mateixa sol·licitud POST diverses vegades pot crear múltiples recursos.

PUT

El mètode PUT s'utilitza per actualitzar un recurs existent o crear-lo si no existeix. És idempotent.

DELETE

El mètode DELETE s'utilitza per eliminar un recurs. És idempotent.

PATCH

El mètode PATCH s'utilitza per aplicar modificacions parcials a un recurs.

OPTIONS

El mètode OPTIONS s'utilitza per descriure les opcions de comunicació per al recurs de destinació.

HEAD

El mètode HEAD és similar a GET, però només retorna les capçaleres de la resposta sense el cos.

Implementació en Spring Boot

Configuració del controlador

A continuació, veurem com implementar aquests mètodes en un controlador Spring Boot.

import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/api/items")
public class ItemController {

    private List<String> items = new ArrayList<>();

    // GET: Obtenir tots els ítems
    @GetMapping
    public List<String> getAllItems() {
        return items;
    }

    // POST: Crear un nou ítem
    @PostMapping
    public String createItem(@RequestBody String item) {
        items.add(item);
        return "Item creat: " + item;
    }

    // PUT: Actualitzar un ítem existent
    @PutMapping("/{index}")
    public String updateItem(@PathVariable int index, @RequestBody String item) {
        if (index >= 0 && index < items.size()) {
            items.set(index, item);
            return "Item actualitzat: " + item;
        } else {
            return "Ítem no trobat";
        }
    }

    // DELETE: Eliminar un ítem
    @DeleteMapping("/{index}")
    public String deleteItem(@PathVariable int index) {
        if (index >= 0 && index < items.size()) {
            String removedItem = items.remove(index);
            return "Item eliminat: " + removedItem;
        } else {
            return "Ítem no trobat";
        }
    }

    // PATCH: Modificar parcialment un ítem
    @PatchMapping("/{index}")
    public String patchItem(@PathVariable int index, @RequestBody String item) {
        if (index >= 0 && index < items.size()) {
            String existingItem = items.get(index);
            String updatedItem = existingItem + item; // Exemple de modificació parcial
            items.set(index, updatedItem);
            return "Item modificat: " + updatedItem;
        } else {
            return "Ítem no trobat";
        }
    }

    // OPTIONS: Descriure les opcions de comunicació
    @RequestMapping(method = RequestMethod.OPTIONS)
    public String options() {
        return "GET, POST, PUT, DELETE, PATCH, OPTIONS";
    }

    // HEAD: Obtenir les capçaleres de la resposta
    @RequestMapping(method = RequestMethod.HEAD)
    public void head() {
        // No cal implementar res aquí, Spring Boot gestionarà les capçaleres automàticament
    }
}

Explicació del codi

  • GET: El mètode getAllItems retorna tots els ítems de la llista.
  • POST: El mètode createItem afegeix un nou ítem a la llista.
  • PUT: El mètode updateItem actualitza un ítem existent a la llista.
  • DELETE: El mètode deleteItem elimina un ítem de la llista.
  • PATCH: El mètode patchItem modifica parcialment un ítem existent.
  • OPTIONS: El mètode options retorna les opcions de comunicació disponibles.
  • HEAD: El mètode head retorna les capçaleres de la resposta sense el cos.

Exercicis pràctics

Exercici 1: Implementar un controlador per gestionar usuaris

Crea un controlador similar a ItemController per gestionar usuaris. Cada usuari ha de tenir un id, nom i email.

Solució

import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

class User {
    private int id;
    private String name;
    private String email;

    // Constructors, getters i setters
    public User(int id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

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

    private List<User> users = new ArrayList<>();

    // GET: Obtenir tots els usuaris
    @GetMapping
    public List<User> getAllUsers() {
        return users;
    }

    // POST: Crear un nou usuari
    @PostMapping
    public String createUser(@RequestBody User user) {
        users.add(user);
        return "Usuari creat: " + user.getName();
    }

    // PUT: Actualitzar un usuari existent
    @PutMapping("/{id}")
    public String updateUser(@PathVariable int id, @RequestBody User user) {
        for (User u : users) {
            if (u.getId() == id) {
                u.setName(user.getName());
                u.setEmail(user.getEmail());
                return "Usuari actualitzat: " + user.getName();
            }
        }
        return "Usuari no trobat";
    }

    // DELETE: Eliminar un usuari
    @DeleteMapping("/{id}")
    public String deleteUser(@PathVariable int id) {
        for (User u : users) {
            if (u.getId() == id) {
                users.remove(u);
                return "Usuari eliminat: " + u.getName();
            }
        }
        return "Usuari no trobat";
    }

    // PATCH: Modificar parcialment un usuari
    @PatchMapping("/{id}")
    public String patchUser(@PathVariable int id, @RequestBody User user) {
        for (User u : users) {
            if (u.getId() == id) {
                if (user.getName() != null) {
                    u.setName(user.getName());
                }
                if (user.getEmail() != null) {
                    u.setEmail(user.getEmail());
                }
                return "Usuari modificat: " + u.getName();
            }
        }
        return "Usuari no trobat";
    }

    // OPTIONS: Descriure les opcions de comunicació
    @RequestMapping(method = RequestMethod.OPTIONS)
    public String options() {
        return "GET, POST, PUT, DELETE, PATCH, OPTIONS";
    }

    // HEAD: Obtenir les capçaleres de la resposta
    @RequestMapping(method = RequestMethod.HEAD)
    public void head() {
        // No cal implementar res aquí, Spring Boot gestionarà les capçaleres automàticament
    }
}

Exercici 2: Provar els mètodes HTTP

Utilitza una eina com Postman per provar els mètodes HTTP del controlador UserController. Crea, actualitza, elimina i modifica usuaris, i comprova que les respostes siguin les esperades.

Resum

En aquesta secció, hem après a gestionar els diferents mètodes HTTP en una aplicació Spring Boot. Hem vist com implementar aquests mètodes en un controlador i hem realitzat exercicis pràctics per reforçar els conceptes apresos. Ara estem preparats per avançar cap a la gestió d'excepcions en serveis RESTful.

◄ Anterior
◄
Següent ►
►

Curs de Spring Boot

Mòdul 1: Introducció a Spring Boot

Mòdul 2: Conceptes bàsics de Spring Boot

Mòdul 3: Construint serveis web RESTful

Mòdul 4: Accés a dades amb Spring Boot

Mòdul 5: Seguretat a Spring Boot

Mòdul 6: Proves a Spring Boot

Mòdul 7: Funcions avançades de Spring Boot

Mòdul 8: Desplegant aplicacions Spring Boot

Mòdul 9: Rendiment i monitorització

Mòdul 10: Millors pràctiques i consells

El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats