Spring Boot @PutMapping Annotation for Updating Resources

💡 Understanding Collection-Based Dependency Injection in Spring When we talk about Dependency Injection (DI) in Spring, most of us think about injecting a single object. But did you know you can inject multiple beans at once using collections? 🤔 Let’s break it down in a simple way 👇 🔹 What is Collection-Based DI? Instead of injecting one object, Spring can inject a list, set, or map of beans into your class. 👉 This is useful when you have multiple implementations of the same interface. 🔹 What’s Happening Here? ✅ Spring scans all beans of type PaymentService ✅ It collects them into a List ✅ Injects them automatically into PaymentProcessor 🔹 Other Supported Collections You can also use: ✔ List<Interface> ✔ Set<Interface> ✔ Map<String, Interface> → Key = bean name Example: Map<String, PaymentService> paymentMap; 🔹 Why is this Useful? ✔ Helps implement strategy pattern easily ✔ Avoids manual bean selection ✔ Makes code more flexible & scalable 🔹 Pro Tip 🚀 Spring injects collections in a specific order if you use @Order or @Priority. 🔚 Summary Collection-based DI = Inject multiple beans → Handle dynamically → Write cleaner code If you're learning Spring deeply, this concept is a game changer when building scalable systems 🔥 #Java #SpringBoot #DependencyInjection #BackendDevelopment #CleanCode

🚀 Day 9/100: Spring Boot From Zero to Production Topic: Dependency Injection (DI) If someone asked me to name the three most important things in Spring Boot, Dependency Injection (DI) would definitely be at the top of that list! 🏆 It might sound like a complex technical term, but the concept is actually quite simple once you break it down. The "Old School" Way ❌ Before Spring, if we wanted to use a service inside a controller, we had to manually create the object ourselves: UserService userService = new UserService(); This makes your code "tightly coupled", meaning your controller is now responsible for creating and managing that service. If the service changes, you have to go back and fix it everywhere. The Spring Boot Way (DI) ✅ With Spring, you don't use the new keyword anymore. Instead, you let the IoC Container (like the ApplicationContext) do the heavy lifting. Think of this container as a giant box that holds all your Beans (object instances). When your controller needs that service, you just ask Spring to "inject" it: @Autowired UserService userService; Why is this a game-changer? 🚀 Inversion of Control (IoC): Spring takes over the responsibility of creating and managing the object lifecycle. Cleaner Code: You don't have to write boilerplate code to instantiate objects. Decoupling: Your components don't need to know how to create their dependencies, they just know they'll be there when needed. Reduced Code Size: It keeps your project much more organized and scalable. Basically, Spring is the ultimate manager, it creates the instances, keeps them in the container, and hands them to you exactly where they are needed! See you in next post with more interesting topics. #Java #SpringBoot #SoftwareDevelopment #100DaysOfCode #Backend

A quick question that made me curious: What actually happens behind the scenes when we use @Transactional in Spring Boot? Most of us just add the annotation and trust it to handle everything. But under the hood, something interesting is happening. Spring doesn’t directly modify your method. Instead, it creates a proxy around the bean. So when a transactional method is called, the flow looks like: Client → Proxy → Transaction Manager → Your Method → Commit/Rollback Here’s what the proxy does: • Starts a transaction before method execution • Executes your business logic • Commits if everything is fine • Rolls back if an exception occurs But here’s another catch 👇 Not all exceptions trigger rollback. By default, Spring only rolls back for: • Runtime exceptions (RuntimeException) • Errors (Error) But checked exceptions (like IOException, SQLException) 👉 do NOT trigger rollback by default So sometimes: • Your code throws an exception • But the transaction still commits 😳 If you want rollback for all exceptions, you need: @Transactional(rollbackFor = Exception.class) And one more important catch: The proxy only works when the method is called from outside the bean. If one method inside the same bean calls another method annotated with @Transactional, the call bypasses the proxy. So the transaction may not even start. That’s why sometimes: • Transactions don’t work as expected • Rollbacks don’t happen • Bugs are hard to trace Spring isn’t “magic” — it’s just smart use of proxies and AOP. Now the interesting question: If method A and method B are in the same bean, and B is annotated with @Transactional, and A calls B internally… 👉 How would you make sure the transaction actually works? #SpringBoot #BackendEngineering #Java #SystemDesign #Transactional #AOP

Hi everyone 👋 📌 Spring Boot Annotation Series Part 22– @RequestParam @RequestParam is used to read query parameters from the request URL and bind them to method parameters. It is part of the Spring Framework and commonly used in REST APIs built with Spring Boot. 🔹 Why do we use @RequestParam? Sometimes we need to pass additional information through the URL. Example: GET /users?age=25 Here, age is a query parameter. @RequestParam helps us capture that value in the controller method. 🔹 Simple Example @RestController @RequestMapping("/users") public class UserController { @GetMapping("/search") public String getUserByAge(@RequestParam int age) { return "User age is: " + age; } } 👉 Request URL: GET http://localhost:8080/users/search?age=25 Output: User age is: 25 🔹 In Simple Words @RequestParam takes values from query parameters in the URL and passes them to the controller method. 👉 🧠 Quick Understanding Used in filtering, search APIs Can be optional using required=false Can provide default values Used to read query parameters from URL Mostly used in GET APIs #SpringBoot #Java #RESTAPI #RequestParam #BackendDevelopment #LearningInPublic

