1. When the application launches, Spring Boot does:

SpringApplication.run("MyApp.class");

This triggers Spring to create an ApplicationContext instance, which will hold all beans

2. Spring scans your packages

Spring looks for classes annotated with:

• @Component
• @Service
• @Repository
• @Controller / @RestController
• @Configuration
• and any class discovered under component scan

This is called classpath scanning.

3. Spring registers BeanDefinitions

When Spring scans your application for components, it does not create objects immediately.
Instead, Spring creates metadata called a BeanDefinition.

4. Spring creates bean instances

After analyzing all definitions, Spring starts creating beans:

• It looks at constructor parameters
• Resolves dependencies
• Creates the object
• Stores it in the ApplicationContext

5. Spring injects dependencies

Next, Spring performs dependency wiring:

• If Bean A needs Bean B → B is injected
• If the bean uses fields with @Autowired → reflection injects
• If the bean uses constructor injection → resolved in the step 4
• If the bean uses setter injection → setter is called

Dependencies are now fully wired.

6. Spring calls lifecycle callbacks

If a bean implements:

• InitializingBean
• DisposableBean
• @PostConstruct
• @PreDestroy

Spring calls these hooks at the appropriate time.

1. Use it to run one-off tasks

✅ Typical use cases include:

• Seeding initial data (e.g. default admin user, basic configuration)
• Verifying that external dependencies are reachable (e.g. third-party APIs, storage services)
• Performing lightweight warm-up tasks (e.g. pre-loading caches)

❌ They should not contain:

• Infinite loops or long-running background tasks, such as while(True)
• Core business workflows that are expected to run repeatedly

@Component
public class AdminUserInitializer implements CommandLineRunner {

    private final UserService userService;

    public AdminUserInitializer(UserService userService) {
        this.userService = userService;
    }

    @Override
    public void run(String... args) {
        // create admin account if it does not exist
        userService.createAdminUserIfMissing();
    }
}

A runner should mainly act as a trigger, not as a place to implement business logic.

2. Control where it runs (profiles / environments)

Spring Boot automatically loads configuration files based on the active profile.

For example, if Spring Boot has:

src/main/resources/
           │── application.yml
           │── application-dev.yml
           │── application-prod.yml

And CommandLineRunner files know when they should execute by @Profile

@Component
@Profile({"dev", "local"})
public class DevAdminInitializer implements CommandLineRunner {
    // ...
}

3. Avoid hard-coding secrets

We can use @value annotation in the CommandLineRunner file

@Component
public class AdminInitializer implements CommandLineRunner {

    @Value("${app.admin.username}")
    private String username;

    @Value("${app.admin.password}")
    private String rawPassword;

    @Override
    public void run(String... args) {
        userService.createAdminIfMissing(username, rawPassword);
    }
}

and application.yml

app:
  admin:
    username: admin
    password: ${APP_ADMIN_PASSWORD:changeme}