Spring @Value Injection Timing Issue

Day 11/30 – LeetCode streak Today’s problem: Sort Integers by The Number of 1 Bits You have to sort an array by popcount first (fewer 1s come earlier), and if two numbers have the same count, sort them by their actual value. Instead of using 'Arrays.sort' with a comparator, I tried writing the sort logic myself with insertion sort: - For each element, treat it as 'key' and move larger elements (based on custom “bit count, then value” order) one step to the right. - 'Swap(a, b)' returns true if 'a' should come after 'b' in the final order, using a manual 'countBits' function to compare the number of 1s. - If bit counts differ, the one with more 1s is considered “greater”; if they’re equal, compare the raw integers. Day 11 takeaway: This was a nice chance to practice writing a custom sort order from scratch—once the comparison rule is clear (“by 1-bits, then by value”), the rest is just plugging that into any sorting algorithm. #leetcode #dsa #java #bitmanipulation #sorting

🚀 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

🚀 Day 11 of #SpringBootChallenge 📌 Topic: Dependency Injection & @Autowired in Spring Boot Today I explored one of the most important concepts in Spring Boot — Dependency Injection (DI). If you truly understand this concept, Spring becomes much easier to work with. 💡 What is Dependency? In simple words, when one class needs another class to function, it is called a dependency. For example: A Car needs an Engine to run. Here, Engine is the dependency of Car. ✅ With Dependency Injection in Spring Boot Spring Boot uses the IoC (Inversion of Control) container to: ✔ Create objects ✔ Manage them ✔ Inject them where required Instead of creating objects manually using new, Spring automatically provides the required dependency. This makes the application: ▪️ Loosely coupled ▪️Easier to test ▪️Cleaner and more maintainable 📌 Tomorrow I’ll continue this topic with: ➤@Autowired annotation ➤Types of Dependency Injection ➤Best practices (Constructor Injection) ➤Real code example Stay tuned 🎥🔥 #Java #SpringBoot #BackendDevelopment #DependencyInjection #LearningInPublic 🚀

LeetCode 83 — Remove Duplicates from Sorted List This problem gives the head of a sorted linked list and asks to remove all duplicate values so that each element appears only once. Since the list is already sorted, duplicate values always appear next to each other. The task is simply to skip repeated nodes while keeping the original order of the list. Example : Input : 1 → 1 → 2 → 3 → 3 Output : 1 → 2 → 3 Approach used — Single Pass Pointer Traversal Because the list is sorted, the solution can be done in one traversal. Two pointers are used during traversal : - One pointer (a) keeps track of the last unique node. - Another pointer (b) scans the list forward. When both nodes have the same value, the duplicate node is skipped. When a new value appears, the unique node is connected to it. At the end, the last node’s next pointer is set to null to ensure the list ends correctly. This approach works in O(n) time and O(1) extra space. #leetcode #datastructures #linkedlist #java #problemSolving

Day 12/30 – LeetCode streak Today’s problem: Number of Steps to Reduce a Number in Binary Representation to One Rules are simple: if the number is even, divide by 2; if it’s odd, add 1. But doing this by simulating the whole number each time is slow and messy. The trick is to walk the binary string from right to left and just count how many operations each bit contributes, while carrying a 1 when we “add 1”: - Ignore index 0 (most significant bit); we stop at 'i > 0'. - For each bit, compute 'bit = (s.charAt(i) - '0') + carry'. - If 'bit' is '1', it’s effectively odd → we need '+1' then '/2' → 'steps += 2' and set 'carry = 1'. - If 'bit' is '0' or '2', it’s even → just '/2' → 'steps += 1', 'carry' stays as is. - After the loop, if there’s still a carry, add one more step because we effectively turned something like '"111"' into '"1000"' and need one last divide to reach '1'. Day 12 takeaway: Instead of repeatedly mutating the number, counting how many times each bit causes “+1 then /2” vs “just /2” gives an O(n), no-conversion solution that feels much cleaner once the carry idea clicks. #leetcode #dsa #java #bitmanipulation #consistency

