[Spring Boot Basics] Nhận và trả dữ liệu trong Spring Boot: @PathVariable, @RequestParam, @RequestBody, @RequestHeader và ResponseEntity

package com.example.demo.product;
 
public enum Category {
    BOOKS, ELECTRONICS, GROCERY
}

package com.example.demo.product;
 
import java.math.BigDecimal;
 
public record Product(Long id, String name, BigDecimal price, Category category) {
}

package com.example.demo.product;
 
import java.math.BigDecimal;
 
public record ProductRequest(String name, BigDecimal price, Category category) {
}

package com.example.demo.product;
 
import java.math.BigDecimal;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
 
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("/api/products")
public class ProductController {
 
    private final Map<Long, Product> products = new ConcurrentHashMap<>();
    private final AtomicLong sequence = new AtomicLong();
 
    public ProductController() {
        add(new ProductRequest("Clean Code", new BigDecimal("32.50"), Category.BOOKS));
        add(new ProductRequest("Mechanical Keyboard", new BigDecimal("89.90"), Category.ELECTRONICS));
        add(new ProductRequest("Arabica Coffee Beans", new BigDecimal("14.20"), Category.GROCERY));
    }
 
    @GetMapping
    public List<Product> findAll() {
        return products.values().stream()
                .sorted(Comparator.comparing(Product::id))
                .toList();
    }
 
    @GetMapping("/{id}")
    public Product findById(@PathVariable Long id) {
        return products.get(id);
    }
 
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Product create(@RequestBody ProductRequest request) {
        return add(request);
    }
 
    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void delete(@PathVariable Long id) {
        products.remove(id);
    }
 
    private Product add(ProductRequest request) {
        long id = sequence.incrementAndGet();
        Product product = new Product(id, request.name(), request.price(), request.category());
        products.put(id, product);
        return product;
    }
}

curl -i http://localhost:8117/api/products/99

HTTP/1.1 200
Content-Length: 0
Date: Sat, 12 Sep 2026 07:01:33 GMT

curl -i -X DELETE http://localhost:8117/api/products/99

HTTP/1.1 204
Date: Sat, 12 Sep 2026 07:01:33 GMT

package com.example.demo.echo;
 
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
 
import com.example.demo.product.ProductRequest;
 
@RestController
public class EchoController {
 
    public record Bound(Long id, boolean dryRun, String requestId, ProductRequest body) {
    }
 
    @PutMapping("/echo/products/{id}")
    public Bound echo(
            @PathVariable Long id,
            @RequestParam boolean dryRun,
            @RequestHeader("X-Request-Id") String requestId,
            @RequestBody ProductRequest body) {
        return new Bound(id, dryRun, requestId, body);
    }
}

curl -i -X PUT "http://localhost:8117/echo/products/42?dryRun=true" \
  -H "Content-Type: application/json" \
  -H "X-Request-Id: 7f3a9c" \
  -d '{"name":"Mechanical Keyboard","price":89.90,"category":"ELECTRONICS"}'

HTTP/1.1 200
Content-Type: application/json
Content-Length: 121
Date: Sat, 12 Sep 2026 07:01:33 GMT
 
{"id":42,"dryRun":true,"requestId":"7f3a9c","body":{"name":"Mechanical Keyboard","price":89.90,"category":"ELECTRONICS"}}

