Spring Boot - REST API - 🎮 Mission: CodeQuest – Become a Spring Boot API Wizard

[akash-coded]

🎮 Mission: CodeQuest – Become a Spring Boot API Wizard

---

🌟 BACKSTORY

NeoBoard is hiring backend engineers to power the galaxy’s most advanced task management system. You're selected to join the elite API Engineering Squad.

To graduate, you must build a Spring Boot-powered REST API – clean, modular, and professional.

---

🛠️ YOUR TECH TOOLKIT

Tool	Purpose
Spring Boot	Backend framework
Eclipse/IDEA	IDE to write & run your code
Maven	Dependency & project manager
Postman	Simulates frontend/API testing
Java 17	Language version

---

🎁 LEVEL-UP: XP BONUS TASKS

• ✅ Convert status string to an enum (TaskStatus.PENDING, TaskStatus.DONE)

• ✅ Add endpoint PUT /api/tasks/{id} to update task status

• ✅ Use ResponseEntity<?> with proper HTTP status codes

• ✅ Add simple validation (e.g., reject empty task title)

---

✅ WHAT YOU NOW KNOW

✅ Bootstrapping a Spring Boot API
✅ Setting up controller, service, and model layers
✅ Building and testing real HTTP endpoints
✅ Coding using best practices followed in the industry
✅ Organizing code like a backend engineer

---

You're now ready to teach and build real-world Spring Boot APIs with clarity and confidence.

Absolutely. Here's the **enhanced version** of the exercise with clear **approach, folder structure, file placement**, and **how to run** instructions — all in a learner-friendly, gamified tone.

---

🎮 Mission: CodeQuest – Become a Spring Boot API Wizard

---

🌟 BACKSTORY

NeoBoard is hiring backend engineers to power the galaxy’s most advanced task management system. You're selected to join the elite API Engineering Squad.

To graduate, you must build a Spring Boot-powered REST API – clean, modular, and professional.

---

🛠️ YOUR TECH TOOLKIT

Tool	Purpose
Spring Boot	Backend framework
Eclipse/IDEA	IDE to write & run your code
Maven	Dependency & project manager
Postman	Simulates frontend/API testing
Java 17	Language version

---

🧭 OVERALL APPROACH

Your mission will follow this layered design pattern:

controller --> service --> model

Each layer:

• Performs a specific job
• Keeps logic separated
• Makes code testable, maintainable, readable

---

🗂 PROJECT STRUCTURE