🌱 Common Spring Beginner Mistakes🚀 Common Spring Beginner Mistakes (and How to Avoid Them) When starting with Spring, these mistakes are very common 👇 ❌ 1. Using 'new' Instead of Dependency Injection Car car = new Car(); ❌ ✔ Always let Spring manage objects using DI ❌ 2. Not Understanding IoC & DI Clearly Writing code without knowing who creates objects Leads to confusion and poor design 📌 Learn IoC & DI before moving ahead ❌ 3. Using @Component Everywhere @Service → business logic @Repository → database layer @Controller → request handling ✔ Use the right annotation for the right layer ❌ 4. Mixing Controller, Service & Repository Logic @Controller class UserController { // DB logic here ❌ } ✔ Follow layered architecture ❌ 5. Field Injection Everywhere @Autowired private Service service; ❌ ✔ Prefer Constructor Injection ❌ 6. Ignoring Bean Lifecycle Not using @PostConstruct Not closing resources properly ✔ Understand create → use → destroy ❌ 7. Not Reading Error Messages Spring errors look big but are very informative Stack traces help you learn faster #Spring #SpringBoot #Java #LearningInPublic #BackendDevelopment #JavaDeveloper

☕ @SpringBootApplication — The Magic Annotation Unpacked One annotation to rule them all. But do you know what's actually inside it? @SpringBootApplication is a convenience annotation that combines three powerful ones: @SpringBootApplication // is equivalent to: @Configuration @EnableAutoConfiguration @ComponentScan public class MyApp { public static void main(String[] args) { SpringApplication.run(MyApp.class, args); } } Here's what each does: • @Configuration — marks this class as a source of bean definitions (replaces XML config) • @ComponentScan — tells Spring to scan the current package and subpackages for @Component, @Service, @Repository, @Controller • @EnableAutoConfiguration — the real magic: Spring Boot reads your classpath and auto-configures beans (e.g., sees H2 → configures DataSource automatically) You can customize the scan: @SpringBootApplication(scanBasePackages = {"com.myapp.service", "com.myapp.api"}) Or exclude an auto-configuration you don't want: @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class}) #Java #SpringBoot #BackendDevelopment #SoftwareEngineering #SpringFramework

LeetCode 2130 — Maximum Twin Sum of a Linked List This problem gives the head of a linked list with even length. For a list of size n, the iᵗʰ node and the (n−1−i)ᵗʰ node are considered twin nodes. The twin sum is defined as the sum of the values of these two nodes. The task is to return the maximum twin sum in the linked list. Example : Input : 5 → 4 → 2 → 1 Twin pairs : (5,1) → sum = 6 (4,2) → sum = 6 Output : 6 Approach used — Reverse Second Half + Twin Traversal Because twin nodes lie symmetrically from the start and end, the list can be processed efficiently by reversing half of it. Two main steps are used during traversal. • First, fast and slow pointers are used to locate the middle of the linked list. - slow moves one step at a time. - fast moves two steps at a time. When fast reaches the end, slow will be positioned at the start of the second half. • The second half of the list is then reversed so that twin nodes align during traversal. After reversing : - One pointer starts from the beginning of the list. - Another pointer starts from the reversed second half. At each step : - The twin sum is calculated. - The maximum twin sum is updated. This approach works in O(n) time and O(1) extra space. #leetcode #datastructures #linkedlist #java #problemSolving

LeetCode 24 — Swap Nodes in Pairs This problem gives the head of a linked list. The task is to swap every two adjacent nodes and return the head of the modified list. One important constraint is that the node values cannot be modified — only the nodes themselves can be rearranged. Example : Input : 1 → 2 → 3 → 4 Output : 2 → 1 → 4 → 3 Each pair of adjacent nodes is swapped while keeping the rest of the list structure intact. Approach used — Pairwise Pointer Manipulation A dummy node is placed before the head to simplify pointer operations, especially for the first pair. During traversal : - first represents the first node of the pair - second represents the second node of the pair For every pair : - The first node is connected to the node after the pair. - The second node is linked before the first node. - The previous node is connected to the new head of the pair. After swapping, the pointer moves forward to process the next pair. This process continues until fewer than two nodes remain. This approach swaps nodes in O(n) time with O(1) extra space. #leetcode #datastructures #linkedlist #java #problemSolving

🔄 Spring Bean Lifecycle – From Creation to Destruction While working with Spring, one concept that really helped me understand how things run internally is the Bean Lifecycle. A Spring Bean goes through multiple stages from the moment it is created till it gets destroyed. Knowing this flow makes debugging and customization much easier. 👉 1. Instantiation Spring container creates the bean instance using constructor or factory method. 👉 2. Dependency Injection All required dependencies are injected (via constructor/setters/fields). 👉 3. Initialization Spring calls lifecycle callbacks like: @PostConstruct InitializingBean.afterPropertiesSet() custom init-method 👉 4. Bean Ready for Use Now the bean is fully initialized and ready to serve the application. 👉 5. Destruction Before removing the bean, Spring calls: @PreDestroy DisposableBean.destroy() custom destroy-method 💡 Why it matters? Understanding lifecycle hooks allows better control over resource management, logging, and custom initialization logic. 📌 For me, learning this made Spring feel less like “magic” and more predictable. #Java #SpringBoot #BackendDevelopment #SoftwareEngineering #LearningJourney