SpringBootApplication Explained: Auto-Configure and Start Spring Boot Apps

🚀 Day 6/100: Spring Boot From Zero to Production Topic: @SpringBootApplication Annotation Your setup is done, your dependencies are added, and now you are ready to write some actual code and business logic. It all begins from your Main Class. This class usually carries the name of your application and contains a main function, the exact point where the execution begins. But there is one very important part of this main class: the @Annotation. In simple terms, an annotation is metadata written after an @ sign. it tells the compiler and the framework specific information about your code. In our case, the star of the show is @SpringBootApplication. This is a "Meta-Annotation," meaning it’s a powerful 3-in-1 combo that keeps your code clean and organized: 1. @Configuration This marks the class as a source of bean definitions. It tells Spring that this class can contain methods annotated with @Bean. In the old days of Spring, you had to manage everything in bulky XML files. With this, we use pure Java to define our infrastructure. 2. @EnableAutoConfiguration This is the "secret sauce" that makes Spring Boot feel like magic. The Role: It tells Spring Boot to start adding beans based on what it finds on your classpath. If it sees h2.jar, it sets up an in-memory database for you. No more Boilerplate Nightmares. You don't have to manually set up a Data Source unless you want to override the defaults. 3. @ComponentScan 🔍 Think of this as the "Search Party" for your project. It tells Spring to hunt for other components, configurations, and services in your packages. It specifically looks for: @Component @Service @Repository @RestController The Scope: By default, it scans the package containing your main class and all sub-packages. This is why we always keep the main class in the root package! We’ve cracked open the entry point of every Spring Boot app. 🔓 See you in the next post. #Java #SpringBoot #SoftwareDevelopment #100DaysOfCode #Backend

🌱 How Spring Boot Starts Internally? 🚀 -->SpringApplication.run(MyApplication.class, args); Let’s break it down step by step 👇 🔄 Step-by-Step Internal Flow 1️⃣ JVM Starts the Main Method The main() method is executed. 2️⃣ SpringApplication.run() is Called This is where Spring Boot startup begins. 3️⃣ Create Application Context Spring Boot creates an ApplicationContext (IOC Container is initialized) 4️⃣ Auto-Configuration Starts Based on dependencies in pom.xml, Spring Boot configures beans automatically. Example: If Spring Web dependency exists → configure DispatcherServlet If JPA exists → configure EntityManager 5️⃣ Component Scanning Spring scans: @Component @Service @Repository @Controller @RestController Beans are created and registered. 6️⃣ Embedded Server Starts Spring Boot starts embedded: Tomcat (default) Jetty Undertow 7️⃣ Application Ready 🎉 App runs on: -->http://localhost:8080 🧠 Simple Understanding Spring Boot automatically: *Creates container *Configures beans *Starts server *Runs application All with one line of code. #SpringBoot #Java #BackendDevelopment #LearningInPublic #JavaDeveloper

What Happens Inside a Spring Boot Application When It Starts? When we start a Spring Boot application, something interesting happens in the background. Spring creates a container in RAM called the Spring IoC Container. This container's job is to: • Create objects • Store them in memory • Manage their lifecycle These managed objects are called Spring Beans. In my example image 👇 I created a class AddServiceImpl and marked it with @Service. When the application starts, Spring automatically creates the object of this class and stores it inside the container. You can see in the logs that the constructor is called only once during application startup. After that, whenever a request comes from the browser, Spring reuses the same object instead of creating a new one every time. This is why Spring applications are: ✔ Efficient ✔ Fast ✔ Memory optimized Because Spring manages object creation and reuse automatically. Understanding Spring Beans and IoC Container is one of the most important concepts when learning Spring Boot. #SpringBoot #Java #BackendDevelopment #SoftwareEngineering #LearningInPublic

🔍 A Small Spring Boot Issue That Reinforced an Important Lesson While setting up a backend module recently, I ran into a situation where Spring Boot was not detecting my JPA repositories. Everything looked correct at first glance: • Entities were defined • Repositories extended JpaRepository • The application started without errors Yet the repositories were not being registered. The root cause turned out to be package structure. Spring Boot scans components starting from the package where the main application class is located. If entities or repositories exist outside that package hierarchy, they won’t be detected automatically. Once the package structure was aligned correctly, Spring Boot detected the repositories and the application behaved as expected. It’s a small detail, but it highlights an important principle in Spring Boot: Convention over configuration. Understanding how the framework discovers components can save a lot of debugging time when working on larger applications. Have you run into similar small but costly framework issues? #SpringBoot #Java #BackendDevelopment #SoftwareEngineering

