Understanding @Autowired in Spring Boot for Dependency Injection

Still getting stuck on Spring Boot annotations? This might save you HOURS. If you're building with Spring Boot and constantly looking up annotations… 👉 You’re definitely not the only one. 👉 But it’s costing you time and focus. To make things easier, I put together a clear and simplified Spring Boot annotations cheat sheet 👇 💡 Here’s what you’ll quickly understand: 🔥 Application Setup @SpringBootApplication, @EnableAutoConfiguration 🧩 Core Architecture @Component, @Service, @Repository, @RestController 🔗 Dependency Injection @Autowired, @Qualifier, @Primary 🌐 REST API Development @GetMapping, @PostMapping, @RequestBody ⚙️ Configuration & Beans @Configuration, @Bean, @Value 🗄️ JPA & Persistence @Entity, @Id, @Transactional ✅ Validation @Valid, @NotNull, @Email 🚨 Exception Handling @ControllerAdvice, @ExceptionHandler 🔐 Security @PreAuthorize, @Secured ⏱️ Async & Scheduling @Async, @Scheduled, @EnableCaching Save it, use it, and stop wasting time searching for the same annotations again 🚀 #SpringBoot #Java #Backend

🚀 #100DaysOfCode – Day 4 Consistency is building up… one concept at a time 💪 ✅ What I accomplished today: 🧠 Spring Boot Learning – REST Controllers & Flow 📌 Key Learnings: Learned about @RestController in Spring Boot → It is a shorthand for @Controller + @ResponseBody → All methods directly return JSON/XML response Understood why using only @Controller is not enough for REST APIs → We need extra configurations, which @RestController simplifies Explored Request Mapping (GET API flow) → How client request hits the controller → How response is returned back Learned about Component Scanning → Spring Boot automatically scans and manages components → Helps in dependency injection & auto-configuration 💻 DSA Practice – Equal Sum Grid Partition 📌 Problem Overview: Given a grid, determine if it's possible to partition it into two parts such that: The sum of both partitions is equal, OR By removing a specific element, the partition can be made equal 📌 Approach: Calculated total sum and maintained two running parts: → topSum and bottomSum Used frequency arrays to track elements in both partitions For every possible split: → Checked if sums are equal → If not, checked whether removing a valid element can balance it Also handled edge cases: → Single row / single column partitions Finally, transposed the grid to reuse logic for vertical splits Submission Link🔗 https://lnkd.in/ewjyGh3N 📌 Key Concepts Used: Prefix-like sum tracking Frequency counting Matrix transformation (transpose) Edge case handling 💡 Reflection: Today was a mix of backend fundamentals + problem-solving Understanding how requests flow in Spring Boot while solving a complex grid problem really helped connect logic with real-world backend thinking. 🔥 Day 4 Done. Moving forward stronger. #SpringBoot #Java #BackendDevelopment #DSA #LeetCode #Consistency #LearningJourney

Yesterday: “It’s working perfectly 😌” Today: Application failed to start. Same code. Same logic. Different story. Welcome to Spring Boot reality 👇 → One missing bean = full system collapse → One wrong config = hours gone → One hidden null = chaos unleashed → One DB hiccup = everything breaks And suddenly… you’re not coding anymore, you’re investigating. Logs become clues. Stack traces become stories. Debugging isn’t pain — it’s where real backend thinking begins. Because great developers don’t fear crashes… they understand them. ⚡ #SpringBoot #Java #BackendDevelopment #Debugging #BuildInPublic

Spring Boot annotations can feel overwhelming at first—but mastering them is a real productivity unlock. This cheat sheet is a great reminder that clean architecture in Spring isn’t about complexity, it’s about understanding the role of each layer and annotation. From dependency injection to REST design and exception handling—everything becomes simpler once the fundamentals click. Definitely worth saving for daily reference 👇 #SpringBoot #Java #Microservices #BackendDevelopment #SoftwareEngineering

✨ Spring Framework 🚀 Today I went deeper into Dependency Injection and Autowiring in Spring and understood how Spring automatically manages dependencies. 🔹 @Autowired (Field, Setter, Constructor Injection) 🔹 How Spring resolves dependencies internally 🔹 Common issues (NoUniqueBeanDefinitionException) 🔹 Using @Qualifier to resolve ambiguity 🔹 Comparison of XML vs Annotation configuration Understanding these concepts made it clearer how Spring reduces manual object creation and handles dependencies efficiently 💡 📌 Also implementing these concepts in code alongside notes. Consistency is the goal 🚀 #SpringFramework #JavaDeveloper #BackendDevelopment #LearnInPublic #SpringBoot #CodingJourney

