Spring Boot - Request Parsing - Guided Exercise: API Input Mastery: Unlocking Data from Every Corner!

[akash-coded]

🧩 Guided Exercise: "API Input Mastery: Unlocking Data from Every Corner!"

🧠 Concepts Covered

• @RequestParam
• @PathVariable
• @RequestBody
• Mixed usage and edge cases
• Differences, best practices, and real-world examples

---

🎯 Goal

Build a Spring Boot mini-API called SmartUserAPI, which performs basic user operations using all types of input mechanisms.

---

🧱 Project Setup

Dependencies via start.spring.io:

• Spring Web
• Lombok
• Spring Boot DevTools

Port: 8082
Update in application.properties:

server.port=8082
spring.application.name=SmartUserAPI

---

🗂️ Folder Structure

src/main/java/com/example/smartuser/
├── controller/
│   └── UserController.java
├── model/
│   └── User.java
├── dto/
│   └── UserDTO.java
└── SmartUserApiApplication.java

---

1️⃣ Step 1: Create the User Model

package com.example.smartuser.model;

import lombok.*;

@Getter @Setter @NoArgsConstructor @AllArgsConstructor @ToString
public class User {
    private int id;
    private String name;
    private int age;
    private String city;
}

---

2️⃣ Step 2: Expose GET with @RequestParam

Task: Fetch greeting message with a user’s name via query param.

// In UserController.java
@GetMapping("/greet")
public String greetUser(@RequestParam String name) {
    return "Hello, " + name + "! Welcome to SmartUserAPI.";
}

🧩 Try this in Postman:

GET http://localhost:8082/greet?name=Akash

---

3️⃣ Step 3: Use @PathVariable to Get User Info by ID

@GetMapping("/user/{id}")
public String getUserById(@PathVariable int id) {
    return "Fetching user with ID: " + id;
}

Try:

GET http://localhost:8082/user/101

---

4️⃣ Step 4: Post User Data using @RequestBody

@PostMapping("/user")
public String createUser(@RequestBody User user) {
    return "User Created: " + user.toString();
}

🧪 Try this in Postman:

• Method: POST
• URL: http://localhost:8082/user
• Body (JSON):

{
  "id": 1,
  "name": "Riya",
  "age": 25,
  "city": "Bangalore"
}

---

5️⃣ Step 5: Mixed Usage: @RequestParam + @PathVariable + @RequestBody

@PostMapping("/user/{id}/update")
public String updateUser(
        @PathVariable int id,
        @RequestParam String city,
        @RequestBody User user) {
    return "Updated user " + id + " in city " + city + " with data: " + user;
}

🧪 Postman:

• URL: http://localhost:8082/user/1/update?city=Delhi
• Body:

{
  "id": 1,
  "name": "Riya",
  "age": 26,
  "city": "Delhi"
}

---

🧠 Recap Questions

1. When should you use @RequestParam over @PathVariable?
2. What if the query param is optional?
3. Why does @RequestBody only work with POST/PUT methods?
4. How does Spring parse JSON into a Java object?

---

📌 Bonus Challenge

Implement validation:

@PostMapping("/user")
public ResponseEntity<String> createUser(@RequestBody @Valid User user) {
    ...
}

Add:

import javax.validation.constraints.*;

@Getter @Setter
public class User {
    @NotNull private Integer id;
    @NotBlank private String name;
    @Min(18) private int age;
    ...
}

---

🧭 Learning Outcome

By end of this, learners can:

• Map inputs flexibly and securely in REST APIs
• Understand request data design trade-offs
• Build controller methods with composability and clean structure

[akash-coded]

// File: SmartUserApiApplication.java
package com.example.smartuser;

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

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

// File: controller/UserController.java
package com.example.smartuser.controller;

import com.example.smartuser.model.User;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class UserController {

    @GetMapping("/greet")
    public String greetUser(@RequestParam String name) {
        return "Hello, " + name + "! Welcome to SmartUserAPI.";
    }

    @GetMapping("/user/{id}")
    public String getUserById(@PathVariable int id) {
        return "Fetching user with ID: " + id;
    }

    @PostMapping("/user")
    public String createUser(@RequestBody User user) {
        return "User Created: " + user.toString();
    }

    @PostMapping("/user/{id}/update")
    public String updateUser(
            @PathVariable int id,
            @RequestParam String city,
            @RequestBody User user) {
        return "Updated user " + id + " in city " + city + " with data: " + user;
    }

    @GetMapping("/user/info")
    public ResponseEntity<String> getUserInfo(
            @RequestParam(required = false, defaultValue = "Guest") String name,
            @RequestParam(required = false, defaultValue = "Unknown") String city) {
        return ResponseEntity.ok("User Info - Name: " + name + ", City: " + city);
    }
}

// File: model/User.java
package com.example.smartuser.model;

import lombok.*;

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class User {
    private int id;
    private String name;
    private int age;
    private String city;
}

// File: resources/application.properties
server.port=8082
spring.application.name=SmartUserAPI

# Enable pretty logs
logging.level.org.springframework=INFO
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} - %msg%n

[akash-coded]

Here’s a step-by-step Spring Boot project walkthrough to demonstrate the different ways to accept input in REST APIs using:

• @RequestParam
• @PathVariable
• @RequestBody

We’ll build an API to manage Customers, with multiple endpoints showcasing these parameter types.

---

🗂 Folder Structure