> PUT /echo/products/42?dryRun=true HTTP/1.1
> Host: localhost:8117
> User-Agent: curl/8.7.1
> Accept: */*
> Content-Type: application/json
> X-Request-Id: 7f3a9c
> Content-Length: 69
>

package com.example.demo.lab;
 
import java.math.BigDecimal;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
 
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.CookieValue;
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.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
import org.springframework.web.util.UriComponentsBuilder;
 
import com.example.demo.product.Category;
import com.example.demo.product.ProductRequest;
 
import jakarta.servlet.http.HttpServletRequest;
 
@RestController
@RequestMapping("/lab")
public class LabController {
 
    // the methods from the following sections go here
}

@GetMapping("/request-info")
public String requestInfo(HttpServletRequest request, HttpMethod method, Locale locale,
                          UriComponentsBuilder uriBuilder) {
    return "request=" + request.getRequestURI() + "?" + request.getQueryString()
            + ", method=" + method
            + ", locale=" + locale
            + ", uriBuilder=" + uriBuilder.toUriString() + "\n";
}

curl "http://localhost:8117/lab/request-info?page=2" -H "Accept-Language: vi-VN"

request=/lab/request-info?page=2, method=GET, locale=vi_VN, uriBuilder=http://localhost:8117

@GetMapping("/unannotated-headers")
public String unannotatedHeaders(HttpHeaders headers) {
    return "size=" + headers.size() + ", names=" + headers.headerNames() + "\n";
}

curl http://localhost:8117/lab/unannotated-headers -H "X-Request-Id: 7f3a9c"

size=0, names=[]

curl "http://localhost:8117/lab/unannotated-headers?contentLength=5" -H "X-Request-Id: 7f3a9c"

size=1, names=[Content-Length]

@GetMapping("/{id}")
public Product findById(@PathVariable Long id) {
    return products.get(id);
}

curl -i http://localhost:8117/api/products/1

HTTP/1.1 200
Content-Type: application/json
Content-Length: 61
Date: Sat, 12 Sep 2026 07:01:33 GMT
 
{"id":1,"name":"Clean Code","price":32.50,"category":"BOOKS"}

./gradlew compileJava --rerun --debug | grep "Compiler arguments"

Compiler arguments: -source 21 -target 21 -d <project>/build/classes/java/main -encoding UTF-8 -h <project>/build/generated/sources/headers/java/main -g -sourcepath "" -proc:none -s <project>/build/generated/sources/annotationProcessor/java/main -XDuseUnsharedTable=true -classpath <classpath> -parameters <source files>

javap -p -constants -cp spring-boot-gradle-plugin-4.1.1.jar org.springframework.boot.gradle.plugin.JavaPluginAction | grep -i parameters

  private static final java.lang.String PARAMETERS_COMPILER_ARG = "-parameters";
  private void configureParametersCompilerArg(org.gradle.api.Project);
  private static void lambda$configureParametersCompilerArg$0(org.gradle.api.tasks.compile.JavaCompile);

      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      14     0  this   Lcom/example/demo/product/ProductController;
            0      14     1    id   Ljava/lang/Long;
    MethodParameters:
      Name                           Flags
      id

tasks.named('test') {
	useJUnitPlatform()
}
 
tasks.withType(JavaCompile).configureEach { 
	options.compilerArgs.remove('-parameters') 
} 

curl -i http://localhost:8117/api/products/1

HTTP/1.1 500
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 12 Sep 2026 07:05:07 GMT
Connection: close
 
{"timestamp":"2026-09-12T07:05:07.283Z","status":500,"error":"Internal Server Error","path":"/api/products/1"}

2026-09-12T14:05:07.280+07:00 ERROR 37195 --- [demo] [nio-8117-exec-3] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed: java.lang.IllegalArgumentException: Name for argument of type [java.lang.Long] not specified, and parameter name information not available via reflection. Ensure that the compiler uses the '-parameters' flag.] with root cause
 
java.lang.IllegalArgumentException: Name for argument of type [java.lang.Long] not specified, and parameter name information not available via reflection. Ensure that the compiler uses the '-parameters' flag.
	at org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver.updateNamedValueInfo(AbstractNamedValueMethodArgumentResolver.java:184) ~[spring-web-7.0.9.jar!/:7.0.9]

@GetMapping("/explicit/{id}")
public String explicit(@PathVariable("id") Long id, @RequestParam("q") String q) {
    return "id=" + id + ", q=" + q;
}

@GetMapping("/categories/{category}/products/{id}")
public String productInCategory(@PathVariable Category category,
                                @PathVariable("id") Long productId) {
    return "category=" + category + ", productId=" + productId;
}

curl http://localhost:8117/lab/categories/BOOKS/products/1

category=BOOKS, productId=1

@GetMapping("/reviews/{reviewId}")
public String review(@PathVariable Long id) {
    return "id=" + id;
}

curl -i http://localhost:8117/lab/reviews/7

HTTP/1.1 500
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 12 Sep 2026 07:01:33 GMT
Connection: close
 
{"timestamp":"2026-09-12T07:01:33.326Z","status":500,"error":"Internal Server Error","path":"/lab/reviews/7"}

2026-09-12T14:01:33.326+07:00  WARN 34784 --- [demo] [nio-8117-exec-9] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.web.bind.MissingPathVariableException: Required URI template variable 'id' for method parameter type Long is not present]

@GetMapping({"/stock", "/stock/{warehouse}"})
public String stock(@PathVariable(required = false) String warehouse) {
    return "warehouse=" + warehouse;
}
 
@GetMapping({"/shipping", "/shipping/{zone}"})
public String shipping(@PathVariable Optional<String> zone) {
    return "zone=" + zone;
}
 
@GetMapping({"/returns", "/returns/{reason}"})
public String returns(@PathVariable String reason) {
    return "reason=" + reason;
}

curl -i http://localhost:8117/api/products/abc

HTTP/1.1 400
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 12 Sep 2026 07:01:33 GMT
Connection: close
 
{"timestamp":"2026-09-12T07:01:33.226Z","status":400,"error":"Bad Request","path":"/api/products/abc"}

2026-09-12T14:01:33.223+07:00  WARN 34784 --- [demo] [io-8117-exec-10] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.web.method.annotation.MethodArgumentTypeMismatchException: Method parameter 'id': Failed to convert value of type 'java.lang.String' to required type 'java.lang.Long'; For input string: "abc"]

@GetMapping("/orders/{orderId}")
public String order(@PathVariable UUID orderId) {
    return "orderId=" + orderId + ", version=" + orderId.version();
}

@GetMapping("/search")
public String search(@RequestParam String q,
                     @RequestParam(defaultValue = "name") String sort,
                     @RequestParam(required = false) BigDecimal minPrice,
                     @RequestParam Optional<BigDecimal> maxPrice) {
    return "q=" + q + ", sort=" + sort + ", minPrice=" + minPrice + ", maxPrice=" + maxPrice;
}

curl "http://localhost:8117/lab/search?q=coffee"

q=coffee, sort=name, minPrice=null, maxPrice=Optional.empty

curl "http://localhost:8117/lab/search?q=coffee&sort=price&minPrice=10&maxPrice=20"

q=coffee, sort=price, minPrice=10, maxPrice=Optional[20]

curl -i http://localhost:8117/lab/search

HTTP/1.1 400
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 12 Sep 2026 07:01:33 GMT
Connection: close
 
{"timestamp":"2026-09-12T07:01:33.335Z","status":400,"error":"Bad Request","path":"/lab/search"}

2026-09-12T14:01:33.335+07:00  WARN 34784 --- [demo] [io-8117-exec-10] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.web.bind.MissingServletRequestParameterException: Required request parameter 'q' for method parameter type String is not present]

@GetMapping("/page")
public String page(@RequestParam(required = false) int limit) {
    return "limit=" + limit;
}

curl -i http://localhost:8117/lab/page

HTTP/1.1 500
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 12 Sep 2026 07:01:33 GMT
Connection: close
 
{"timestamp":"2026-09-12T07:01:33.392Z","status":500,"error":"Internal Server Error","path":"/lab/page"}

2026-09-12T14:01:33.390+07:00 ERROR 34784 --- [demo] [io-8117-exec-10] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed: java.lang.IllegalStateException: Optional int parameter 'limit' is present but cannot be translated into a null value due to being declared as a primitive type. Consider declaring it as object wrapper for the corresponding primitive type.] with root cause
 
java.lang.IllegalStateException: Optional int parameter 'limit' is present but cannot be translated into a null value due to being declared as a primitive type. Consider declaring it as object wrapper for the corresponding primitive type.
	at org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver.handleNullValue(AbstractNamedValueMethodArgumentResolver.java:266) ~[spring-web-7.0.9.jar!/:7.0.9]

@GetMapping("/page-default")
public String pageDefault(@RequestParam(defaultValue = "20") int limit) {
    return "limit=" + limit;
}

@GetMapping("/tags")
public String tags(@RequestParam List<String> tag) {
    return "tag=" + tag + ", size=" + tag.size();
}

@GetMapping("/params")
public String params(@RequestParam Map<String, String> single,
                     @RequestParam MultiValueMap<String, String> multi) {
    return "Map=" + single + "\nMultiValueMap=" + multi + "\n";
}

curl "http://localhost:8117/lab/params?q=coffee&tag=java&tag=spring"

Map={q=coffee, tag=java}
MultiValueMap={q=[coffee], tag=[java, spring]}

@GetMapping("/by-category")
public String byCategory(@RequestParam Category category) {
    return "category=" + category;
}

@PostMapping("/form")
public String form(@RequestParam String name, @RequestParam BigDecimal price) {
    return "name=" + name + ", price=" + price;
}
 
@PutMapping("/form")
public String formPut(@RequestParam String name, @RequestParam BigDecimal price) {
    return "PUT name=" + name + ", price=" + price;
}

curl -X POST http://localhost:8117/lab/form -d "name=Desk+Lamp&price=24.00"

name=Desk Lamp, price=24.00

@GetMapping("/headers")
public String headers(@RequestHeader("X-Request-Id") String requestId,
                      @RequestHeader(name = "Accept-Language", defaultValue = "en") String language) {
    return "requestId=" + requestId + ", language=" + language;
}

curl http://localhost:8117/lab/headers -H "X-Request-Id: 7f3a9c"

requestId=7f3a9c, language=en

curl http://localhost:8117/lab/headers -H "x-request-id: 7f3a9c" -H "Accept-Language: vi-VN"

requestId=7f3a9c, language=vi-VN

@GetMapping("/header-number")
public String headerNumber(@RequestHeader("X-Page") int page) {
    return "page=" + page;
}

@GetMapping("/all-headers")
public String allHeaders(@RequestHeader HttpHeaders headers) {
    return "size=" + headers.size()
            + ", names=" + headers.headerNames()
            + ", user-agent=" + headers.getFirst("user-agent")
            + ", accept=" + headers.getAccept() + "\n";
}

curl http://localhost:8117/lab/all-headers -H "X-Request-Id: 7f3a9c"

size=4, names=[Host, User-Agent, Accept, X-Request-Id], user-agent=curl/8.7.1, accept=[*/*]

