Building REST APIs in Spring Boot with @RestController

#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

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

🚀 Developed a basic REST API using Spring Boot to handle HTTP requests and responses. 🔹 What I implemented: Created a REST Controller using @RestController Used @RequestMapping to define base URL (/api) Built a GET API using @GetMapping("/student") 🔹 API Endpoint: http://localhost:8080/api/student 🔹 Output: "Student data" 🔹 Key Learnings: How Spring Boot handles HTTP requests Understanding request → controller → response flow Basics of REST API development Excited to move next into POST APIs and sending real data using @RequestBody 🔥 #SpringBoot #Java #BackendDevelopment #LearningJourney #CSE 

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 – 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

Global Exception Handling in Spring Boot using @ControllerAdvice While building REST APIs, handling exceptions properly is very important. Instead of writing try-catch blocks in every controller, I learned how to manage all exceptions in one place using @ControllerAdvice. What is @ControllerAdvice? It is a global exception handler in Spring Boot that allows us to handle exceptions across the entire application in a centralized way. Why use it? ✔ Clean and maintainable code ✔ Avoid repetitive try-catch blocks ✔ Centralized error handling ✔ Consistent API responses How it works? We create a class and annotate it with @ControllerAdvice, then define methods using @ExceptionHandler for different exceptions. Example: @ControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(Exception.class) public ResponseEntity<String> handleGlobalException(Exception ex) { return new ResponseEntity<>("Something went wrong: " + ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR); } @ExceptionHandler(NullPointerException.class) public ResponseEntity<String> handleNullPointer(NullPointerException ex) { return new ResponseEntity<>("Null value found!", HttpStatus.BAD_REQUEST); } } Result: Now whenever an exception occurs anywhere in the application, it will be handled here automatically. This approach makes APIs more professional and easier to debug. #SpringBoot #Java #BackendDevelopment #ExceptionHandling #WebDevelopment #Learning

Clean REST API in Spring Boot (Best Practice) 🚀 Here’s a simple structure you should follow 👇 📁 Controller - Handles HTTP requests 📁 Service - Business logic 📁 Repository - Database interaction Example 👇 @RestController @RequestMapping("/users") public class UserController { @Autowired private UserService userService; @GetMapping("/{id}") public User getUser(@PathVariable Long id) { return userService.getUserById(id); } } 💡 Why this matters: ✔ Clean code ✔ Easy testing ✔ Better scalability ⚠️ Avoid: Putting everything inside controller ❌ Structure matters more than code 🔥 Follow for more practical backend tips 🚀 #SpringBoot #Java #CleanArchitecture #Backend

In production Spring Boot services, scattered try-catch blocks create inconsistent API behavior. A better approach is centralized handling: ```@RestControllerAdvice public class GlobalExceptionHandler {   @ExceptionHandler(ResourceNotFoundException.class)   public ResponseEntity<ErrorResponse> handleNotFound(ResourceNotFoundException ex) {     return ResponseEntity.status(HttpStatus.NOT_FOUND)         .body(new ErrorResponse("RESOURCE_NOT_FOUND", ex.getMessage()));   }   @ExceptionHandler(MethodArgumentNotValidException.class)   public ResponseEntity<ErrorResponse> handleValidation(MethodArgumentNotValidException ex) {     return ResponseEntity.status(HttpStatus.BAD_REQUEST)         .body(new ErrorResponse("VALIDATION_ERROR", "Invalid request payload"));   }   @ExceptionHandler(Exception.class)   public ResponseEntity<ErrorResponse> handleGeneric(Exception ex) {     return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)         .body(new ErrorResponse("INTERNAL_ERROR", "Unexpected error occurred"));   } }``` Benefits we observed: - Consistent contract for error payloads - Cleaner controllers/services - Accurate HTTP semantics (400, 404, 409, 500) - Better observability and incident response A strong error model is part of API design, not just exception handling. #SpringBoot #Java #Microservices #API #SoftwareEngineering #Backend

🧬 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

#Post6 In the previous posts, we built basic REST APIs step by step. But what happens when something goes wrong? 🤔 Example: User not found Invalid input Server error 👉 By default, Spring Boot returns a generic error response. But in real applications, we need proper and meaningful error handling. That’s where Exception Handling comes in 🔥 Instead of handling exceptions in every method, Spring provides a better approach using @ControllerAdvice 👉 It allows us to handle exceptions globally Example: @ControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(Exception.class) public String handleException(Exception ex) { return ex.getMessage(); } } 💡 Why use this? • Centralized error handling • Cleaner controller code • Better API response Key takeaway: Use global exception handling to manage errors in a clean and scalable way 🚀 In the next post, we will create custom exceptions for better control 🔥 #Java #SpringBoot #BackendDevelopment #RESTAPI #LearnInPublic