Fixing Spring Boot Async Method Synchronous Issue

Spent 15 minutes wondering why my Spring Boot @Async method was running synchronously. The code looked fine: @Async public void sendEmail(String to) {   // send email logic } No errors. App started fine. But the method was blocking the main thread. The problem: Missing @EnableAsync on the main application class. The fix: @SpringBootApplication @EnableAsync public class MyApplication {   public static void main(String[] args) {     SpringApplication.run(MyApplication.class, args);   } } One annotation. That was it. Spring does not warn you when async is disabled. It just runs your @Async methods synchronously. What async issue has caught you off guard? #Java #SpringBoot #Async #Debugging #BackendDevelopment

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 10 minutes wondering why my Spring Boot @Scheduled task was not running. The code looked fine: @Scheduled(fixedRate = 5000) public void runTask() { System.out.println("Task running..."); } No errors. App started fine. But the task never executed. The problem: Missing @EnableScheduling on the main application class. The fix: @SpringBootApplication @EnableScheduling public class MyApplication { public static void main(String[] args) { SpringApplication_run(MyApplication.class, args); } } One annotation. That was it. Spring does not warn you when scheduling is disabled. It just silently ignores your @Scheduled methods. What scheduling issue has caught you off guard? #Java #SpringBoot #Scheduling #Debugging #BackendDevelopment

Spent 15 minutes wondering why my Spring Boot application was not picking up environment variables. The code looked fine: @Value("${API_KEY}") private String apiKey; No errors. App started fine. But apiKey was always null. The problem: Environment variables use underscores, but Spring expects dots in property names by default. The fix: Use relaxed binding or set it correctly in application-properties. spring.application.api-key=${API_KEY} Then inject it: @Value("${spring.application.api-key}") private String apiKey; One mapping. That was it. Spring does not warn you when it cannot resolve an environment variable. It just injects null and moves on. What environment variable issue has caught you off guard? #Java #SpringBoot #Debugging #BackendDevelopment

🚀 Spring Boot Auto-configuration: The Magic Behind the Curtain Ever wondered how Spring Boot "just works" the moment you add a dependency? No XML, no manual bean wiring — it simply configures itself. That's Auto-configuration in action. When your app starts, Spring Boot scans META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports (Spring Boot 3) for hundreds of configuration classes. Each one is guarded by @ConditionalOn* annotations — they activate only when the right classes or properties are on the classpath. @AutoConfiguration @ConditionalOnClass(DataSource.class) @ConditionalOnMissingBean(DataSource.class) public class DataSourceAutoConfiguration { @Bean public DataSource dataSource() { return new HikariDataSource(); } } Add spring-boot-starter-data-jpa → DataSource class appears → auto-config fires → you get a connection pool for free. Define your own DataSource bean → @ConditionalOnMissingBean kicks in → auto-config backs off. You stay in control. Key conditionals to know: • @ConditionalOnClass — class must exist on classpath • @ConditionalOnMissingBean — no custom bean defined yet • @ConditionalOnProperty — specific property is set #Java #SpringBoot #BackendDevelopment #AutoConfiguration #SpringFramework

@SpringBootApplication Explained 🚀 ✅ What is @SpringBootApplication? It is the main annotation used to start a Spring Boot application. Just one annotation replaces multiple configurations. 🔍 What does it contain internally? @SpringBootApplication is a combination of 3 annotations: 1️⃣ @Configuration → Marks the class as a configuration class 2️⃣ @EnableAutoConfiguration → Spring Boot automatically configures beans based on dependencies 3️⃣ @ComponentScan → Scans and registers all components (@Component, @Service, etc.) 🧠 In Simple Words This annotation tells Spring Boot: “Configure everything automatically and start the application.” 🧩 Example @SpringBootApplication public class MyApplication { public static void main(String[] args) { SpringApplication.run(MyApplication.class, args); } } ✔ Starts embedded server ✔ Loads Spring context ✔ Runs the application 💡 Why It’s Important Reduces boilerplate code Makes Spring Boot beginner-friendly Mandatory for every Spring Boot app Understanding how Spring Boot applications actually start 🚀 #SpringBoot #Java #SpringFramework #LearningInPublic #BackendDeveloper

Spent 10 minutes wondering why my Spring Boot application was ignoring my config file. The code looked fine. The properties were correct. But the app kept using default values. No errors. No warnings. Just silence. The problem: The config file was placed in the wrong folder. I had it in src/main/resources/config instead of src/main/resources. The fix: Move the file to src/main/resources. One folder. That was it. Spring Boot does not warn you when it cannot find your config file. It just uses defaults and moves on. What config file issue has caught you off guard? #Java #SpringBoot #Debugging #BackendDevelopment

Handling Errors Like a Pro in Spring Boot In real-world applications, things WILL go wrong — Invalid input, server issues, database failures… So how do we handle them properly? Instead of writing try-catch everywhere, Spring Boot gives a clean solution: @ControllerAdvice @ExceptionHandler In simple terms: Spring Boot = “Don’t worry, I’ll handle all errors in one place.” --- Example: If a user is not found → return proper message If input is invalid → return clean error response --- Why this is important: ✔ Cleaner code (no messy try-catch everywhere) ✔ Centralized error handling ✔ Better API responses ✔ Production-ready backend --- Currently learning and applying these concepts step by step #SpringBoot #Java #BackendDevelopment #ExceptionHandling #LearningInPublic

Most beginners handle exceptions like this: try {  userService.findUser(id); } catch (Exception e) {  return "Something went wrong"; } Don't do this. Spring Boot gives you a cleaner way: @ControllerAdvice @ControllerAdvice public class GlobalExceptionHandler {  @ExceptionHandler(UserNotFoundException.class)  public ResponseEntity<String> handleNotFound(UserNotFoundException ex) {   return ResponseEntity.status(404).body(ex.getMessage());  }  @ExceptionHandler(Exception.class)  public ResponseEntity<String> handleGeneral(Exception ex) {   return ResponseEntity.status(500).body("Internal server error");  } } Why this is better: ✅ One place for all error handling ✅ Clean controllers — no try/catch everywhere ✅ Consistent API error responses ✅ Easy to extend as your app grows Your API consumers will thank you for returning proper HTTP status codes. #Java #SpringBoot #ExceptionHandling #BackendDevelopment #LearningInPublic

🚀 Spring Boot Series #006 Spring Bean Lifecycle — The Hidden Magic Behind Your Application Ever wondered what really happens when your Spring Boot app starts? It’s not just objects being created… it’s a well-orchestrated lifecycle 🔄 Let’s break it down 👇 🔹 1. 𝗕𝗲𝗮𝗻 𝗜𝗻𝘀𝘁𝗮𝗻𝘁𝗶𝗮𝘁𝗶𝗼𝗻 Spring creates the bean instance (using constructor or factory method). 👉 “Object is born” — but not ready yet. 🔹 2. 𝗗𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝘆 𝗜𝗻𝗷𝗲𝗰𝘁𝗶𝗼𝗻 Spring injects required dependencies (@Autowired, constructor injection, etc.) 👉 Now your bean starts gaining power ⚡ 🔹 3. 𝗔𝘄𝗮𝗿𝗲 𝗜𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲𝘀 (Optional but powerful) Spring injects internal context via interfaces like: BeanNameAware ApplicationContextAware 👉 Your bean becomes Spring-aware 🧠 🔹 4. 𝗕𝗲𝗮𝗻 𝗣𝗼𝘀𝘁-𝗣𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴 (Before Init) Custom logic via BeanPostProcessor 👉 Great place for custom proxies, logging, auditing 🔹 5. 𝗜𝗻𝗶𝘁𝗶𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻 𝗣𝗵𝗮𝘀𝗲 This is where your bean becomes fully ready! Ways to initialize: @PostConstruct InitializingBean.afterPropertiesSet() Custom init-method 👉 “I’m ready to serve!” 💪 🔹 6. 𝗕𝗲𝗮𝗻 𝗣𝗼𝘀𝘁-𝗣𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴 (After Init) Another chance to modify the bean (AOP magic happens here ✨) 🔹 7. 𝗕𝗲𝗮𝗻 𝗶𝘀 𝗥𝗲𝗮𝗱𝘆 𝘁𝗼 𝗨𝘀𝗲 Finally, your bean is in action 🎯 🔹 8. 𝗗𝗲𝘀𝘁𝗿𝘂𝗰𝘁𝗶𝗼𝗻 𝗣𝗵𝗮𝘀𝗲 When the app shuts down: @PreDestroy DisposableBean.destroy() Custom destroy-method 👉 Cleanup resources 🧹 #SpringBeansLifecycle #Java #BackendDevelopment #SpringBoot #SoftwareEngineering #SpringBootwithVC