@PathVariable for URL parameters in Spring Boot - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the @PathVariable annotation in Spring Boot?

The @PathVariable annotation is used to extract values from the URL path and bind them to method parameters in a controller. It helps get dynamic parts of the URL as variables.

beginner

How do you define a method parameter to capture a URL segment named id using @PathVariable?

You add @PathVariable("id") before the method parameter. For example: public String getUser(@PathVariable("id") String id).

intermediate

Can @PathVariable be used without specifying the variable name inside the parentheses? When?

Yes, if the method parameter name matches the path variable name in the URL template, you can omit the name in @PathVariable. For example, if the URL is /user/{id} and the parameter is String id, just use @PathVariable String id.

beginner

What happens if a URL does not contain the expected path variable when using @PathVariable?

Spring Boot will return a 404 error because the URL does not match the expected pattern that includes the path variable.

intermediate

How can you handle multiple @PathVariable parameters in a single controller method?

You can add multiple parameters each annotated with @PathVariable matching the URL template. For example: @GetMapping("/order/{orderId}/item/{itemId}") with method parameters @PathVariable String orderId, @PathVariable String itemId.

What does @PathVariable do in a Spring Boot controller?

A Reads query parameters from the URL

B Extracts values from the URL path and binds them to method parameters

C Handles form data submission

D Defines the HTTP method type

@PathVariable extracts dynamic parts of the URL path, not query parameters or form data.

Given the URL /user/42 and mapping @GetMapping("/user/{id}"), how do you capture 42 in the method?

A Use <code>@PathVariable("id") String id</code> as a parameter

B Use <code>@RequestParam("id") String id</code>

C Use <code>@RequestBody String id</code>

D Use <code>@CookieValue("id") String id</code>

The @PathVariable annotation captures the value from the URL path segment.

If the method parameter name matches the path variable name, how can you simplify @PathVariable usage?

A Omit the variable name inside <code>@PathVariable</code>

B Remove <code>@PathVariable</code> entirely

C Use <code>@RequestParam</code> instead

D Use <code>@PathVariable("differentName")</code>

You can omit the name if the parameter name matches the path variable name exactly.

What HTTP status code does Spring Boot return if a required @PathVariable is missing in the URL?

A 500 Internal Server Error

B 400 Bad Request

C 404 Not Found

D 200 OK

Spring Boot returns 404 because the URL pattern does not match the expected route.

How do you handle multiple path variables in a URL like /order/{orderId}/item/{itemId}?

A Use <code>@RequestBody</code> to get both variables

B Use a single <code>@PathVariable</code> with a list

C Use <code>@RequestParam</code> for both variables

D Add multiple <code>@PathVariable</code> parameters matching each variable

Each path variable needs its own @PathVariable parameter in the method.

Explain how @PathVariable works in Spring Boot and how you use it to get data from the URL.

Think about how you get the 'id' from a URL like /user/123.

Describe what happens if the URL does not include the expected path variable when using @PathVariable in a controller.

Consider what happens when you visit a URL missing a required part.

Practice

1. What is the main purpose of the @PathVariable annotation in Spring Boot?

easy

A. To bind form data to a Java object

B. To handle exceptions in controller methods

C. To define a fixed URL mapping for a controller method

D. To extract values from the URL path and pass them as method parameters

Solution

1. Step 1: Understand the role of @PathVariable

   @PathVariable is used to get dynamic parts of the URL and pass them to method parameters.

2. Step 2: Compare with other annotations

   Other options like binding form data or exception handling are done by different annotations, not @PathVariable.

3. Final Answer:

   To extract values from the URL path and pass them as method parameters -> Option D

4. Quick Check:

   @PathVariable = extract URL values [OK]

Hint: Remember: @PathVariable grabs values directly from URL path [OK]

Common Mistakes:

• Confusing @PathVariable with @RequestParam
• Thinking it binds form data
• Assuming it handles exceptions

2. Which of the following is the correct syntax to use @PathVariable in a Spring Boot controller method to get an id from the URL /user/{id}?

easy

A. @GetMapping("/user/{id}") public String getUser(@PathVariable int id) { ... }

B. @GetMapping("/user") public String getUser(@PathVariable int id) { ... }

C. @GetMapping("/user/{id}") public String getUser(@RequestParam int id) { ... }

D. @GetMapping("/user/{id}") public String getUser(@PathVariable String name) { ... }

Solution

1. Step 1: Match URL pattern with method parameter

   The URL has {id}, so the method must have @PathVariable int id to match the placeholder.

