🛠️ Spring Boot REST API: Semi-Guided Exercise - SmartCatalog API – Stream, String and Spring in Action

[akash-coded]

🛠️ Spring Boot REST API: Semi-Guided Exercise

Project Title: SmartCatalog API – Stream, String & Spring in Action

---

🎯 Objective

You’ll build a production-style Spring Boot REST API that manages a catalog of products.
The app will have three service implementations:

1. Traditional Java (loops, if-else)
2. Java 8 Stream API
3. String-focused manipulations

You'll explore:

• Layered architecture (@Controller, @Service, @Repository)
• Dependency Injection and Interfaces
• Java 8 Streams vs Traditional loops
• String utilities in service logic
• RESTful API design and testing with Postman
• In-memory database (H2) usage

---

🧠 Background Story

Imagine you work at a startup building the backend for a retail app called SmartCatalog.
The CTO wants:

• Simple product listing
• Efficient filtering & reporting
• Clean code with separation of concerns
• Future readiness with Streams and functional style

You’ll impress them by giving three clean implementations of the same logic – loop-based, stream-based, and string-focused.

---

📁 Project Folder Structure

src/
├── main/
│   ├── java/com/example/smartcatalog/
│   │   ├── controller/
│   │   │   └── ProductController.java
│   │   ├── model/
│   │   │   └── Product.java
│   │   ├── repository/
│   │   │   └── ProductRepository.java
│   │   ├── service/
│   │   │   ├── ProductService.java
│   │   │   ├── impl/
│   │   │   │   ├── ProductServiceTraditionalImpl.java
│   │   │   │   ├── ProductServiceStreamImpl.java
│   │   │   │   └── ProductServiceStringImpl.java
│   │   └── SmartCatalogApplication.java
│   └── resources/
│       ├── application.properties
│       └── data.sql
└── test/

---

🧱 Step-by-Step Tasks

Step 1: Scaffold Spring Boot Project

Use [start.spring.io](https://start.spring.io):

• Dependencies: Spring Web, Spring Data JPA, H2 Database, Lombok
• Group: com.example
• Artifact: smartcatalog
• Port: 8082 (set in application.properties)

Step 2: Model Class

Create a Product model with:

• id: int
• name: String
• price: double
• category: String
• description: String

Use Lombok annotations for boilerplate:

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Product {
    private int id;
    private String name;
    private double price;
    private String category;
    private String description;
}

Step 3: Repository (optional for now)

@Repository
public interface ProductRepository extends JpaRepository<Product, Integer> {}

Optional: For now, use hardcoded list in each service instead of DB.

---

🚀 Implement the Services

🎯 Common Interface

public interface ProductService {
    List<Product> getAllProducts();
    List<Product> getByCategory(String category);
    List<String> getAllProductNames();
    double getTotalPrice();
    Product getMostExpensiveProduct();
    String getProductDescriptions();
}

---

🧵 Service 1: Traditional Loops

Fill using basic loops and conditionals.

---

🌊 Service 2: Stream API Style

Use stream(), map(), filter(), reduce(), collect() etc.

---

✂️ Service 3: String-Focused Logic

Focus on operations like:

• Concatenating descriptions
• Filtering using startsWith, contains
• Transforming strings to uppercase/lowercase
• Sorting alphabetically

---

🌐 Controller

@RestController
@RequestMapping("/api/products")
public class ProductController {

    @Autowired @Qualifier("streamService")
    private ProductService streamService;

    @Autowired @Qualifier("traditionalService")
    private ProductService traditionalService;

    @Autowired @Qualifier("stringService")
    private ProductService stringService;

    @GetMapping("/stream")
    public List<Product> streamProducts() { return streamService.getAllProducts(); }

    @GetMapping("/traditional")
    public List<Product> traditionalProducts() { return traditionalService.getAllProducts(); }

    @GetMapping("/names")
    public List<String> productNames() { return streamService.getAllProductNames(); }

    @GetMapping("/total")
    public double totalPrice() { return streamService.getTotalPrice(); }

    @GetMapping("/expensive")
    public Product mostExpensive() { return streamService.getMostExpensiveProduct(); }

    @GetMapping("/descriptions")
    public String allDescriptions() { return stringService.getProductDescriptions(); }
}

---

⚙️ application.properties

server.port=8082
spring.h2.console.enabled=true
spring.h2.console.path=/h2
spring.datasource.url=jdbc:h2:mem:productsdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

---

🧪 Postman Test Scenarios

Method	URL	Description
GET	/api/products/stream	List all products using Stream
GET	/api/products/traditional	List using traditional loops
GET	/api/products/names	Fetch all product names
GET	/api/products/total	Total price of products
GET	/api/products/expensive	Get most expensive product
GET	/api/products/descriptions	Get concatenated descriptions

Edge Cases:

• Try category=Unknown
• No products (try removing items from list)
• Long string descriptions

---

🔥 Pro Tips & Nuggets

• Use @Qualifier to inject specific implementations
• Prefer List.of() for small immutable lists in demos
• Use .orElse(null) instead of Optional for beginners
• In production, use DB & repository pattern
• Add unit tests for each service
• Integrate Swagger for API documentation (extra)

---

🧩 Challenge Extensions (Optional)

• Add new endpoint to find average price
• Add filtering by name containing substring (query param)
• Create ProductDTO and use it instead of Product directly in API

---

✅ Outcome

You’ll deeply understand:

• Layered architecture
• Interface polymorphism
• Stream API usage
• String operations in business logic
• REST API creation using Spring Boot