Dependency Injection in Spring: The Key to Flexible Java Apps

Date:03/02/2026 Today reminded me that good software engineering is about clarity, not just correctness. 🔹 Problem Solved: Maximum Average Subarray While solving a sliding window problem, my logic was correct, but some test cases failed due to a subtle issue: double avg = sum / k; - ❌ integer division double avg = (double) sum / k; - ✅ correct Because both sum and k were integers, Java performed integer division first, losing decimal precision. This caused incorrect comparisons when averages were very close—especially with large inputs. Note: For fixed window the breaking logic is i-k+1 . ✔ Lesson: Even correct algorithms can fail if type behavior and precision are overlooked. 🔹 What I Learned About the Java Module System (JPMS) -> I also learned about the Java Module System (Java 9), which enforces clear boundaries in applications. A module explicitly defines: ->what it exports (public API) ->what it requires (dependencies) This metadata (module-info.java) is enforced at compile time and runtime, providing strong encapsulation and eliminating hidden dependencies. 🔹 The Common Thread ->Both experiences reinforced the same principle: ->Explicitness prevents bugs. ->Explicit casting avoids precision errors ->Explicit module boundaries avoid accidental dependencies Even though most Spring Boot apps don’t actively use JPMS, understanding it improves how I design packages, separate APIs from internals, and reason about large systems. 🎯 Takeaway Small details in code and strong boundaries in design together build reliable, scalable software. #Java #ProblemSolving #SlidingWindow #JavaModules #SoftwareEngineering #LearningJourney #BackendDevelopment

Hi everyone 👋 Continuing the weekday Spring Boot series with another useful annotation 👇 📌 Spring Boot Annotation Series – Part 6 ✅ @Value annotation The @Value annotation is used to inject values into Spring beans 👇 🔹 Why do we use @Value? - To read values from application.properties or application.yml - To avoid hardcoding values in code - To manage environment-specific configurations 🔹 Where can we use @Value? To inject: - Configuration values - Environment variables - Default values 🔹 Simple example properties - server.port=8081 app.name=MySpringApp in java code - @Value("${server.port}") private int port; @Value("${app.name}") private String appName; 🔹 In simple words @Value helps us take values from configuration files and use them directly in our code. 👉 🧠 Quick Understanding (My Notes) - @Value injects external values into fields - Mostly used with application.properties - Helps keep code clean and configurable #SpringBoot #Java #ValueAnnotation #BackendDevelopment #LearningInPublic

🔧 𝐃𝐞𝐩𝐞𝐧𝐝𝐞𝐧𝐜𝐲 𝐈𝐧𝐣𝐞𝐜𝐭𝐢𝐨𝐧 (𝐃𝐈) 𝐢𝐧 𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 Dependency Injection is one of the key principles that makes Spring Boot powerful and developer-friendly. Instead of a class creating its own dependencies using new, Spring’s IoC (Inversion of Control) container creates, manages, and injects objects automatically. ✨ Key Benefits ▸ Loose coupling – classes depend on abstractions, not concrete implementations ▸ Better testability – easy to mock dependencies during unit testing ▸ Cleaner & maintainable code – responsibilities are clearly separated 🔌 Types of Dependency Injection in Spring Boot ▸ Constructor Injection (recommended) – ensures immutability and required dependencies ▸ Setter Injection – useful for optional dependencies ▸ Field Injection – simple, but less test-friendly Using annotations such as @Component, @Service, @Repository, and @Autowired, Spring Boot automatically manages dependency wiring, allowing developers to focus on business logic instead of object lifecycles. 🚀 Mastering DI is a big step toward building scalable, enterprise-ready Spring Boot applications. #SpringBoot #Java #BackendDevelopment #SoftwareEngineering #Tech