When you generate your Spring Boot project via [start.spring.io](https://start.spring.io):

📦 src/main/java/com/neoboard/taskapi/

Create the following packages and place files accordingly:

com.neoboard.taskapi
├── controller          → All REST API classes
├── model               → Plain Java classes (data)
├── service             → Business logic
├── TaskapiApplication  → Main class with @SpringBootApplication

✅ Best Practice: Group classes by feature type (not by technical type only).

---

🧪 FILE-WISE GUIDED BREAKDOWN

🟢 1. Task.java (MODEL)

📁 Location: com.neoboard.taskapi.model

public class Task {
    private int id;
    private String title;
    private String status; // Consider converting to enum in later level

    // Constructor, Getters, Setters
}

---

🟢 2. TaskService.java (SERVICE)

📁 Location: com.neoboard.taskapi.service

@Service
public class TaskService {
    private List<Task> tasks = new ArrayList<>();
    
    // addTask, getAllTasks, getById, deleteById
}

---

🟢 3. TaskController.java (CONTROLLER)

📁 Location: com.neoboard.taskapi.controller

@RestController
@RequestMapping("/api/tasks")
public class TaskController {

    @Autowired
    private TaskService taskService;

    // @GetMapping, @PostMapping, etc.
}

---

🟢 4. TaskapiApplication.java (MAIN ENTRY POINT)

📁 Location: com.neoboard.taskapi

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

---

🚀 HOW TO RUN YOUR SPRING BOOT API

✅ Inside Eclipse:

1. Right-click on TaskapiApplication.java

2. Select: Run As → Java Application

3. Console shows:

   Started TaskapiApplication in 3.142 seconds (JVM running for 3.7)
   

✅ By Terminal (if using Maven):

./mvnw spring-boot:run

---

🌐 HOW TO TEST YOUR API

Once running, your app will be available at:
http://localhost:8080/api/tasks

🧪 Test Cases (Use Postman)

Method	URL	Body (JSON)	Expected Output
POST	/api/tasks	{"id":1,"title":"Fix bugs","status":"pending"}	201 Created (no content body)
GET	/api/tasks	—	List of tasks (JSON array)
GET	/api/tasks/1	—	Single task object
DELETE	/api/tasks/1	—	200 OK

---

🧼 BEST PRACTICES TO FOLLOW

Practice	Example / Why
Use @RestController	Combines @Controller + @ResponseBody
Use plural nouns in URLs	/api/tasks not /api/task
Avoid business logic in controller	Keep controllers thin, delegate to service layer
Return ResponseEntity<?>	Adds status codes and flexibility
Use enums for restricted fields	Convert "status" string → enum TaskStatus

---

🎁 LEVEL-UP: XP BONUS TASKS

• ✅ Convert status string to an enum (TaskStatus.PENDING, TaskStatus.DONE)
• ✅ Add endpoint PUT /api/tasks/{id} to update task status
• ✅ Use ResponseEntity<?> with proper HTTP status codes
• ✅ Add simple validation (e.g., reject empty task title)

---

✅ WHAT YOU NOW KNOW

✅ Bootstrapping a Spring Boot API
✅ Setting up controller, service, and model layers
✅ Building and testing real HTTP endpoints
✅ Coding using best practices followed in the industry
✅ Organizing code like a backend engineer

---

It’s structured like a mission-based progression game, with each level introducing one or more Spring Boot API concepts. It includes:

• Detailed explanation of concepts

• Applications in real-world projects

• Step-by-step code tasks

• Embedded best practices and coding conventions

• A compelling theme to sustain learner engagement

---

🎮 Mission: CodeQuest – Become a Spring Boot API Wizard

---

🌟 The Backstory

You’ve been hired as the Backend Engineer for NeoBoard, a futuristic digital task manager used by teams across the galaxy.

The mission? Build a Spring Boot-powered REST API from scratch.

Your journey includes:

• Understanding key concepts

• Implementing services step-by-step

• Earning XP by building features

• Reaching the final boss: a fully functioning REST API

---

🧩 The Game Map

Level	Concept Introduced	XP
0	Spring Boot Basics	0
1	Model + Java Classes	10
2	Service Layer	20
3	Dependency Injection	30
4	REST Controller + HTTP Methods	50
5	Testing with Postman	20
6	Best Practices + Refactoring	20

🧪 XP Earned: 20

---

🧩 Level 6: Polish & Power Up

🎯 Tasks:

1. ✅ Add PUT /api/tasks/{id} to update task status

2. ✅ Add response codes using ResponseEntity

3. ✅ Move strings like "pending" to an enum called TaskStatus

4. ✅ Add validation: task ID should not be negative

5. ✅ Modularize packages: controller, service, model

---

🧠 Pro Tips Recap:

• Use @RestController + @RequestMapping("/api/xyz")

• Inject services using @Autowired

• Always create a service layer, don’t dump logic in controllers

• Stick to HTTP method conventions: GET, POST, PUT, DELETE

• Maintain clean package structure (model, service, controller)

---

🏆 The Final Boss

You’ve built a working REST API using Spring Boot.
You now understand:

• Bootstrapping Spring apps

• Writing clean model classes

• Service and DI patterns

• Building and testing REST APIs

---

🎁 Bonus XP Challenges

• Add in-memory DB support using H2

• Add Swagger UI for API documentation

• Create DTO classes to decouple model from API input

• Add exception handling using @ControllerAdvice

• Explore @Valid for request validation

---

Let me know if you'd like this in:

• .docx printable format

• Shared GitHub starter template

• Auto-grading criteria sheet for classroom use

You're now ready to teach them Spring Boot APIs like a pro.

Absolutely. Here's a **creative, gamified, and comprehensive Spring Boot exercise** that both teaches and nudges learners toward building their first **real REST API**.

It’s structured like a mission-based progression game, with each level introducing one or more Spring Boot API concepts. It includes:

• Detailed explanation of concepts
• Applications in real-world projects
• Step-by-step code tasks
• Embedded best practices and coding conventions
• A compelling theme to sustain learner engagement

---

🎮 Mission: CodeQuest – Become a Spring Boot API Wizard

---

🌟 The Backstory

You’ve been hired as the Backend Engineer for NeoBoard, a futuristic digital task manager used by teams across the galaxy.

The mission? Build a Spring Boot-powered REST API from scratch.

Your journey includes:

• Understanding key concepts
• Implementing services step-by-step
• Earning XP by building features
• Reaching the final boss: a fully functioning REST API

---

🧩 The Game Map

Level	Concept Introduced	XP
0	Spring Boot Basics	0
1	Model + Java Classes	10
2	Service Layer	20
3	Dependency Injection	30
4	REST Controller + HTTP Methods	50
5	Testing with Postman	20
6	Best Practices + Refactoring	20

---

🧠 Level 0: Spring Boot Bootcamp

🎯 Goal:

Understand what Spring Boot is and how to set it up.

📖 Concepts:

• Spring Boot is a framework for creating production-ready Java apps with minimal configuration.
• Uses starter dependencies to reduce setup effort.
• Embedded server (Tomcat) allows running as standalone apps.

🛠 Task:

• Go to [start.spring.io](https://start.spring.io)
• Project Name: neoboard
• Dependencies: Spring Web
• Group: com.neoboard
• Artifact: taskapi
• Java version: 17+

Download, unzip, and import into Eclipse.
🧪 XP Earned: 0 (Warm-up)

---

🧩 Level 1: Define the Data Model

🎯 Goal:

Create a Java class (Task) to represent a task.

📖 Concepts:

• In Spring Boot, we create POJOs (Plain Old Java Objects) to model data.
• These will later be used in API requests/responses.

📄 Task.java

package com.neoboard.model;

public class Task {
    private int id;
    private String title;
    private String status;

    public Task(int id, String title, String status) {
        this.id = id;
        this.title = title;
        this.status = status;
    }

    // TODO: Generate Getters and Setters
}

🧠 Pro Tip: Use camelCase for fields, PascalCase for class names.
🧪 XP Earned: 10

---

🧩 Level 2: Service Layer Logic

🎯 Goal:

Create a service class to store and manage tasks.

📖 Concepts:

• Services hold business logic and communicate with future databases.
• Annotated with @Service to be injectable.

📄 TaskService.java

package com.neoboard.service;

import com.neoboard.model.Task;
import org.springframework.stereotype.Service;

import java.util.*;

@Service
public class TaskService {

    private List<Task> taskList = new ArrayList<>();

    public List<Task> getAllTasks() {
        return taskList;
    }

    public void addTask(Task task) {
        taskList.add(task);
    }

    public Task getTaskById(int id) {
        return taskList.stream().filter(t -> t.getId() == id).findFirst().orElse(null);
    }

    public void deleteTaskById(int id) {
        taskList.removeIf(t -> t.getId() == id);
    }
}

🧠 Pro Tip: Favor using List as abstraction, not concrete types like ArrayList
🧪 XP Earned: 20

---

🧩 Level 3: Inject the Service

🎯 Goal:

Use @Autowired to inject TaskService into the controller.

📖 Concepts:

• Dependency Injection (DI) lets Spring create and inject required objects.
• Use @Autowired for field or constructor-based injection.
• Keeps code loose-coupled and testable.

---

🧠 Best Practice:
Use constructor-based injection over field injection in large apps.

---

🧩 Level 4: The First API Controller

🎯 Goal:

Build REST endpoints using Spring annotations.

📖 Concepts:

Annotation	Purpose
@RestController	Tells Spring this class handles REST APIs
@GetMapping, @PostMapping, etc.	Maps HTTP methods to Java methods
@RequestBody	Maps JSON request to Java object
@PathVariable	Maps URL part to method param

---

📄 TaskController.java

package com.neoboard.controller;

import com.neoboard.model.Task;
import com.neoboard.service.TaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/tasks")
public class TaskController {

    @Autowired
    private TaskService taskService;

    @GetMapping
    public List<Task> getAll() {
        return taskService.getAllTasks();
    }

    @GetMapping("/{id}")
    public Task getById(@PathVariable int id) {
        return taskService.getTaskById(id);
    }

    @PostMapping
    public void addTask(@RequestBody Task task) {
        taskService.addTask(task);
    }

    @DeleteMapping("/{id}")
    public void delete(@PathVariable int id) {
        taskService.deleteTaskById(id);
    }
}

🧠 Pro Tip: Keep controller methods thin. Let services do the logic.

🧪 XP Earned: 50
💥 You can now access your API at:

• GET /api/tasks
• POST /api/tasks
• GET /api/tasks/{id}
• DELETE /api/tasks/{id}

---

🧩 Level 5: Testing with Postman

🎯 Goal:

Simulate frontend using Postman to test your APIs.

Method	URL	Body Example
POST	http://localhost:8080/api/tasks	{"id":1,"title":"Fix bugs","status":"pending"}
GET	http://localhost:8080/api/tasks	—

🧪 XP Earned: 20

---

🧩 Level 6: Polish & Power Up

🎯 Tasks:

1. ✅ Add PUT /api/tasks/{id} to update task status
2. ✅ Add response codes using ResponseEntity
3. ✅ Move strings like "pending" to an enum called TaskStatus
4. ✅ Add validation: task ID should not be negative
5. ✅ Modularize packages: controller, service, model

---

🧠 Pro Tips Recap:

• Use @RestController + @RequestMapping("/api/xyz")
• Inject services using @Autowired
• Always create a service layer, don’t dump logic in controllers
• Stick to HTTP method conventions: GET, POST, PUT, DELETE
• Maintain clean package structure (model, service, controller)

---

🏆 The Final Boss

You’ve built a working REST API using Spring Boot.
You now understand:

• Bootstrapping Spring apps
• Writing clean model classes
• Service and DI patterns
• Building and testing REST APIs

---

🎁 Bonus XP Challenges

• Add in-memory DB support using H2
• Add Swagger UI for API documentation
• Create DTO classes to decouple model from API input
• Add exception handling using @ControllerAdvice
• Explore @Valid for request validation

[Sdey0907]

**_`

Task -Spring Boot - REST API_neoboard_taskapi_Sayan Dey_Completed

`_**

taskapi_SpringBoot.zip