2. Step 2: Check annotation and parameter type

   @GetMapping("/user/{id}") public String getUser(@PathVariable int id) { ... } correctly uses @PathVariable with int id and matches the URL pattern.

3. Final Answer:

   @GetMapping("/user/{id}") public String getUser(@PathVariable int id) { ... } -> Option A

4. Quick Check:

   URL {id} matches @PathVariable int id [OK]

Hint: URL placeholder and @PathVariable name must match [OK]

Common Mistakes:

• Missing {id} in URL path
• Using @RequestParam instead of @PathVariable
• Mismatching parameter name and URL placeholder

3. Given the following Spring Boot controller method:

@GetMapping("/product/{category}/{id}")
public String getProduct(@PathVariable String category, @PathVariable int id) {
    return category + "-" + id;
}

What will be the output when a client requests /product/electronics/42?

medium

A. electronics-42

B. 42-electronics

C. category-id

D. electronics42

Solution

1. Step 1: Identify parameter values from URL

   URL /product/electronics/42 means category = "electronics", id = 42.

2. Step 2: Understand return statement

   The method returns category + "-" + id, so it returns "electronics-42".

3. Final Answer:

   electronics-42 -> Option A

4. Quick Check:

   Return = category + "-" + id = electronics-42 [OK]

Hint: Match URL parts to parameters in order [OK]

Common Mistakes:

• Swapping parameter order
• Ignoring the dash '-' in return
• Confusing @PathVariable with @RequestParam

4. Consider this Spring Boot controller method:

@GetMapping("/order/{orderId}")
public String getOrder(@PathVariable int id) {
    return "Order: " + id;
}

What will happen when a client requests /order/100?

medium

A. Returns "Order: 0"

B. Returns "Order: 100"

C. Throws an error because parameter name does not match path variable

D. Returns null

Solution

1. Step 1: Check URL placeholder and method parameter names

   URL has {orderId}, but method parameter is named id without specifying name in @PathVariable.

2. Step 2: Understand default matching behavior

   Without specifying the name in @PathVariable, Spring tries to match parameter name to path variable name. They differ, causing an error.

3. Final Answer:

   Throws an error because parameter name does not match path variable -> Option C

4. Quick Check:

   Parameter name must match path variable or specify name [OK]

Hint: Parameter name must match path variable or use @PathVariable("name") [OK]

Common Mistakes:

• Assuming names can differ without annotation
• Ignoring the need to specify variable name in @PathVariable
• Expecting default value assignment

5. You want to create a Spring Boot controller method that handles URLs like /blog/{year}/{month}/{slug} where year and month are integers and slug is a string. Which of the following method signatures correctly uses @PathVariable to extract these values?

hard

A. @GetMapping("/blog/{year}/{month}/{slug}")
public String getPost(@PathVariable int yr, @PathVariable int mo, @PathVariable String sl) { ... }

B. @GetMapping("/blog/{year}/{month}/{slug}")
public String getPost(@PathVariable("year") int y, @PathVariable("month") int m, @PathVariable("slug") String s) { ... }

C. @GetMapping("/blog/{year}/{month}/{slug}")
public String getPost(@PathVariable String year, @PathVariable String month, @PathVariable String slug) { ... }

D. @GetMapping("/blog/{year}/{month}/{slug}")
public String getPost(@PathVariable int y, @PathVariable int m, @PathVariable String s) { ... }

Solution

1. Step 1: Match URL placeholders with method parameters

   The URL has {year}, {month}, {slug}. Method parameters must match these names or specify them explicitly.

2. Step 2: Check parameter names and @PathVariable usage

   @GetMapping("/blog/{year}/{month}/{slug}") public String getPost(@PathVariable("year") int y, @PathVariable("month") int m, @PathVariable("slug") String s) { ... } uses different parameter names (y, m, s) but explicitly maps them to URL placeholders using @PathVariable("name"), which is correct.

3. Final Answer:

   @GetMapping("/blog/{year}/{month}/{slug}") public String getPost(@PathVariable("year") int y, @PathVariable("month") int m, @PathVariable("slug") String s) { ... } -> Option B

4. Quick Check:

   Explicit name mapping allows different parameter names [OK]

Hint: Use @PathVariable("name") if parameter name differs from URL placeholder [OK]

Common Mistakes:

• Using mismatched parameter names without specifying name
• Using wrong data types for year/month
• Assuming parameter names must always match URL placeholders