springboot-input-types-demo/
├── src/
│   └── main/
│       ├── java/
│       │   └── com/example/demo/
│       │       ├── controller/
│       │       │   └── CustomerController.java
│       │       ├── dto/
│       │       │   └── CustomerRequest.java
│       │       ├── model/
│       │       │   └── Customer.java
│       │       ├── service/
│       │       │   ├── CustomerService.java
│       │       │   └── CustomerServiceImpl.java
│       │       └── DemoApplication.java
│       └── resources/
│           ├── application.properties
│           └── data.sql
└── pom.xml

---

⚙️ Step 1: Create a Spring Boot project

Go to https://start.spring.io/ and generate a project with:

• Project: Maven

• Language: Java

• Spring Boot: 3.x

• Group: com.example

• Artifact: demo

• Dependencies:

  • Spring Web
  • Spring Boot DevTools
  • Lombok
  • H2 Database (optional)
  • Spring Data JPA (optional)

Extract and import it into Eclipse.

---

📄 Step 2: Add Dependencies in pom.xml

Ensure these are present:

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

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>

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

---

💻 Step 3: Customer model class

model/Customer.java

package com.example.demo.model;

import lombok.*;

@Getter @Setter @AllArgsConstructor @NoArgsConstructor @ToString
public class Customer {
    private int id;
    private String name;
    private String email;
}

---

📥 Step 4: CustomerRequest DTO

dto/CustomerRequest.java

package com.example.demo.dto;

import lombok.*;

@Getter @Setter @AllArgsConstructor @NoArgsConstructor @ToString
public class CustomerRequest {
    private String name;
    private String email;
}

---

🔧 Step 5: Service Interface & Implementation

service/CustomerService.java

package com.example.demo.service;

import com.example.demo.dto.CustomerRequest;
import com.example.demo.model.Customer;

import java.util.List;

public interface CustomerService {
    Customer getCustomerById(int id);
    List<Customer> getCustomersByEmail(String email);
    Customer createCustomer(CustomerRequest request);
}

service/CustomerServiceImpl.java

package com.example.demo.service;

import com.example.demo.dto.CustomerRequest;
import com.example.demo.model.Customer;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

@Service
public class CustomerServiceImpl implements CustomerService {

    private final List<Customer> customerList = new ArrayList<>();
    private final AtomicInteger idCounter = new AtomicInteger(1);

    @Override
    public Customer getCustomerById(int id) {
        return customerList.stream().filter(c -> c.getId() == id).findFirst().orElse(null);
    }

    @Override
    public List<Customer> getCustomersByEmail(String email) {
        return customerList.stream()
                .filter(c -> c.getEmail().equalsIgnoreCase(email))
                .collect(Collectors.toList());
    }

    @Override
    public Customer createCustomer(CustomerRequest request) {
        Customer c = new Customer(idCounter.getAndIncrement(), request.getName(), request.getEmail());
        customerList.add(c);
        return c;
    }
}

---

🌐 Step 6: Controller

controller/CustomerController.java

package com.example.demo.controller;

import com.example.demo.dto.CustomerRequest;
import com.example.demo.model.Customer;
import com.example.demo.service.CustomerService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/customers")
public class CustomerController {

    @Autowired
    private CustomerService service;

    // GET with @PathVariable
    @GetMapping("/{id}")
    public Customer getCustomerById(@PathVariable int id) {
        return service.getCustomerById(id);
    }

    // GET with @RequestParam
    @GetMapping
    public List<Customer> getCustomerByEmail(@RequestParam String email) {
        return service.getCustomersByEmail(email);
    }

    // POST with @RequestBody
    @PostMapping
    public Customer createCustomer(@RequestBody CustomerRequest request) {
        return service.createCustomer(request);
    }

    // POST with @RequestParam (just for demo)
    @PostMapping("/create-quick")
    public Customer createQuickCustomer(@RequestParam String name, @RequestParam String email) {
        return service.createCustomer(new CustomerRequest(name, email));
    }
}

---

⚙️ Step 7: application.properties

src/main/resources/application.properties

server.port=8080
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
logging.level.org.springframework=INFO

---

▶️ Step 8: Run and Test

In Eclipse:

• Right-click on DemoApplication.java → Run as → Java Application

---

📮 Step 9: Postman Endpoints

🔹 Create customer (JSON payload)

POST http://localhost:8080/api/customers
Body (JSON)

{
  "name": "Akash",
  "email": "akash@example.com"
}

🔹 Create customer (Query Param)

POST http://localhost:8080/api/customers/create-quick?name=John&email=john@example.com

🔹 Get by ID

GET http://localhost:8080/api/customers/1

🔹 Get by Email

GET http://localhost:8080/api/customers?email=akash@example.com

[akash-coded]

Customer_API_Input_Types_Demo.postman_collection.json

[akash-coded]

graph TD
    subgraph Client
        A[Postman/User Interface]
    end

    subgraph Controller Layer
        B1[/POST /api/customers/]:::body
        B2[/POST /api/customers/create-quick/]:::param
        B3[/GET /api/customers/:id/]:::path
        B4[/GET /api/customers?email=xyz/]:::query
    end

    subgraph Service Layer
        S1[CustomerService Interface]
        S2[CustomerServiceImpl]
    end

    subgraph Data Layer
        R1[CustomerRepository] 
        DB[(H2 Database)]
    end

    A --> B1 --> S1 --> S2 --> R1 --> DB
    A --> B2 --> S1
    A --> B3 --> S1
    A --> B4 --> S1

    class B1 body;
    class B2 param;
    class B3 path;
    class B4 query;

Loading

[prasetha21-max]

PRASETHA N
demo.zip

[Sdey0907]

Task - Request Parsing_SpringBoot_SayanDey_Completed

demo_API_SpringBoot.zip