Understanding Dependency Injection in Spring: Constructor vs Setter Injection

Day 82 of #100dayscodingchallenge 💡 Constructor and Setter Dependency Injection in Spring Framework In Spring Framework, Dependency Injection (DI) is essential for building loosely coupled and easily testable applications. It allows an object’s dependencies to be provided externally rather than hardcoded. Two common approaches: 🔹 Constructor Injection: Dependencies are injected through the class constructor. Ensures mandatory dependencies are available at creation, promotes immutability, and makes code more reliable. 🔹 Setter Injection: Dependencies are injected via setter methods after object creation. Offers flexibility for optional dependencies and allows changes later if needed. ⚙️ Best Practice: Use Constructor Injection for essential dependencies and Setter Injection for optional ones. This keeps your code clean, maintainable, and aligned with good software design principles. #SpringFramework #DependencyInjection #Java #CleanCode #BackendDevelopment #SoftwareEngineering Anand Kumar Buddarapu Saketh Kallepu Uppugundla Sairam

Day 32 of #50DaysOfLeetCodeChallenge Problem: Top K Frequent Elements 💡 Approach: Count the frequency of each number using a HashMap. Push all unique numbers into a PriorityQueue (max-heap) that sorts numbers by frequency. Poll the heap k times to get the top frequent elements. ⌛ Complexity: Time: O(n log m) — n = array length, m = distinct numbers Space: O(m) — for map + heap ✅ Key Takeaways: PriorityQueue can be customized with a comparator to act as a max-heap or min-heap. Frequency-based problems often benefit from hash maps + heaps. Understanding comparators is crucial for ordering based on custom logic. #50DaysOfCode #LeetCode #Java #DSA #ProblemSolving

🚀Day 29/100 - Problem of the day :- Minimum Number of Increments on Subarrays to Form a Target Array. 🎯 Goal: Solve the “Minimum Number of Increments on Subarrays to Form a Target Array” problem efficiently on LeetCode. 💡 Core Idea: The key observation is that we only need to add operations when the current element is greater than the previous one. So, the total operations = target[0] + sum(max(target[i] - target[i-1], 0)). This approach ensures we only count necessary increments, avoiding redundant steps. 🎯 Key Takeaway: By focusing on the difference between consecutive elements, we transform a complex problem into a simple linear pass — achieving both clarity and top performance. ✅ Passed all 129 test cases 🚀 Runtime beats 100% of Java submissions 💾 Space Complexity: O(1) — constant extra space used. ⏱ Time Complexity: O(n) — single pass through the array. #Java #DSA #ProblemSolving #Day29 #Leetcode #CodingJourney #100DaysChallenge

💡 Strengthening Problem-Solving Skills with LeetCode (Java) I recently practiced a few algorithmic challenges focused on optimising time and space complexity using greedy strategies and iterative logic: 🔹 Best Time to Buy and Sell Stock (I) Implemented a single-pass solution to track minimum prices and calculate the maximum achievable profit. Approach: Greedy Time Complexity: O(n) 🔹 Best Time to Buy and Sell Stock (II) Designed a solution to capture all profitable opportunities through consecutive transactions. Approach: Greedy Time Complexity: O(n) 🔹 Jump Game Developed an efficient method to verify reachability of the last index by dynamically tracking the farthest reachable position. Approach: Greedy Time Complexity: O(n) Each of these problems reinforced the importance of clarity in logic design and the efficiency that comes with the right algorithmic approach. #LeetCode #Java #ProblemSolving #DSA #Coding #Algorithms #SoftwareEngineering

Day 17/100 – #100DaysOfCode 🚀 | #Java #DSA #LeetCode ✅ Problem Solved: Add Two Numbers 🔎 Task: You’re given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each node contains a single digit. Return the sum as a linked list. 💡 Approach Used: Traverse both lists simultaneously. Keep track of carry while adding digits. Create a new linked list to store the result. 🧠 Key Concepts: Linked List, Iteration, Carry Handling ⚙️ Time Complexity: O(max(m, n)) 📦 Space Complexity: O(max(m, n)) ✨ Today’s takeaway: Breaking complex problems into smaller iterative steps makes implementation smoother 🚀 #Java #LeetCode #DSA #ProblemSolving #CodingChallenge #ProgrammingJourney #100DaysOfCode