Why write 100 lines of code when the same can be done in 10? 🚀 Day 1 of my Spring Learning Series Today, I started my journey into the Spring Framework, aiming to understand how modern enterprise applications are built efficiently. The first concept I explored was the difference between: • **Languages (Java)** → the foundation we build on   • **Technologies (Servlets)** → tools that help solve specific problems   • **Frameworks (Spring)** → structured solutions that handle most of the heavy lifting  A simple way to see it: Building with a language is like starting from raw materials, while using a framework is like working with a ready-made structure — you focus more on customization than construction. This shift in perspective made me realize how powerful frameworks are in writing cleaner, scalable, and maintainable code. Looking forward to diving deeper into Spring in the coming days. What was the first framework that changed the way you code? #SpringFramework #Java #BackendDevelopment #SoftwareEngineering #LearningInPublic #TechJourney

𝗠𝗮𝘀𝘁𝗲𝗿 𝗦𝗽𝗿𝗶𝗻𝗴 𝗔𝗢𝗣 𝗮𝗻𝗱 𝗦𝘁𝗼𝗽 𝗥𝗲𝗽𝗲𝗮𝘁𝗶𝗻𝗴 𝗬𝗼𝘂𝗿𝘀𝗲𝗹𝗳 Repetitive "boilerplate" code is the silent killer of clean architectures. In Spring Boot development, we often see service layers drowning in code that has nothing to do with the actual business logic. Things like:  • 📝 Logging method entry and exit.  • 🛡️ Security/Permission checks.  • ⏱️ Performance monitoring (measuring execution time).  • 🔄 Cache eviction management. If you are manually adding this logic to every service method, you’re creating a maintenance nightmare. 𝗧𝗵𝗲 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻: Spring Aspect-Oriented Programming (AOP). 𝗔𝗢𝗣 lets you separate these "Cross-Cutting Concerns" from your business logic. You write the logic once in an 𝗔𝘀𝗽𝗲𝗰𝘁, and Spring automatically applies it whenever specific methods are called. Your Service class remains clean, readable, and focused on one responsibility. How It Works (Example): Instead of copying 𝗹𝗼𝗴𝗴𝗲𝗿.𝗶𝗻𝗳𝗼(...) into every method, you create a single Logging 𝗔𝘀𝗽𝗲𝗰𝘁 like the one below. Using @𝗔𝗿𝗼𝘂𝗻𝗱 advice, you can intercept the method call, start a timer, execute the actual method, and then log the result. The Benefits: ✅ 𝗗𝗥𝗬 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲: Write logic once, use it everywhere. ✅ 𝗗𝗲𝗰𝗼𝘂𝗽𝗹𝗶𝗻𝗴: Business logic doesn’t know (or care) about logging/monitoring. ✅ 𝗙𝗹𝗲𝘅𝗶𝗯𝗶𝗹𝗶𝘁𝘆: Enable or disable cross-cutting features easily. 🛑 𝗖𝗿𝗶𝘁𝗶𝗰𝗮𝗹 𝗧𝗶𝗽: 𝗧𝗵𝗲 𝗣𝗿𝗼𝘅𝘆 𝗧𝗿𝗮𝗽! When using Spring AOP (by default), Spring creates a dynamic proxy object around your target class. The AOP logic only executes when you call the method through that proxy. 𝗧𝗵𝗶𝘀 𝗺𝗲𝗮𝗻𝘀: If 𝙈𝙚𝙩𝙝𝙤𝙙𝘼() inside your Service class calls 𝙈𝙚𝙩𝙝𝙤𝙙𝘽() (which is also inside the same class), the call is internal and bypasses the proxy. Your AOP advice for 𝙈𝙚𝙩𝙝𝙤𝙙𝘽() will NOT run. Knowing this subtle nuance is what separates Spring experts from beginners! How are you using AOP in your Spring Boot applications? Share your best use cases below! 👇 #SpringBoot #Java #SoftwareArchitecture #CodingBestPractices #BackendDev

Day 95 of my consistency journey Today was all about going deeper into building my URL Shortener project and strengthening my backend fundamentals. I focused on understanding how real-world systems handle redirection, database interaction, and scalability. Instead of just coding, I tried to think like a backend engineer — why things are designed a certain way, not just how. 💡 Key takeaways from today: - How URL redirection actually works behind the scenes - Importance of clean architecture in backend systems - Thinking in terms of scalability from the start - Strengthening Java + Spring Boot fundamentals Consistency is slowly turning confusion into clarity. Still a long way to go, but showing up every day is the real win. #Day95 #Consistency #BackendDevelopment #Java #SpringBoot #SystemDesign #100DaysOfCode

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

🔄 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