HTTP Status Codes in Spring Boot

text
quickcab/
├─ pom.xml
└─ src/main/java/
   └─ com/quickcab/rides/
      ├─ RidesApplication.java
      ├─ RideController.java
      ├─ RideErrors.java
      └─ ErrorAdvice.java

xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>4.1.1</version>
        <relativePath/>
    </parent>

    <groupId>com.quickcab</groupId>
    <artifactId>rides</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <java.version>21</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webmvc</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

java
package com.quickcab.rides;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RidesApplication {

    public static void main(String[] args) {
        SpringApplication.run(RidesApplication.class, args);
    }
}

java
package com.quickcab.rides;

public class RideErrors {

    public static class RideNotFoundException extends RuntimeException {
        public RideNotFoundException(int id) {
            super("Ride " + id + " does not exist");
        }
    }

    public static class InvalidRideException extends RuntimeException {
        public InvalidRideException(String message) {
            super(message);
        }
    }

    public static class NoDriverException extends RuntimeException {
        public NoDriverException() {
            super("No drivers nearby, try again later");
        }
    }
}

java
package com.quickcab.rides;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class ErrorAdvice {

    record ApiError(int status, String error, String message) {}

    private ResponseEntity<ApiError> reply(HttpStatus status, String message) {
        return ResponseEntity.status(status)
                .body(new ApiError(status.value(), status.getReasonPhrase(), message));
    }

    @ExceptionHandler(RideErrors.RideNotFoundException.class)
    public ResponseEntity<ApiError> notFound(RideErrors.RideNotFoundException e) {
        return reply(HttpStatus.NOT_FOUND, e.getMessage());
    }

    @ExceptionHandler(RideErrors.InvalidRideException.class)
    public ResponseEntity<ApiError> invalid(RideErrors.InvalidRideException e) {
        return reply(HttpStatus.BAD_REQUEST, e.getMessage());
    }

    @ExceptionHandler(RideErrors.NoDriverException.class)
    public ResponseEntity<ApiError> noDriver(RideErrors.NoDriverException e) {
        return reply(HttpStatus.SERVICE_UNAVAILABLE, e.getMessage());
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ApiError> other(Exception e) {
        return reply(HttpStatus.INTERNAL_SERVER_ERROR, "Something went wrong");
    }
}

java
package com.quickcab.rides;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/rides")
public class RideController {

    record Ride(int id, String pickup, String drop) {}
    record RideRequest(String pickup, String drop) {}

    private final Map<Integer, Ride> rides = new ConcurrentHashMap<>();
    private final AtomicInteger nextId = new AtomicInteger(1);

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Ride book(@RequestBody RideRequest request) {
        if (request.pickup().equals(request.drop())) {
            throw new RideErrors.InvalidRideException("Pickup and drop are the same");
        }
        if (request.pickup().equals("Outskirts")) {
            throw new RideErrors.NoDriverException();
        }
        Ride ride = new Ride(nextId.getAndIncrement(), request.pickup(), request.drop());
        rides.put(ride.id(), ride);
        return ride;
    }

    @GetMapping("/{id}")
    public Ride one(@PathVariable int id) {
        Ride ride = rides.get(id);
        if (ride == null) {
            throw new RideErrors.RideNotFoundException(id);
        }
        return ride;
    }

    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void cancel(@PathVariable int id) {
        if (rides.remove(id) == null) {
            throw new RideErrors.RideNotFoundException(id);
        }
    }

    @GetMapping("/crash")
    public String crash() {
        throw new IllegalStateException("backend is down");
    }
}

bash
mvn spring-boot:run
curl -s -w " %{http_code}\n" -X POST localhost:8080/rides -H "Content-Type: application/json" -d '{"pickup":"Station","drop":"Airport"}'
curl -s -w " %{http_code}\n" -X POST localhost:8080/rides -H "Content-Type: application/json" -d '{"pickup":"Station","drop":"Station"}'
curl -s -w " %{http_code}\n" -X POST localhost:8080/rides -H "Content-Type: application/json" -d '{"pickup":"Outskirts","drop":"Mall"}'
curl -s -w " %{http_code}\n" localhost:8080/rides/9
curl -s -w " %{http_code}\n" localhost:8080/rides/crash
curl -s -o /dev/null -w "%{http_code}\n" -X DELETE localhost:8080/rides/1
curl -s -o /dev/null -w "%{http_code}\n" -X PUT localhost:8080/rides/1

text
201
400
503
404
500
204
500

json
{
  "status": 400,
  "error": "Bad Request",
  "message": "Pickup and drop are the same"
}

json
{
  "status": 404,
  "error": "Not Found",
  "message": "Ride 9 does not exist"
}