CommandLineRunner and ApplicationRunner in Spring Boot

1️⃣ Introduction

In a Spring Boot application, sometimes you need to execute some logic right after the application starts.

• Preloading data into the database
• Validating configuration
• Logging startup information
• Running background initialization tasks
• Setting up cache
• Running migration scripts

Spring Boot provides two interfaces for this purpose:

• CommandLineRunner
• ApplicationRunner

Both are executed after the Spring ApplicationContext is fully loaded.

2️⃣ Execution Lifecycle Position

Application Starts
        ↓
Spring Context Initialization
        ↓
Beans Created & Dependencies Injected
        ↓
CommandLineRunner / ApplicationRunner Executed
        ↓
Application Ready

• They run after all beans are created
• They run before the application starts serving requests

3️⃣ CommandLineRunner

📌 Definition

CommandLineRunner is a functional interface provided by Spring Boot.

@FunctionalInterface
public interface CommandLineRunner {
    void run(String... args) throws Exception;
}

📌 Example: Basic Usage

@Component
public class MyCommandLineRunner implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {

        System.out.println("Application started successfully!");

        for (String arg : args) {
            System.out.println("Argument: " + arg);
        }
    }
}

📌 Real-World Example: Preloading Data

@Component
public class DataLoader implements CommandLineRunner {

    private final UserRepository userRepository;

    public DataLoader(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public void run(String... args) {
        userRepository.save(new User("Admin", "admin@example.com"));
        System.out.println("Default user created");
    }
}

4️⃣ ApplicationRunner

📌 Definition

@FunctionalInterface
public interface ApplicationRunner {
    void run(ApplicationArguments args) throws Exception;
}

📌 Example Implementation

@Component
public class MyApplicationRunner implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) throws Exception {

        System.out.println("ApplicationRunner executed");

        if (args.containsOption("name")) {
            System.out.println("Name: " + args.getOptionValues("name"));
        }

        System.out.println("Non-option args: " + args.getNonOptionArgs());
    }
}

5️⃣ CommandLineRunner vs ApplicationRunner

6️⃣ Execution Order

@Component
@Order(1)
public class FirstRunner implements CommandLineRunner {

    @Override
    public void run(String... args) {
        System.out.println("First Runner");
    }
}

7️⃣ Important Notes

• Runs only once during application startup
• If exception is thrown → Application startup fails
• Long-running code delays startup

8️⃣ Best Practices

• Keep logic lightweight
• Avoid long blocking operations
• Handle exceptions properly
• Use @Order if multiple runners exist

9️⃣ Internal Working

1. Creates ApplicationContext
2. Loads all Beans
3. Identifies CommandLineRunner & ApplicationRunner
4. Sorts them (if ordered)
5. Executes run() method

🔟 Summary

📌 Final Takeaway

• Both interfaces are used for startup logic
• Both run after the application context is ready
• Choose based on argument handling needs