Spring Boot Magic: Component Scanning & Auto-Configuration Explained Simply One thing that amazed me while learning Spring Boot is how much it does automatically behind the scenes. Two powerful features make this possible: 👉 Component Scanning 👉 Auto-Configuration 🔹 Component Scanning When we start a Spring Boot app, it scans the package and finds classes annotated with: @Component @Service @Repository @RestController Example: @Service public class OrderService { } 👉 Spring automatically: - detects it - creates an object (bean) - manages it No manual object creation needed! 🔹 Auto-Configuration Spring Boot looks at: - dependencies (like web, database) - configuration and automatically sets things up. For example: Add spring-boot-starter-web 👉 You instantly get a running web server 😄 No need to configure Tomcat manually! 🔹 Why this is powerful ✅ Reduces boilerplate code ✅ Faster development ✅ Focus on business logic ✅ Clean and maintainable code 🔹 What actually happens @SpringBootApplication ↓ Component Scanning ↓ Bean Creation ↓ Dependency Injection ↓ App is ready 🚀 🔹 Key takeaway - Spring Boot handles the setup, so we can focus on solving real problems. Still exploring more Spring internals and building small projects to understand it deeper. #SpringBoot #Java #BackendDevelopment #AutoConfiguration #LearningJourney #SoftwareEngineering

Spring Boot Annotations — The Backbone of Every Application When I started learning Spring Boot, annotations felt confusing… But once I understood them, everything became much simpler. In simple terms: Annotations tell Spring Boot what to do and how to manage your code. --- 🔹 Some important ones: @SpringBootApplication → Entry point of the app ✅ @RestController → Handles API requests ✅ @Service → Business logic layer ✅ @Repository → Database interaction ✅ @Autowired → Injects dependencies automatically ✅ @RequestMapping → Maps HTTP requests --- Why annotations matter: Reduce boilerplate code Enable Dependency Injection Make applications modular & scalable Help Spring manage everything behind the scenes --- Instead of writing everything manually, Spring Boot = “Just add annotations, I’ll handle the rest.” --- Currently learning and applying these concepts step by step #SpringBoot #Java #BackendDevelopment #Annotations #LearningInPublic #FullStackDeveloper

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

🚀 What Actually Happens When a Spring Boot Application Starts? Most developers just run the app and see: "Started Application in 3.2 seconds" But inside the JVM, a lot more is happening 👇 1️⃣ JVM Starts The JVM launches and executes the "main()" method from the JAR. 2️⃣ Class Loading Begins Classes are loaded using: • Bootstrap ClassLoader • Platform ClassLoader • Application ClassLoader 3️⃣ Bytecode Verification JVM verifies bytecode to ensure security and correctness. 4️⃣ SpringApplication.run() Executes This initializes the Spring Application Context. 5️⃣ Component Scanning Spring scans the project for beans like: "@Controller" "@Service" "@Repository" "@Component" 6️⃣ Dependency Injection Spring connects all beans automatically. 7️⃣ AOP Proxies Created Spring creates proxies for features like logging, transactions, and security. 8️⃣ Embedded Server Starts Tomcat/Jetty starts and the application becomes ready to serve APIs. ⚡ Most startup errors occur during: • Bean creation • Dependency injection • Auto configuration • Missing environment properties Understanding this flow helps in debugging Spring Boot applications faster. 📌 Currently exploring Spring Boot internals and backend architecture. If you're learning Java & Spring Boot, let’s connect and grow together! 🤝 #Java #SpringBoot #JVM #BackendDevelopment #Programming

🚀 Day 1/100: Spring Boot From Zero to Production Topic: Why Spring Boot is a Game Changer Spring Boot is an open-source framework that makes Java application development a breeze. But what exactly is a framework? Think of a framework as an environment equipped with tools and best practices. It’s designed to provide a solid foundation for your code, saving you time and mental energy. Spring Boot takes "saving time" to the next level by providing opinionated defaults and production-ready features. It allows developers to focus on building actual features instead of reinventing the wheel or wasting hours on boilerplate setup. The "Magic" behind Spring Boot: Auto-configuration: Spring Boot automatically configures Beans based on the dependencies in your classpath. It’s highly flexible, if you don't like the default, you can easily override it by creating your own Beans. Embedded Servers: A total game-changer. Tomcat is ready to serve right out of the box, though you can swap it for a custom one if needed. No external server setup required! Production-Ready Features: It comes pre-packed with monitoring, metrics, and health checks to ensure your app is ready for the real world. I’ll be diving deep into all these "fancy terms" over the next 100 Days of Spring Boot Made Easy. See you in the next post! 👋 #Java #SpringBoot #SoftwareDevelopment #100DaysOfCode #Backend

Day 1 of 15 -> The Heart of Spring Boot: Beans #SpringBootChallenge | Day 1/15 When I first started with Spring Boot, one word kept appearing: Bean. Phrases like "Register it as a Bean," "Inject the Bean," and "Spring manages the Bean" were everywhere, but I had no idea what it meant, so I ignored it. That was a big mistake. So, what is a Bean? In plain Java, when you need an object, you create it yourself: UserService service = new UserService(); It's simple, but now you are responsible for creating, managing, destroying, and passing it around. In Spring Boot, you delegate that responsibility. You tell Spring, "Hey, manage this object for me." That object is called a Bean. Why is this important? Imagine a large application with 50 classes, all depending on each other. Without Spring, you manually create and wire every object. With Spring, you declare it once, and Spring handles the rest. This is known as Inversion of Control (IoC); you don't control the object lifecycle Spring does. The tool Spring uses to inject these beans where needed is Dependency Injection (DI). The result is: - Less boilerplate code - Loosely coupled components - Easier to test and maintain - One instance shared across the app (by default)