🚀 What Exactly Is a Bean in Spring? (Simple but Important) Sometimes the simplest questions are the ones we forget to explain clearly. As Spring developers, we often say: “Bean is just an object managed by Spring IoC.” But what does that really mean? In the Spring Framework: A Bean is an object that is: ✔ Created by the Spring IoC container ✔ Managed by the container ✔ Injected using Dependency Injection (DI) ✔ Stored inside the ApplicationContext ✔ Controlled through its lifecycle If you create an object using new, it’s just a normal object. If Spring creates and manages it — it becomes a Bean. Example: @Service public class PaymentService { } Because of @Service, Spring registers this class as a Bean and manages it inside the container. 💡 Why this matters? Understanding Beans properly helps in: Debugging injection issues Avoiding NoUniqueBeanDefinitionException Managing lifecycle correctly Writing clean architecture Sometimes we use Spring daily but forget the fundamentals behind it. Still learning. Still refining basics. #SpringBoot #Java #BackendDevelopment #CleanCode #SoftwareEngineering

🚀 Why @RestController is a Game Changer in Spring Boot 🔥 One annotation that instantly elevates your API development: @RestController Behind the scenes, it combines: @Controller + @ResponseBody 💪 Why it’s powerful: 👉 Automatically converts Java objects into JSON 👉 Eliminates unnecessary boilerplate 👉 Makes REST APIs clean, readable, and production-ready 👉 Encourages modern API design practices Sometimes, one annotation makes all the difference. 💡 #Java #SpringBoot #BackendDevelopment #SoftwareEngineering #TechGrowth

💻 Crash vs 🧩 Exception 💻 Errors / Crashes OS/JVM/Hardware level serious issues 🔴 Serious system-level issues 🔴 Usually unrecoverable Examples: OutOfMemoryError StackOverflowError 🧩 Exceptions 🟡 Program logic or runtime issues 🟡 Can be handled Examples: Divide by zero Null pointer File not found 💥Exception An exception is an unexpected problem during program execution that breaks the normal flow of a program 🚧 📌 Key clarity: 👉 An exception is NOT the user’s mistake itself 👉 It is the error event created because of that mistake 🧠 Example: User enters 0 ➝ Code tries 15 / 0 ➝ 💥 ArithmeticException ➗ Division by Zero — Important Clarity ⚖️ ✅ Integer division: 15 / 0 💥 Throws ArithmeticException ❌ Program stops if not handled ⚠️ Floating-point division: 15.0 / 0 ♾️ Result = Infinity ✅ No exception thrown 👉 So yes, “it gives infinity” is correct, but only for float/double, not int ✔️ 🚨 What Happens When an Exception Is NOT Handled When an exception occurs: ✔️ Execution stops from that exact line ✔️ Java creates an exception object ✔️ JVM searches for a handler ✔️ No handler found ➝ 💀 program terminates ✔️ Stack trace printed 📄 📌 This behavior is called: 👉 Abnormal termination of the program ⏱️ Compile-Time vs Runtime Exceptions ✅ Checked Exceptions (Compile-time checked) 🔹 Compiler forces handling 🔹 Example: File handling (IOException) ✅ Unchecked Exceptions (Runtime) 🔹 Occur during execution 🔹 Compiler does NOT force handling Examples: ArithmeticException NullPointerException 🧠 Throwable Hierarchy Object ↓ Throwable ↓ Exception ↓ ↓ CTE RTE 🔖Frontlines EduTech (FLM) #Java #ExceptionHandling #ProgrammingConcepts #CoreJava #DeveloperMindset #TechAustralia #AustraliaJobs #SydneyTech #MelbourneTech #BrisbaneTech #AustraliaIT #LearningInPublic #SoftwareEngineering #CodingLife #TechExplained

Day 3 / 21 — #Simplifying Spring concepts that confuse beginners Early in my career, I thought #Dependency #Injection meant “using Spring.” It doesn’t. You can do Dependency Injection with plain Java. Pass dependencies through constructors. Avoid creating them inside the class. That’s it. No framework required. Imagine a service that needs a database client. Without DI, the service creates it. With DI, the service receives it. The logic stays the same, but responsibility shifts. So why didn’t teams just keep doing DI by hand? Because real systems don’t have three objects. They have dozens. Different environments. Different configurations. Different lifecycles. Someone has to decide what gets created, when, and how long it lives. That “someone” slowly became a pile of factory classes, wiring code, and setup logic spread across the codebase. It worked—until change became expensive. Spring didn’t win because it invented Dependency Injection. It won because it centralized it. In production, this centralization matters. When configuration changes, when dependencies need pooling, or when startup behavior needs tuning, having one place that manages wiring reduces risk. It also makes failures easier to reason about. A common mistake I still see: Teams jump straight to Spring without understanding DI itself. When something breaks, they blame the framework instead of the design. Frameworks don’t replace fundamentals. They scale them. If you had to remove Spring tomorrow, would your code still reflect clean Dependency Injection—or would everything fall apart? #Java #SpringBoot #BackendEngineering #SystemDesign #API #ScalableSystems

