Spring Bean Lifecycle Explained in 8 Steps

Spent 25 minutes wondering why my Spring Boot scheduled task was running twice. The code looked fine: @Scheduled(fixedRate = 5000) public void processQueue() {   System.out.println("Processing..."); } No errors. App started fine. But the log showed the task running twice every 5 seconds. The problem: I had @SpringBootApplication on my main class AND @EnableScheduling on a separate config class. Spring created two schedulers. The fix: Keep @EnableScheduling only in one place. @SpringBootApplication @EnableScheduling public class MyApp {   public static void main(String[] args) {     SpringApplication.run(MyApp.class, args);   } } One annotation in the wrong place. That was it. Spring does not warn you when scheduling is enabled multiple times. It just creates duplicate schedulers. What duplicate execution issue has caught you off guard? #Java #SpringBoot #Debugging #BackendDevelopment

Spent 25 minutes wondering why my Spring Boot async method was running synchronously. The code looked fine: @Async public void sendEmail(String to) {   // sending logic } No errors. App started fine. But the method blocked the main thread every time. The problem: I forgot to add @EnableAsync to my main class. @SpringBootApplication @EnableAsync public class MyApp {   public static void main(String[] args) {     SpringApplication.run(MyApp.class, args);   } } One annotation. That was it. Spring Boot does not warn you if @Async methods exist but async is not enabled. It just runs them synchronously. What annotation have you forgotten that caused unexpected behavior? #Java #SpringBoot #Debugging #BackendDevelopment

Backend Ladder #004: Timeouts are a feature No timeout = "I'm okay waiting forever." You're not. Your users aren't. Your thread pool definitely isn't. My rule for every external call: - a timeout (always) - a retry policy (sometimes none — that's fine) - a clear fallback (even if it's just a fast error) 💬: One missing timeout could take down an entire checkout flow. The dependency was fine. We weren't. #Reliability #Java #SpringBoot — 📌 I’m running a Backend Ladder series to share the notes, patterns, and hard lessons I’ve collected over the years building backend systems—one small topic at a time.

Every Spring Boot application revolves around Beans. But do you really know what happens behind the scenes? Here’s the complete lifecycle of a Spring Bean inside the IoC Container: 1️⃣ Container Started 2️⃣ Bean Created 3️⃣ Dependencies Injected (@Autowired, Constructor, Setter) 4️⃣ Bean Initialized (@PostConstruct, init methods, InitializingBean) 5️⃣ Bean Ready for Use 6️⃣ Bean Used by the Application 7️⃣ Container Shutdown 8️⃣ Bean Destroyed (@PreDestroy, destroy(), DisposableBean) 💡 Why This Matters Understanding the bean lifecycle helps you: ✔ Debug initialization issues ✔ Handle resource management properly ✔ Avoid memory leaks ✔ Use @PostConstruct and @PreDestroy correctly ✔ Perform better in Spring interviews Most developers use Spring. Fewer understand what happens inside the container. Master the internals → Write better backend systems. #Spring #SpringBoot #Java #BackendDevelopment #JavaDeveloper #Microservices #SoftwareEngineering #Programming #Coding #DeveloperCommunity #TechLearning #SpringFramework #InterviewPreparation #CodingInterview #FullStackDeveloper

🚀 #SpringBoot Mastery: @Value Annotation — Reading Config into Your Beans Most developers hardcode configuration values. Senior engineers don't. Spring Boot's @Value annotation lets you inject properties from application.properties / application.yml directly into your bean fields — no magic, just clean, maintainable config. @Service public class PaymentService { @Value("${payment.api.url}") private String apiUrl; @Value("${payment.timeout:5000}") // default fallback private int timeout; @Value("${app.name}") private String appName; } And in application.properties: payment.api.url=https://api.payments.io/v2 payment.timeout=3000 app.name=MyShop Why does this matter? ✅ No hardcoded URLs or secrets in code ✅ Different values per environment (dev/staging/prod) ✅ Easier configuration changes without redeployment ✅ Supports SpEL (Spring Expression Language) for dynamic values Pro tip: Always define a default value with : syntax — it prevents startup failures when a property is missing. #Java #SpringBoot #BackendDevelopment #SoftwareEngineering #CleanCode

Day 17 – Spring Boot Annotations Explained Today I focused on understanding some important Spring Boot annotations that power backend applications. -> @RestController Combines @Controller and @ResponseBody. It is used to create REST APIs and return JSON responses directly. -> @RequestMapping Maps HTTP requests to specific handler methods. It defines the URL path and supports different HTTP methods like GET, POST, PUT, and DELETE. -> @Autowired Used for Dependency Injection. Spring automatically injects required beans into a class. -> @Configuration Indicates that a class contains bean definitions. Spring processes it to generate and manage beans in the application context. Understanding these annotations helps in writing clean, structured, and maintainable backend code. Spring Boot reduces complexity, but knowing what happens behind the scenes makes a real difference. #Day17 #SpringBoot #Java #BackendDevelopment #Annotations #LearningJourney

Spent 40 minutes wondering why my Spring Boot scheduler was not running. The code looked fine: @Scheduled(fixedRate = 5000) public void processQueue() {   System.out.println("Running..."); } No errors. App started fine. But the method never executed. The problem: I forgot to add @EnableScheduling to my main class. @SpringBootApplication @EnableScheduling public class MyApp {   public static void main(String[] args) {     SpringApplication.run(MyApp.class, args);   } } One annotation. That was it. Spring Boot does not warn you if @Scheduled methods exist but scheduling is not enabled. It just ignores them. What missing annotation has cost you debugging time? #Java #SpringBoot #Debugging #BackendDevelopment

DAY 62/100 | Building Consistency ⏳ Showing up every day. Learning, growing, and improving. Last time I explained why we have files like Controller, Service, Model, and Repository in the #backend. But some people asked another question: “Okay… but how does the whole process actually run?” So here’s the simple pathway of how a request usually moves in a backend system. User interacts with the application ↓ Frontend sends a request to the backend ↓ API endpoint is called (example: POST /api/...) ↓ Controller receives the request ↓ Service layer handles the main logic ↓ Response is returned from the backend ↓ Frontend displays the result to the user What looks like just one small action on the screen actually goes through multiple layers behind the scenes. Understanding this flow made backend development much clearer for me. Every layer has its own responsibility, which makes applications easier to manage and scale. Still learning. Still exploring. #BackendDevelopment #SpringBoot #Java #WebDevelopment #LearningInPublic