🚀 Day 63/90 – Merge K Sorted Linked Lists using Min Heap Today I explored how to merge multiple sorted linked lists efficiently using a Priority Queue (Min Heap). Learned how two different approaches — one that creates new nodes and another that reuses existing nodes — can give the same output but differ in memory usage. Even though both take similar time on LeetCode, understanding why makes a huge difference in writing optimized solutions. Every day, it’s less about syntax and more about thinking like an engineer. 💪 #VenkatToSDEin90Days #Day63 #Java #DSA #Heaps #LinkedLists #CodingJourney #ProblemSolving #LeetCode

Day 23 — Medium — Partition List Today’s problem was “Partition List.” At first, it wasn’t obvious how to rearrange nodes while keeping their relative order intact. I tried a few approaches but eventually had to look at the answer to understand the right method. Once I saw the solution, it clicked — building two separate lists (one for nodes smaller than the target value, and another for nodes greater or equal) and then connecting them gives the correct partition while preserving order. It took me a while, but after revisiting the explanation, I was able to crack the algorithm on my own. Key takeaway: Sometimes checking the answer isn’t failure — it’s just another step in learning. What matters is revisiting, rethinking, and making the solution your own. #100DaysOfCode #DSA #Java #LinkedLists #ProblemSolving #CodingJourney

Day 24/100 – #100DaysOfCode 🚀 | #Java #LeetCode #DSA #LinkedList ✅ Problem Solved: Linked List Cycle II 🔎 Task: Given the head of a linked list, return the node where the cycle begins. If there is no cycle, return null. 💡 Approach Used: Used Floyd’s Tortoise and Hare Algorithm to detect the cycle. Once a meeting point is found, moved one pointer to head and kept the other at the meeting point — both move one step at a time until they meet again (start of cycle). 🧠 Key Concepts: Two Pointers, Linked List Traversal, Cycle Detection ⚙️ Time Complexity: O(n) 📦 Space Complexity: O(1) ✨ Today’s takeaway: Understanding the mathematical intuition behind pointer movement makes linked list cycle problems easy to visualize and solve 🔄 #Java #LeetCode #DSA #ProblemSolving #CodingChallenge #100DaysOfCode

18/30 days ✅ Solved a LeetCode Problem #1342 — Number of Steps to Reduce a Number to Zero Successfully solved this problem in Java with 💯% runtime efficiency (0 ms)!The logic behind this problem is simple — we repeatedly perform operations to reduce a given number to zero while counting the steps. If the number is even, we divide it by two; if it is odd, we subtract one. This process continues until the number becomes zero, and the total number of operations gives the result. For example, for num = 14, the sequence is 14 → 7 → 6 → 3 → 2 → 1 → 0, which takes 6 steps. This approach efficiently reduces the number using basic conditional and looping logic, achieving a time complexity of O(log n). #LeetCode #CodingChallenge #JavaProgramming #ProblemSolving

Recently, I shared a deep dive into how Spring, Lombok, and Mockito manipulate bytecode from inside the JVM. But I didn’t stop there. The next logical step was to put that knowledge into practice: I built a working example that shows how to modify a running Java application — without restarts, without redeployments, and without touching a single line of the original source code. In my new article, I walk through: ✅ How to attach to a live JVM using the Attach API ✅ How to load a Java agent and gain full access to Instrumentation ✅ How to redefine a method body at runtime ✅ Common pitfalls and practical solutions This isn’t just theory — it’s a fully functional implementation you can run and adapt to your own use cases. After reading both articles — the one on how popular frameworks work under the hood, and this one on dynamic JVM instrumentation — you’ll be able to stop seeing the JVM as a black box. Instead, you’ll start seeing it as a flexible platform that can be programmed from the outside, even while your application is already running. 👉 Full article on TProger (in Russian, with code): https://lnkd.in/epVsA8Rq #Java #JVM #Bytecode #HotSwap #Instrumentation #SoftwareEngineering #ByteBuddy #APM #Performance #Programming