Spring Boot REST API Development Basics

#Post2 In the previous post, we understood what a REST API is. Now the next question is 👇 How do we actually build REST APIs in Spring Boot? That’s where @RestController comes in 🔥 @RestController is a special annotation used to create REST APIs. It combines two things: • @Controller • @ResponseBody 👉 Meaning: Whatever method returns → it is written directly to the HTTP response body (usually JSON for objects) Example: @RestController public class UserController { @GetMapping("/user") public String getUser() { return "Hello User"; } } Output → "Hello User" (sent as response) 💡 Key difference: @Controller → used for returning views (JSP/HTML) @RestController → used for REST APIs (JSON response) Key takeaway: If you are building APIs in Spring Boot → @RestController is your starting point 🚀 In the next post, we will understand how request mapping works using @GetMapping and others 🔥 #Java #SpringBoot #BackendDevelopment #RESTAPI #LearnInPublic

🧬 Spring Boot – Understanding API Responses Today I explored how Spring Boot sends data from backend to frontend. 🧠 Key Learnings: ✔️ Returning a Java object automatically converts it to JSON ✔️ Spring Boot uses Jackson internally for this conversion ✔️ "@ResponseBody" ensures data is sent directly as response 💡 Best Practice: 👉 Using "@RestController" simplifies everything (Combination of @Controller + @ResponseBody) ✔️ Explored different return types: • Object • List • String • ResponseEntity (for better control over status & response) 🔁 API Flow: Request → Controller → Service → Return Object → JSON Response → Client 💻DSA Practice: • Even/Odd check using modulus • Sum of first N numbers (optimized using formula) ✨ Understanding how backend responses work is key to building real-world REST APIs. #SpringBoot #Java #BackendDevelopment #RESTAPI #WebDevelopment #DSA #LearningInPublic #SoftwareEngineering

🚀 Spring Boot Learning – @RestController vs @RequestMapping While building REST APIs in Spring Boot, I explored how requests are handled behind the scenes. 🔹 @RestController Used to create REST APIs. It combines @Controller + @ResponseBody and returns data directly (JSON/String). 🔹 @RequestMapping Used to map URLs to classes or methods and can handle different HTTP methods. 💡 Modern Approach (Shortcut Annotations) Instead of using @RequestMapping for everything, Spring provides: -> @GetMapping -> @PostMapping -> @PutMapping -> @DeleteMapping These make code cleaner and more readable. 📌 Key Insight: 👉 @RestController creates APIs 👉 Mapping annotations connect URLs to methods Sharing a simple graphical representation to make this concept easier to understand. 📊 #SpringBoot #Java #BackendDevelopment #RESTAPI #DependencyInjection #JavaDeveloper #LearningInPublic

Understanding Request Mapping in Spring Boot While working on my Spring Boot projects, I explored how request mapping plays a crucial role in handling client requests efficiently. 🔹 @RequestMapping This is a general-purpose annotation used to map HTTP requests to handler methods. It can be applied at both class and method level and supports multiple HTTP methods. 🔹 @GetMapping Specifically designed for handling HTTP GET requests. It makes the code more readable and is commonly used for fetching data from the server. 🔹 @PostMapping Used for handling HTTP POST requests. Ideal when sending data from client to server, such as form submissions or creating new records. Why use specific mappings? Using @GetMapping, @PostMapping, etc., improves code clarity and makes APIs more expressive compared to using @RequestMapping for everything. In real projects, choosing the right mapping annotation helps in building clean and maintainable REST APIs. #SpringBoot #Java #BackendDevelopment #RESTAPI #CodingJourney #LearningInPublic

🧬 Spring Boot – Understanding @RequestBody Today I learned how Spring Boot handles data coming from the client using @RequestBody. 🧠 Key Concept: 👉 "@RequestBody" is used to receive JSON data from the frontend and convert it into a Java object automatically. 🔁 Flow: Client (JSON) → @RequestBody → Java Object 💡 This makes API development clean and efficient without manual parsing. ✔️ Helps in handling POST & PUT requests ✔️ Automatically maps request data to objects ✔️ Simplifies backend code 📌 Real Use Case: • Creating users • Updating data • Handling form submissions 💻 DSA Practice: • Prime number check • Factorial calculation 🧠 Quick Check: "@RequestBody" is used to receive data from client ✅ ✨ Understanding how data flows from frontend to backend is a key step in mastering REST APIs. #SpringBoot #Java #BackendDevelopment #RESTAPI #WebDevelopment #DSA #LearningInPublic

#Post3 In the previous post, we understood the role of @RestController in building APIs. Now the next step is 👇 How do we map HTTP requests to methods? That’s where mapping annotations come in 🔥 In Spring Boot, we use: • @GetMapping → for GET requests • @PostMapping → for POST requests • @PutMapping → for UPDATE • @DeleteMapping → for DELETE • @PatchMapping → for partial updates Example: @GetMapping("/users") → fetch all users @PostMapping("/users") → create a new user 💡 What about @RequestMapping? @RequestMapping is a generic annotation that can handle all HTTP methods. Example: @RequestMapping(value="/users", method=RequestMethod.GET) 👉 But in modern Spring Boot, we prefer specific annotations like @GetMapping for cleaner and readable code Key takeaway: Use specific mapping annotations for better clarity and maintainability 👍 In the next post, we will understand how @RequestBody works in handling request data 🔥 #Java #SpringBoot #BackendDevelopment #RESTAPI #LearnInPublic

#SpringUnpackedSeries - 01 Spring Boot is doing a LOT more than you think. You don’t write SQL. You don’t configure much. Yet everything just… works. That’s not magic. That’s layers of abstraction doing the heavy lifting. I’m starting a new series called “Spring Unpacked” where I break down what’s actually happening behind the scenes. First post: 👉 What is Spring Boot + JPA (really)? With a simple mental model you won’t forget. Because once you see it… you can’t unsee it. #SpringUnpacked #SpringBoot #Java #JPA #Backend #BackendDevelopment #Hibernate #SoftwareEngineering

What actually happens when you hit a REST API? 🤔 Let’s break it down step by step 👇 1️⃣ Client sends HTTP request 2️⃣ Request hits DispatcherServlet 3️⃣ HandlerMapping finds the correct controller 4️⃣ Controller processes request 5️⃣ Service layer applies business logic 6️⃣ Repository interacts with DB 7️⃣ Response is returned as JSON 💡 Behind the scenes: - Jackson converts Java → JSON - Spring handles dependency injection - Exception handling via @ControllerAdvice ⚡ Real benefit: Understanding this flow helps you: ✔ Debug faster ✔ Write better APIs ✔ Optimize performance Next time you call an API, remember — a lot is happening inside 🔥 Follow for more backend deep dives 🚀 #SpringBoot #Java #RestAPI #BackendDeveloper

🚀 Spring Boot — One mistake I made while building APIs I used to return Entity objects directly from my controllers. It worked… but later I realized the problem: ✔ Exposes DB structure ✔ Hard to change later ✔ Can leak unnecessary data Now I use DTOs instead. 👉 Cleaner 👉 Safer 👉 More control Small change, big impact. What’s one mistake you made while learning Spring Boot? #SpringBoot #JavaDeveloper #BackendDevelopment #LearningInPublic #Java

Honestly, I’ve made the same mistake early on. Returning entities directly feels fast and “it just works”… until you start changing your schema or need to hide certain fields. That’s when things get messy. Switching to DTOs was one of those moments where I realized how important clean API design is not just for now, but for future changes. Definitely a small change with a big impact.