How a Spring Boot Application Starts: A Simple, Story-Based End-to-End

🔥 How a Spring Boot Application Starts: A Simple, Story-Based End-to-End Explanation

Spring Boot is loved for its simplicity. You write a few lines of code, add an annotation here and there, press Run, and magically—your application starts scanning components, wiring dependencies, preparing an embedded server, and responding to HTTP requests.

To beginners, this entire process feels like a black box. Even many experienced developers admit:

“It works, but I’m not exactly sure how.”

This blog removes the mystery.

Instead of dry explanations, we’ll understand the full Spring Boot startup lifecycle through a fun, memorable story about building and opening a new business:

🏪 Boot Beans Coffee Shop — managed by Spring Boot itself.

Everything your application does—component scanning, bean creation, auto-configuration, dependency injection—becomes part of opening this coffee shop step-by-step.

By the end, you’ll have a crystal-clear understanding of Spring Boot’s internal workflow, and you’ll never see Spring Boot the same way again.

☕ Chapter 1: The Blueprint — Where Spring Boot Begins

Every great building project needs a starting point, and for a Spring Boot application, that point is the main() method.

@SpringBootApplication
public class BootBeanApplication{
    public static void main(String[] args){
           SpringApplication.run(BootBeanApplication.class, args);
    }
}

This tiny method is powerful. It sets everything in motion:

The JVM starts executing your application.
- SpringApplication.run() calls Spring Boot into action.
  - Spring Boot reads the master annotation @SpringBootApplication.

Think of this annotation as placing the blueprint of the coffee shop on a desk and calling in your project manager:

“Spring Boot, we’re building a coffee shop called Boot Beans.
Here’s the manual. Please take charge.”

Without this blueprint, Spring Boot would have no idea where to start.

🧑‍💼 Chapter 2: The Project Manager Arrives

Running SpringApplication.run() summons Spring Boot—the project manager who organizes everything.

It immediately opens the instruction manual: the @SpringBootApplication annotation.

Inside it discovers:

@Configuration → “This application has configurations.”
@ComponentScan → “Please search for workers here.”
@EnableAutoConfiguration → “Set up tools automatically.”

Project Manager Spring Boot lifts its head:

“Ah! We're building a web application. Time to assemble the crew, tools, and machinery.”

This is the moment the application truly begins.

🔍 Chapter 3: Searching for Workers — Component Scanning

Now Spring Boot begins walking through your project's folders:

com.myshop

controllers
services
repositories
config

It’s like walking through a neighborhood searching for skilled workers.

Spring Boot checks every class and asks:

“Are you working in the coffee shop?”

Only classes wearing specific badges respond:

@Component
@Service
@Repository
@Controller
@RestController
@Configuration

For example:

@Service
public class BaristaService{}

Spring Boot sees the badge and says,

“Excellent! A Barista is available. I’ll add this to the worker list.”

But here’s a crucial detail:

Workers are not hired yet.

They’re only registered.

Spring Boot simply creates a BeanDefinition—a recipe for how to create that worker later.

Think of it as filling a folder with worker details during job interviews.

🧠 Chapter 4: Building the Command Center—The IoC Container

To manage so many workers, tools, and configurations, Spring Boot builds the heart of the shop:

🧠 The IoC Container (ApplicationContext)

This is the central operating brain.

It manages:

All workers (beans)
All relationships between them
When they are created
How long do they live
How are they destroyed

Just like a shop has a central office that manages employees, schedules, and tasks, the IoC container orchestrates everything behind the scenes.

🛠️ Chapter 5: Hiring the Workers—Bean Instantiation

After scanning and building definitions, Spring Boot begins actually hiring the workers.

Example worker:

@Service
public class PaymentService {}

The IoC container now says:

“Time to create the PaymentService worker!”

And executes:

new PaymentService();

This object is a bean—a managed worker in the Spring ecosystem.

Every class marked with component annotations becomes a bean—an employee ready to serve in the Boot Beans Coffee Shop.

🤝 Chapter 6: Giving Tools to Workers — Dependency Injection

Now that workers exist, they need their tools.

A Barista can’t brew coffee without an espresso machine or beans. Similarly, a Spring bean often needs other beans to function.

Example:

@Service
public class OrderService {

    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

Here, OrderService is saying:

“I can’t work unless I have PaymentService!”

Spring Boot responds:

“Of course! I already created a PaymentService bean. I’ll inject it for you.”

This process is called Dependency Injection (DI).

Why DI matters:

Workers don’t create their own tools (no new PaymentService()).
Spring manages everything.
If tools change, workers don’t need to know.
This makes the shop flexible and maintainable.

DI is one of the greatest strengths of Spring—and the IoC container handles it beautifully.

🎓 Chapter 7: Training the Workers—Post Processing

Before opening the shop, workers need training:

Learning safety rules
Receiving uniforms
Getting keycards
Understanding their roles

Spring does the same via post-processing, which includes:

✔ `@PostConstruct`

Runs immediately after the worker (bean) is fully prepared.

@PostConstruct
public void init() {
    System.out.println("OrderService is ready!");
}

✔ BeanPostProcessor

A powerful hook where Spring:

Adds logging
Applies security
Wraps beans with proxies
Enables transactions
Applies AOP features

This phase is like advanced worker training before the shop opens.

🧠 Chapter 8: Installing the Managers—Auto-Configuration

This is the genius part of Spring Boot.

Based on your project dependencies, Spring Boot automatically configures important components.

If you include:

spring-boot-starter-web
→ “You need a web server. Installing Tomcat.”
spring-boot-starter-jpa
→ “You’re using a database. Setting up DataSource and Hibernate.”
spring-boot-starter-security
→ “You need login and security. Enabling Spring Security defaults.”

It’s like Spring Boot hires a team of managers:

Web Manager
Database Manager
Security Manager
Logging Manager
Serialization Manager

These managers prepare everything using best practices—without needing configuration files.

Auto-configuration is what makes Spring Boot so easy and so powerful.

🚀 Chapter 9: Opening the Coffee Shop—Embedded Server Starts

Once:

✔ Workers (beans) are created
✔ Tools (dependencies) are injected
✔ Managers (auto-configurations) are installed
✔ Training (post-processing) is completed

Spring Boot finally announces:

“Boot Beans Coffee Shop is now officially OPEN!”

Technically, this is when:

Embedded Tomcat (or Jetty/Undertow) starts listening.

You see logs like:

Tomcat started on port(s): 8080
Started BootBeansApplication in 2.345 seconds

Your controllers are now ready to serve “customers” (HTTP requests).

Example:

@RestController
public class HomeController {

    @GetMapping("/")
    public String hello() {
        return "Shop is open!";
    }
}

Visiting:

http://localhost:8080

It means you’ve just walked into the coffee shop.

🧪 Real Example

Let’s build a minimal version of the Boot Beans Coffee Shop.

📁 Structure

com.myshop
 ├── DemoApplication.java
 ├── controllers
 ├── services
 └── repositories

@SpringBootApplication
public class DemoApplication{
    public static void main(String[] args){
        SpringApplication.run(DemoApplication.class, args);
    }
}

Controller, Services, Repository (Simplified)

@RestController
public class CoffeeController {

    private final BaristaService barista;

    public CoffeeController(BaristaService barista) {
        this.barista = barista;
    }

    @GetMapping("/brew")
    public String brewCoffee() {
        return barista.brew();
    }
}

@Service
public class BaristaService {

    private final CoffeeBeanRepository beans;

    public BaristaService(CoffeeBeanRepository beans) {
        this.beans = beans;
    }

    public String brew() {
        return "Brewing coffee with " + beans.count() + " beans!";
    }
}

@Repository
public class CoffeeBeanRepository {

    public int count() {
        return 42;
    }
}

Visiting /brew returns:

Brewing coffee with 42 beans!

Your shop is fully operational.

Spring Boot Startup—Technical Summary

JVM calls main()
SpringApplication.run() starts Spring Boot
ApplicationContext (IoC Container) created
Component Scan runs
Bean Definitions created
Beans instantiated
Dependencies injected
@PostConstruct executed
BeanPostProcessors applied
Auto-configurations applied
Embedded server starts
Application ready

This is the complete Spring Boot lifecycle.

🎉 Conclusion

Spring Boot is not magic.

It’s a beautifully organized system that:

Reads your blueprint
Finds workers
Creates and equips them
Configures managers
Trains everyone
Starts the server
Opens the shop

Once you understand this lifecycle, everything in Spring Boot becomes clearer:

Why certain errors occur
When beans are created
How dependencies are injected
How auto-configuration works

You gain power and confidence, because now you understand the engine under the hood.

How a Spring Boot Application Starts: A Simple, Story-Based End-to-End Explanation