Skip to main content

Understanding API Parameters in Spring Boot

Understanding API Parameters in Spring Boot

When designing APIs in Spring Boot, it's essential to understand how to handle different types of parameters. These parameters define how data is sent from the client to the server. Let's break down the common types of parameters used in API development, with examples and cURL commands.

1. Types of Parameters

Parameter Type Location Use Case Example Format Annotation in Spring Boot
Query Param URL after `?` Filtering, Pagination ?key=value @RequestParam
Path Param In the URL path Identifying specific resource /resource/{id} @PathVariable
Form Param Form-encoded body Simple form submissions key=value @RequestParam
Request Body JSON or raw data in body Complex objects or large payloads JSON or XML @RequestBody

2. Examples

1. Query Parameters


@GetMapping("/api/products")
public ResponseEntity<List<Product>> getProducts(@RequestParam String category) {
    return ResponseEntity.ok(productService.getProducts(category));
}
    

cURL:

curl -X GET "http://localhost:8080/api/products?category=electronics"

2. Path Parameters


@GetMapping("/api/products/{id}")
public ResponseEntity<Product> getProductById(@PathVariable Long id) {
    return ResponseEntity.ok(productService.getProductById(id));
}
    

cURL:

curl -X GET "http://localhost:8080/api/products/123"

3. Form Parameters


@PostMapping("/api/products")
public ResponseEntity<Product> createProduct(@RequestParam String name, @RequestParam double price) {
    return ResponseEntity.ok(productService.createProduct(name, price));
}
    

cURL:

curl -X POST "http://localhost:8080/api/products" -d "name=phone&price=50000"

4. Request Body (JSON)


@PostMapping("/api/products")
public ResponseEntity<Product> createProduct(@RequestBody Product product) {
    return ResponseEntity.ok(productService.createProduct(product));
}
    

cURL:

curl -X POST "http://localhost:8080/api/products" -H "Content-Type: application/json" -d '{"name":"phone","price":50000}'

Conclusion

Understanding how to handle query, path, form, and body parameters is essential for building robust APIs in Spring Boot. By selecting the right parameter type for the right scenario, you can create efficient, scalable, and well-structured applications.

Support us

Comments

Popular posts from this blog

Advanced Kafka Resilience: Dead-Letter Queues, Circuit Breakers, and Exactly-Once Delivery

Introduction In distributed systems, failures are inevitable—network partitions, broker crashes, or consumer lag can disrupt data flow. While retries help recover from transient issues, you need stronger guarantees for mission-critical systems. This guide covers three advanced Kafka resilience patterns: Dead-Letter Queues (DLQs) – Handle poison pills and unprocessable messages. Circuit Breakers – Prevent cascading failures when Kafka is unhealthy. Exactly-Once Delivery – Avoid duplicates in financial/transactional systems. Let's dive in! 1. Dead-Letter Queues (DLQs) in Kafka What is a DLQ? A dedicated Kafka topic where "failed" messages are sent after max retries (e.g., malformed payloads, unrecoverable errors). ...

Project Reactor Important Methods Cheat Sheet

🔹 1️⃣ subscribeOn – "Decides WHERE the Pipeline Starts" 📝 Definition: subscribeOn influences the thread where the data source (upstream) (e.g., data generation, API calls) runs . It affects the source and everything downstream (until a publishOn switches it). Flux<Integer> flux = Flux.range(1, 3) .doOnNext(i -> System.out.println("[Generating] " + i + " on " + Thread.currentThread().getName())) .subscribeOn(Schedulers.boundedElastic()) // Change starting thread .map(i -> { System.out.println("[Processing] " + i + " on " + Thread.currentThread().getName()); return i * 10; }); flux.blockLast(); Output: [Generating] 1 on boundedElastic-1 [Processing] 1 on boundedElastic-1 [Generating] 2 on boundedElastic-1 [Processing] 2 on boundedElastic-1 [Generating] 3 on boundedElastic-1 [Processing] 3 on boundedElastic-1 📢 Key Insight: ...

🔄 Kafka Producer Internals: send() Explained with Delivery Semantics and Transactions

Kafka Producer Internal Working Apache Kafka is known for its high-throughput, fault-tolerant message streaming system. At the heart of Kafka's data pipeline is the Producer —responsible for publishing data to Kafka topics. This blog dives deep into the internal workings of the Kafka Producer, especially what happens under the hood when send() is called. We'll also break down different delivery guarantees and transactional semantics with diagrams. 🧠 Table of Contents Kafka Producer Architecture Overview What Happens When send() is Called Delivery Semantics Kafka Transactions & Idempotence Error Handling and Retries Diagram: Kafka Producer Internals Conclusion 🏗️ Kafka Producer Architecture Overview Kafka Producer is composed of the following core components: Serializer : Converts key/value to bytes. Partitioner : Determines which partition a record should go to. Accumulator : Buffers the records in memory be...