Mapping HTTP Requests with Spring Boot Annotations

#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

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

Most used Spring Boot annotations (that you’ll see almost everywhere) If you’ve worked with Spring, you already know… half the magic is in annotations 😅 Here are some of the ones I keep using almost daily: * @SpringBootApplication → starting point of the app * @RestController → tells Spring this class handles APIs * @RequestMapping / @GetMapping / @PostMapping → for routing requests * @Autowired → dependency injection (used a lot, sometimes too much 👀) * @Service → business logic layer * @Repository → database layer * @Component → generic bean * @Entity → maps class to DB table * @Id → primary key * @Configuration → for config classes * @Bean → manually define beans when needed When I started, I used to just memorize these. Over time, I realised understanding when NOT to use them is equally important. Like: * overusing @Autowired everywhere * mixing @Component, @Service randomly * not understanding bean lifecycle Spring feels simple at start, but there’s a lot going under the hood. If you’re learning Spring right now → focus less on remembering, more on understanding what each annotation actually does. Which Spring annotation do you use the most? 👇 #ThoughtForTheDay #SpringBoot #Java #Backend #SoftwareEngineering

🚀 Day 3/30 – Spring Boot Journey Today I explored @Component, @Service, and @Repository in Spring Boot. 🔹 @Component → Creates Spring Bean automatically 🔹 @Service → Used for business logic layer 🔹 @Repository → Handles database operations + exception handling 💡 Key Learning: All these annotations are special types of @Component, but using them properly improves code structure, readability, and follows clean architecture. Also understood how these layers work together: 👉 Controller → Service → Repository This made Dependency Injection much clearer! #SpringBoot #Java #BackendDeveloper #Learning #Microservices #100DaysOfCode

🚀 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 

#Post5 In the previous post, we saw how @RequestBody helps us handle request data. Now the next question is 👇 How do we get data from the URL? There are two common ways: • @PathVariable • @RequestParam Let’s understand 👇 👉 @PathVariable Used when the value is part of the URL path Example: GET /users/10 @GetMapping("/users/{id}") public String getUser(@PathVariable int id) { return "User id: " + id; } 👉 @RequestParam Used when the value comes as a query parameter Example: GET /users?id=10 @GetMapping("/users") public String getUser(@RequestParam int id) { return "User id: " + id; } 💡 Key difference: @PathVariable → part of URL @RequestParam → query parameter Key takeaway: Use the right approach based on how data is passed in the request 👍 In the next post, we will explore exception handling in Spring Boot 🔥 #Java #SpringBoot #BackendDevelopment #RESTAPI #LearnInPublic

@PathVariable vs @RequestParam – Passing URL Data While working on my Spring Boot projects, I explored how to pass data through URLs using @PathVariable and @RequestParam, and how both are used in different scenarios. 🔹 @PathVariable Used to get values directly from the URL path. It is mostly used when the value is required and represents a specific resource. Example: /users/101 → here 101 is taken as path variable 🔹 @RequestParam Used to get values from query parameters in the URL. It is commonly used for optional data like filters, search, or pagination. Example: /users?name=Rahul → here name is a request parameter Why use both? Using @PathVariable and @RequestParam properly makes APIs more clear and meaningful. @PathVariable → for identifying resources @RequestParam → for filtering or optional inputs In real projects, understanding this difference helps in designing clean and scalable REST APIs. #SpringBoot #Java #BackendDevelopment #RESTAPI #CodingJourney #LearningInPublic

🚀 Day 6 — Core Spring Annotations (Must Know 🔥) Today I learned the most important Spring annotations 👉 These are used in almost every real project 💡 1. @Component 👉 Marks a class as Spring Bean @Component class User {} 💡 2. @Service 👉 Used for business logic layer @Service class UserService {} 💡 3. @Repository 👉 Used for database layer @Repository class UserRepository {} 💡 4. @Controller 👉 Handles web requests @Controller class UserController {} 💡 5. @Autowired 👉 Injects dependency automatically @Autowired UserService service; ⚡ Important Point: 👉 All above annotations need @ComponentScan 📌 Key Takeaways: @Component → generic bean @Service → business logic @Repository → DB layer @Controller → request handling @Autowired → dependency injection 💡 One line I learned: 👉 Annotations replaced XML configuration 💬 Which annotation confused you the most? Day 6 done ✅ #Spring #Java #BackendDevelopment #LearningInPublic #30DaysOfCode #SpringBoot #Developers

Stop labeling your Spring Beans randomly! 🛑 I see many projects where @Component, @Service, and @Repository are used interchangeably. They all register a Bean in the context, so they are the same, right? Not exactly. Using the right stereotype is about Communication and Semantics. 🔹 @Service: Clearly states: "This is where the business logic lives." It's your domain's heart. 🔹 @Repository: Signals: "I talk to the database." Spring provides an extra layer of magic here: it automatically translates platform-specific exceptions (like SQLException) into Data Access Exceptions. 🔹 @Component: The generic catch-all. Use it for utility classes or anything that doesn't fit the service/repository pattern. Tip: Using the correct label makes your code readable for the next dev. It tells a story about what each class is responsible for before they even read a single line of implementation. How strict is your team with stereotyping their Spring components? Let’s talk below! 👇 #Java #SpringBoot #SoftwareArchitecture #CleanCode #Backend #SpringFramework #CleanDesign

#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