📌 Spring Boot Annotation Series – Part 8 ✅ @Component annotation The @Component annotation is used to mark a class as a Spring-managed bean 👇 🔹 Why do we use @Component? To tell Spring: 👉 “Create an object of this class and manage it.” - To enable dependency injection - To let Spring detect the class during component scanning 🔹 How does it work? When Spring Boot starts: - It scans packages (using @ComponentScan) - Finds classes annotated with @Component - Creates and registers them as beans in the Spring container 🔹 Simple example @Component public class EmailService { public void sendEmail() { System.out.println("Email sent"); } } Now this class can be injected using: @Autowired private EmailService emailService; 🔹 In simple words @Component tells Spring to automatically create and manage this class as a bean. 👉 🧠 Quick Understanding - Marks a class as a Spring bean - Detected during component scanning - Enables dependency injection #SpringBoot #Java #Component #BackendDevelopment #LearningInPublic

Setter Injection finally helped me in understanding that how Spring handles optional object dependencies.... In the last post, I implemented setter injection using simple properties like studentName and studentId, studentAdress, which helped me understand how Spring injects values. But today, I took the next step 👉 Injecting one object into another using Setter Injection (reference-type injection) in Core Spring. And this made Dependency Injection feel even more practical. 🧐 Let’s understand this with an example Suppose we have two classes: 1️⃣ Student 2️⃣ Address Here, a Student can have an Address, but the object can still exist without it initially. This is a real backend scenario where a dependency is optional or changeable. 🤔 In Core Java, we manually create objects and set the dependencies using setters. But in Core Spring, the IoC Container creates, manages, and injects reference-type dependencies via setters without using new keyword. 👨💻 What I Implemented (From Scratch – Core Spring) 1️⃣ Created a Maven project. 2️⃣ Added Spring Core and Spring Context dependencies. 3️⃣ Created POJO classes of Student, Address. 4️⃣ Defined beans in config.xml 5️⃣ Used setter injection to inject Address into Student. 6️⃣ Let Spring manage the entire object lifecycle. 7️⃣ Retrieved the bean from the container and used it in App.java. 💡 What Clicked for Me 👉 Setter Injection works well for optional dependencies, & Reference values can be changed after object creation. 👉 Constructor Injection is still better for mandatory dependencies. This helped me clearly understand when to use setter injection vs constructor injection. In next post we will discuss a comparison of Constructor Injection vs Setter Injection and decide when to use which. #SpringFramework #DependencyInjection #SetterInjection #Java #BackendDevelopment #LearningInPublic

📌 Spring Boot Annotation Series – Part 2 ✅ @ComponentScan Ever faced a situation where Spring says ❌ NoSuchBeanDefinitionException even though your class is annotated correctly? That’s where @ComponentScan comes in 👇 🔹 WHY do we use @ComponentScan? Spring needs to know where your classes are. @ComponentScan tells Spring: 👉 “Scan these packages and create beans from them.” Without scanning, Spring doesn’t even see your classes. Spring needs to scan packages to find classes annotated with: @Component @Service @Repository @Controller 🔹 WHEN do we need @ComponentScan? When your service or config class is in a different package. When working on multi-module projects. When Spring can’t find a bean at runtime. 🔹 WHERE does Spring scan by default? By default, Spring scans: 👉 The package of the main application class 👉 And all its sub-packages If your class is outside this, Spring will miss it. @ComponentScan(basePackages = "com.example.app") #SpringBoot #Java #BackendDevelopment #LearningInPublic