@GetMapping("/theme")
public String theme(@CookieValue("theme") String theme) {
    return "theme=" + theme;
}

curl http://localhost:8117/lab/theme -b "theme=dark"

theme=dark

curl -i -X POST http://localhost:8117/api/products \
  -H "Content-Type: application/json" \
  -d '{"name":"Desk Lamp","price":24.00,"category":"ELECTRONICS"}'

HTTP/1.1 201
Content-Type: application/json
Content-Length: 66
Date: Sat, 12 Sep 2026 07:01:33 GMT
 
{"id":4,"name":"Desk Lamp","price":24.00,"category":"ELECTRONICS"}

curl -i -X POST http://localhost:8117/api/products \
  -d '{"name":"Desk Lamp","price":24.00,"category":"ELECTRONICS"}'

HTTP/1.1 415
Accept: application/json, application/*+json
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 12 Sep 2026 07:01:33 GMT
 
{"timestamp":"2026-09-12T07:01:33.639Z","status":415,"error":"Unsupported Media Type","path":"/api/products"}

2026-09-12T14:01:33.638+07:00  WARN 34784 --- [demo] [nio-8117-exec-6] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.web.HttpMediaTypeNotSupportedException: Content-Type 'application/x-www-form-urlencoded;charset=UTF-8' is not supported]

@PostMapping("/optional-body")
public String optionalBody(@RequestBody(required = false) ProductRequest request) {
    return "request=" + request;
}

@PostMapping("/imports")
public ResponseEntity<Map<String, String>> startImport() {
    return ResponseEntity.status(HttpStatus.ACCEPTED)
            .header("X-Import-Id", "imp-42")
            .body(Map.of("status", "QUEUED"));
}

curl -i -X POST http://localhost:8117/lab/imports

HTTP/1.1 202
X-Import-Id: imp-42
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 12 Sep 2026 07:01:33 GMT
 
{"status":"QUEUED"}

@GetMapping("/featured")
public ResponseEntity<String> featured(@RequestParam(defaultValue = "false") boolean empty) {
    Optional<String> featured = empty ? Optional.empty() : Optional.of("Clean Code");
    return ResponseEntity.of(featured);
}

curl -i "http://localhost:8117/lab/featured?empty=true"

HTTP/1.1 404
Content-Length: 0
Date: Sat, 12 Sep 2026 07:01:33 GMT

@GetMapping("/which-status")
@ResponseStatus(HttpStatus.CREATED)
public ResponseEntity<String> whichStatus() {
    return ResponseEntity.ok("ResponseEntity said 200");
}

curl -i http://localhost:8117/lab/which-status

HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 23
Date: Sat, 12 Sep 2026 07:01:33 GMT
 
ResponseEntity said 200

package com.example.demo.product;
 
import java.math.BigDecimal;
import java.net.URI; 
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional; 
import java.util.UUID; 
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
 
import org.springframework.http.HttpStatus; 
import org.springframework.http.ResponseEntity; 
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.RequestHeader; 
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; 
import org.springframework.web.bind.annotation.ResponseStatus; 
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder; 
 
@RestController
@RequestMapping("/api/products")
public class ProductController {
 
    private final Map<Long, Product> products = new ConcurrentHashMap<>();
    private final AtomicLong sequence = new AtomicLong();
 
    public ProductController() {
        add(new ProductRequest("Clean Code", new BigDecimal("32.50"), Category.BOOKS));
        add(new ProductRequest("Mechanical Keyboard", new BigDecimal("89.90"), Category.ELECTRONICS));
        add(new ProductRequest("Arabica Coffee Beans", new BigDecimal("14.20"), Category.GROCERY));
    }
 
    @GetMapping
    public List<Product> findAll() { 
    public List<Product> findAll(@RequestParam(required = false) Category category, 
                                 @RequestParam(required = false) BigDecimal minPrice) { 
        return products.values().stream()
                .filter(p -> category == null || p.category() == category) 
                .filter(p -> minPrice == null || p.price().compareTo(minPrice) >= 0) 
                .sorted(Comparator.comparing(Product::id))
                .toList();
    }
 
    @GetMapping("/{id}")
    public Product findById(@PathVariable Long id) { 
        return products.get(id); 
    public ResponseEntity<Product> findById(@PathVariable Long id) { 
        return ResponseEntity.of(Optional.ofNullable(products.get(id))); 
    }
 
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED) 
    public Product create(@RequestBody ProductRequest request) { 
        return add(request); 
    public ResponseEntity<Product> create(@RequestBody ProductRequest request, 
                                          @RequestHeader("X-Request-Id") Optional<String> requestId) { 
        Product product = add(request); 
        URI location = ServletUriComponentsBuilder.fromCurrentRequest() 
                .path("/{id}") 
                .buildAndExpand(product.id()) 
                .toUri(); 
        return ResponseEntity.created(location) 
                .header("X-Request-Id", requestId.orElseGet(() -> UUID.randomUUID().toString())) 
                .body(product); 
    }
 
    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT) 
    public void delete(@PathVariable Long id) { 
        products.remove(id); 
    public ResponseEntity<Void> delete(@PathVariable Long id) { 
        if (products.remove(id) == null) { 
            return ResponseEntity.notFound().build(); 
        } 
        return ResponseEntity.noContent().build(); 
    }
 
    private Product add(ProductRequest request) {
        long id = sequence.incrementAndGet();
        Product product = new Product(id, request.name(), request.price(), request.category());
        products.put(id, product);
        return product;
    }
}

curl -i -X POST http://localhost:8117/api/products \
  -H "Content-Type: application/json" \
  -H "X-Request-Id: 7f3a9c" \
  -d '{"name":"Desk Lamp","price":24.00,"category":"ELECTRONICS"}'

HTTP/1.1 201
Location: http://localhost:8117/api/products/4
X-Request-Id: 7f3a9c
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 12 Sep 2026 07:05:08 GMT
 
{"id":4,"name":"Desk Lamp","price":24.00,"category":"ELECTRONICS"}

HTTP/1.1 201
Location: http://localhost:8117/api/products/5
X-Request-Id: 2e37d6d3-49bb-4883-bdb7-97129cdf42ca

@PostMapping("/uris")
public String uris() {
    return "fromCurrentRequest()    -> "
            + ServletUriComponentsBuilder.fromCurrentRequest().path("/{id}").buildAndExpand(6).toUri()
            + "\nfromCurrentRequestUri() -> "
            + ServletUriComponentsBuilder.fromCurrentRequestUri().path("/{id}").buildAndExpand(6).toUri()
            + "\n";
}

fromCurrentRequest()    -> http://localhost:8117/lab/uris/6?source=import
fromCurrentRequestUri() -> http://localhost:8117/lab/uris/6

curl -i http://localhost:8117/api/products/99

HTTP/1.1 404
Content-Length: 0
Date: Sat, 12 Sep 2026 07:05:08 GMT

curl -i -X DELETE http://localhost:8117/api/products/4

HTTP/1.1 204
Date: Sat, 12 Sep 2026 07:05:08 GMT

HTTP/1.1 404
Content-Length: 0
Date: Sat, 12 Sep 2026 07:05:08 GMT

curl -i "http://localhost:8117/api/products?category=BOOKS"

HTTP/1.1 200
Content-Type: application/json
Content-Length: 126
Date: Sat, 12 Sep 2026 07:05:08 GMT
 
[{"id":1,"name":"Clean Code","price":32.50,"category":"BOOKS"},{"id":6,"name":"Refactoring","price":41.00,"category":"BOOKS"}]

curl "http://localhost:8117/api/products?minPrice=20"

[{"id":1,"name":"Clean Code","price":32.50,"category":"BOOKS"},{"id":2,"name":"Mechanical Keyboard","price":89.90,"category":"ELECTRONICS"},{"id":6,"name":"Refactoring","price":41.00,"category":"BOOKS"}]

curl "http://localhost:8117/api/products?category=ELECTRONICS&minPrice=50"

[{"id":2,"name":"Mechanical Keyboard","price":89.90,"category":"ELECTRONICS"}]