Extracting Data with @PathVariable and @RequestParam

The Anatomy of a Dynamic URL

Before we get into the code, let's look at a typical URL for a REST API and break it down. There are two common ways to pass dynamic data in a URL:

1. Path Variables: These are part of the URL path and are used to identify a specific resource. They feel like part of the URL's "address."
2. Request Parameters (or Query Parameters): These appear after a question mark (?) and are used to modify the request, such as for filtering, sorting, or pagination.

The image below provides a perfect visual breakdown.

Let's now explore how to use each of these in Spring Boot.

1. @PathVariable: Identifying a Specific Resource

The @PathVariable annotation is your tool for extracting data embedded directly in the URL's path. Its most common use is to get a unique identifier for a resource. Think of endpoints like /users/{userId} or /orders/{orderId}.

To see this in action, let's look at a clear code example.

As you saw, the implementation is quite intuitive. You define a placeholder in your mapping's path with curly braces {} and then use @PathVariable to bind the value from that part of the URL to a method parameter.

Now, let's watch a video segment that shows this being implemented in a practical scenario: deleting a specific quote by its ID. Although the video uses Kotlin, the annotations and REST concepts are identical to Java.

The equivalent Java code for the deleteQuote method shown in the video would look like this:

@DeleteMapping("/{id}")
public void deleteQuote(@PathVariable Long id) {
    // Logic to find the quote by 'id' and remove it from the list
    quotes.removeIf(quote -> quote.getId().equals(id));
}

This pattern is fundamental in REST API design for any action targeting a single, specific item.

2. @RequestParam: Filtering, Sorting, and Optional Data

While @PathVariable is for required identifiers, @RequestParam is used for extracting data from the query string (e.g., /search?query=spring). This makes it perfect for optional parameters, filters, and sorting controls.

Let's start with a reading that shows the basic usage and, more importantly, how to handle optional parameters and provide default values.

The ability to set required = false and provide a defaultValue is a powerful feature. It allows clients to omit parameters without causing an error, making your API more robust and easier to use.

Now, let's see a practical example of implementing a search filter using @RequestParam.

Here is the Java equivalent of the endpoint that filters quotes:

@GetMapping
public List<QuoteDTO> getQuotes(@RequestParam(value = "q", required = false) String query) {
    if (query != null && !query.isEmpty()) {
        // If a query is provided, filter the list
        return quotes.stream()
                     .filter(quote -> quote.getContent().toLowerCase().contains(query.toLowerCase()))
                     .collect(Collectors.toList());
    } else {
        // Otherwise, return the full list
        return quotes;
    }
}

This filtering logic is a common pattern you'll implement often in backend development.

@GetMapping("/products")
public List<Product> getProducts(
    @RequestParam(value = "page", required = false, defaultValue = "0") int page,
    @RequestParam(value = "limit", required = false, defaultValue = "10") int limit
) {
    // ... implementation to fetch products using pagination ...
    return paginatedListOfProducts;
}

3. @PathVariable vs. @RequestParam: When to Use Which?

Now that you've seen both annotations, let's solidify the distinction. Choosing the right one is key to designing clean, intuitive REST APIs.

This short video provides a fantastic side-by-side comparison.

To dive deeper into the nuances, the following Baeldung article is an excellent resource. It also touches on a subtle point about URL encoding that aligns with your interest in "under the hood" details.

Finally, this comparison table is a great reference to bookmark or save for a quick review.

Conclusion

You've now mastered the essential tools for capturing data passed in a URL. This, combined with your knowledge of @RequestBody from the previous lesson, gives you a complete toolkit for handling inputs in your Spring Boot REST controllers.

Key Takeaways:

• @PathVariable is for extracting required values that are part of the URL path itself. It's semantically tied to identifying a specific resource. (e.g., GET /users/123).
• @RequestParam is for extracting values from the query string. It's ideal for optional parameters used to filter, sort, or paginate a collection of resources. (e.g., GET /users?status=active).
• You can make request parameters optional and provide defaults using @RequestParam(required = false, defaultValue = "...").

What's Next?

So far, we've focused on getting data into our API. But a well-designed API also needs to provide clear, standardized responses. In the next lesson, we will learn how to return appropriate HTTP status codes and headers using ResponseEntity. This will give you fine-grained control over your API's output, allowing you to communicate success, errors, and other states to the client precisely.