🚀 Mastering HTTP Method Mappings in Spring Boot One annotation decides whether your endpoint lives or dies — and most developers don't fully understand the difference between them. In Spring Boot, @RequestMapping is the parent of all HTTP-method-specific shortcuts. But in real projects, you'll almost never see it alone — instead, we use @GetMapping, @PostMapping, @PutMapping, and @DeleteMapping to make code readable and intentional. Here's why it matters: @RestController @RequestMapping("/api/products") public class ProductController { @GetMapping // GET /api/products public List<Product> getAll() { ... } @PostMapping // POST /api/products public Product create(@RequestBody Product p) { ... } @PutMapping("/{id}") // PUT /api/products/1 public Product update(@PathVariable Long id, @RequestBody Product p) { ... } @DeleteMapping("/{id}") // DELETE /api/products/1 public void delete(@PathVariable Long id) { ... } } Clean, self-documenting, and follows REST conventions. Key takeaway: Use @RequestMapping at class level for base paths, and specific annotations at method level for clarity. Mixing HTTP methods inside one @RequestMapping is a code smell. #Java #SpringBoot #BackendDevelopment #REST #Programming

🔍 How Dependency Injection (DI) Works Internally in Spring Boot When I first used @Autowired, I wondered… 👉 How does Spring automatically create and inject objects? Here’s what I learned: 1️⃣ When the application starts, Spring creates an Application Context (IoC Container). 2️⃣ It scans for classes annotated with: @Component, @Service, @Repository, @Controller 3️⃣ Spring creates objects (beans) of these classes and stores them inside the container. 4️⃣ When a class needs a dependency (using @Autowired), Spring: ✔ Finds the required bean ✔ Injects it automatically So instead of: UserService service = new UserService(); Spring manages object creation for us. 💡 This is called Inversion of Control (IoC). Result: ✔ Loose coupling ✔ Better testability ✔ Cleaner architecture Understanding internals > Just memorizing annotations 🚀 #SpringBoot #DependencyInjection #Java #BackendDeveloper #Learning

🔍 How Dependency Injection (DI) Works Internally in Spring Boot When I first used @Autowired, I wondered… 👉 How does Spring automatically create and inject objects? Here’s what I learned: 1️⃣ When the application starts, Spring creates an Application Context (IoC Container). 2️⃣ It scans for classes annotated with: @Component, @Service, @Repository, @Controller 3️⃣ Spring creates objects (beans) of these classes and stores them inside the container. 4️⃣ When a class needs a dependency (using @Autowired), Spring: ✔ Finds the required bean ✔ Injects it automatically So instead of: UserService service = new UserService(); Spring manages object creation for us. 💡 This is called Inversion of Control (IoC). Result: ✔ Loose coupling ✔ Better testability ✔ Cleaner architecture Understanding internals > Just memorizing annotations 🚀 #SpringBoot #DependencyInjection #Java #BackendDeveloper #Learning

🚀 Dependency Injection: The Heart of Spring Most developers write code where objects create their own dependencies. Spring flips this on its head — and that's what makes it powerful. Dependency Injection (DI) means an object receives its dependencies from the outside instead of creating them itself. The IoC (Inversion of Control) container manages object creation, wiring, and lifecycle. // ❌ Without DI — tight coupling public class OrderService { private PaymentService payment = new PaymentService(); // hard-coded! } // ✅ With DI — loose coupling @Service public class OrderService { private final PaymentService paymentService; public OrderService(PaymentService paymentService) { this.paymentService = paymentService; // injected by Spring } } Why does this matter? ✔ Testability — swap real dependencies with mocks ✔ Flexibility — change implementations without touching consumers ✔ Single Responsibility — objects focus on their job, not wiring ✔ Less boilerplate — Spring handles object lifecycle Spring's ApplicationContext is the IoC container. It scans your classes, creates beans, resolves dependencies, and injects them automatically. You declare what you need; Spring figures out how to provide it. This is the concept everything in Spring Boot builds upon. Master this, and the rest clicks into place. #Java #SpringBoot #BackendDevelopment #DependencyInjection #IoC #SoftwareEngineering

I understood Dependency Injection… but I was confused about how it actually works in code. Then I learned about @Autowired What does @Autowired do? It tells Spring: “Inject the required dependency here automatically.” --- Without @Autowired: You manually create objects → more code, tight coupling With @Autowired: Spring finds and injects the object → cleaner code --- How it works (simple): Spring scans your project → Finds matching beans → Injects them where @Autowired is used --- Why it matters: • Reduces boilerplate code • Improves maintainability • Enables loose coupling --- In simple terms: @Autowired = “Spring, you handle this for me.” --- Learning step by step and building strong fundamentals Next: I’ll explain how Spring Boot handles REST APIs internally. #SpringBoot #Java #BackendDevelopment #LearningInPublic #FullStackDeveloper

New to Spring Boot? You'll see these annotations in every project. Here's what they actually do: @SpringBootApplication → Entry point. Combines @Configuration, @EnableAutoConfiguration, @ComponentScan @RestController → Marks a class as an HTTP request handler that returns data (not views) @Service → Business logic layer. Spring manages it as a bean @Repository → Data access layer. Also enables Spring's exception translation @Autowired → Inject a dependency automatically (prefer constructor injection instead) @GetMapping / @PostMapping / @PutMapping / @DeleteMapping → Maps HTTP methods to your handler methods @RequestBody → Deserializes JSON from request body into a Java object @PathVariable → Extracts values from the URL path Bookmark this. You'll refer back to it constantly. Which annotation confused you the most when starting out? 👇 #Java #SpringBoot #Annotations #BackendDevelopment #LearningInPublic