Spring Boot Annotations Explained: @SpringBootApplication to @Autowired

#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

#Post4 In the previous post, we understood how request mapping works using @GetMapping and others. Now the next question is 👇 How does Spring Boot handle data sent from the client? That’s where @RequestBody comes in 🔥 When a client sends JSON data → it needs to be converted into a Java object. Example request (JSON): { "name": "User", "age": 25 } Controller: @PostMapping("/user") public User addUser(@RequestBody User user) { return user; } 👉 Spring automatically converts JSON → Java object This is done using a library called Jackson (internally) 💡 Why is this useful? • No manual parsing needed • Clean and readable code Key takeaway: @RequestBody makes it easy to handle request data in APIs 🚀 In the next post, we will understand @PathVariable and @RequestParam 🔥 #Java #SpringBoot #BackendDevelopment #RESTAPI #LearnInPublic

#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

🚀 DAY 9 — Spring Revision (Day 1 → Day 8) 🔥 Before starting Spring Boot, I revised everything I learned so far 👇 📌 🔁 QUICK REVISION (IMPORTANT POINTS) ✅ Day 1 — Why Spring? Too many technologies earlier (JSP, Servlet, JDBC) Spring reduces complexity Provides one ecosystem for backend ✅ Day 2 — IoC & DI IoC → Spring controls object creation DI → Spring injects dependencies Loose coupling achieved ✅ Day 3 — Spring vs Spring Boot Spring → more configuration Spring Boot → auto configuration + embedded server Boot = faster development ✅ Day 4 — Constructor Injection Dependency passed via constructor Recommended way ✔️ No new keyword ✅ Day 5 — XML vs Annotation XML → old, more config Annotation → modern, less code Needs @ComponentScan ✅ Day 6 — Core Annotations @Component → bean @Service → business logic @Repository → DB @Controller → request @Autowired → DI ✅ Day 7 — Bean Basics Bean = object managed by Spring Created by IoC container Scope: Singleton (default), Prototype ✅ Day 8 — Bean Lifecycle Create → Inject → Init → Use → Destroy @PostConstruct → after init @PreDestroy → before destroy 🎯 🔥 INTERVIEW QUESTIONS (MUST KNOW) ❓ What is Spring? 👉 Framework for building Java applications, reduces complexity ❓ What is IoC? 👉 Control of object creation given to Spring ❓ What is Dependency Injection? 👉 Injecting required objects instead of creating manually ❓ Types of DI? 👉 Constructor, Setter, Field (Constructor preferred) ❓ What is Bean? 👉 Object managed by Spring container ❓ Bean Scope? 👉 Singleton (one object), Prototype (multiple objects) ❓ Bean Lifecycle? 👉 Create → Inject → Init → Use → Destroy ❓ Difference: Spring vs Spring Boot? 👉 Boot reduces configuration, adds embedded server ❓ @Component vs @Service vs @Repository? 👉 Same working, different purpose (layer-wise clarity) ❓ What is @Autowired? 👉 Automatically inject dependency ❓ What is ApplicationContext? 👉 IoC container that manages beans 💡 FINAL UNDERSTANDING 👉 Spring = Manage objects + reduce complexity 👉 IoC + DI = Core of Spring 💬 Did you revise before jumping to Spring Boot? Day 9 done ✅ #Spring #Java #BackendDevelopment #LearningInPublic #30DaysOfCode #SpringBoot #Developers

Hi everyone 👋 Continuing the Spring Boot Annotation Series 👇 📌 Spring Boot Annotation Series Part 25 – @ModelAttribute @ModelAttribute is used to bind request data (form data / query params) to a Java object. It is part of the Spring Framework and mainly used in Spring MVC applications. 🔹 Why do we use @ModelAttribute? When we receive multiple values from a request (like form data), instead of handling each parameter separately, we can bind them directly to an object. 👉 Makes code clean and structured. 🔹 Where is it used? Form submissions (HTML forms) Query parameters MVC applications (not mostly REST APIs) 🔹 In Simple Words @ModelAttribute takes request data and converts it into a Java object. 👉 🧠 Quick Understanding Binds request data to object Used in form handling Works with query/form data Not mainly used for JSON #SpringBoot #Java #ModelAttribute #SpringMVC #BackendDevelopment #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

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

🧬 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

💡 Types of Dependencies in Spring Framework: In the 🌱 Spring Framework, Dependency Injection (DI) is a core concept that helps achieve loose coupling and better code maintainability. Let’s explore the three main types of dependencies used in Spring: 🔹 1. Primitive Dependency This involves injecting simple values like int, double, boolean, or String. 👉 Example: Injecting a username, age, or configuration value into a bean. ✔️ Configured using @Value annotation or XML ✔️ Commonly used for constants and environment properties ✔️ Lightweight and easy to manage 💡 Use case: Application properties like app name, port number, etc. 🔹 2. Collection Dependency Spring allows injecting collections such as List, Set, Map, or Properties. 👉 Example: List of email recipients Map of key-value configurations ✔️ Supports bulk data injection ✔️ Can be configured via XML or annotations ✔️ Useful for dynamic and flexible data handling 💡 Use case: Storing multiple values like roles, configurations, or URLs. 🔹 3. Reference Dependency (Object Dependency) This is the most important type where one bean depends on another bean. 👉 Example: OrderService depends on PaymentService Car depends on Engine ✔️ Achieved using @Autowired, @Inject, or XML <ref> ✔️ Promotes loose coupling ✔️ Core concept behind Spring IoC Container 💡 Use case: Service layer calling repository layer, or controller calling service. 🚀 Why Dependency Injection Matters in Spring? Reduces tight coupling between classes Makes unit testing easier Improves code reusability and maintainability Enables better separation of concerns 🔥 Pro Tip: Prefer constructor injection over field injection for better immutability and testability. #SpringFramework #Java #DependencyInjection #BackendDevelopment #SoftwareEngineering #TechLearning Anand Kumar Buddarapu

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