How Spring Boot Auto-Configuration Works

@SpringBootConfiguration    // a @Configuration: the class can declare @Bean methods
@EnableAutoConfiguration    // load the auto-configuration classes
@ComponentScan              // scan this class's package and its sub-packages
public @interface SpringBootApplication {
  Class<?>[] exclude() default {};
  // ...
}

//ImportsApp.java
package com.javabrahman.boot.autoconfig.imports;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.Enumeration;
import java.util.List;

public class ImportsApp {
  static final String IMPORTS = "META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports";

  public static void main(String[] args) throws IOException {
    Enumeration<URL> files = ImportsApp.class.getClassLoader().getResources(IMPORTS);
    int total = 0;
    while (files.hasMoreElements()) {
      URL url = files.nextElement();
      if (!url.getProtocol().equals("jar")) {
        continue;   // list the jars only, not this tutorial's own classes folder
      }
      List<String> classes;
      try (InputStream in = url.openStream()) {
        classes = new String(in.readAllBytes()).lines()
            .map(String::strip).filter(line -> !line.isEmpty() && !line.startsWith("#")).toList();
      }
      String jar = url.toString().replaceAll(".*/([^/!]+\\.jar)!.*", "$1");
      System.out.printf("%-48s %3d%n", jar, classes.size());
      total += classes.size();
    }
    System.out.println("Auto-configuration classes in total: " + total);
  }
}

@AutoConfiguration
@ConditionalOnClass(MBeanExporter.class)                                   // the library is present
@ConditionalOnBooleanProperty(name = "spring.jmx.enabled")                 // and switched on
public final class JmxAutoConfiguration {

  @Bean
  @ConditionalOnMissingBean(value = MBeanExporter.class, search = SearchStrategy.CURRENT)
  MBeanExporter mbeanExporter(...) {                                       // unless the application has one
    ...
  }
}

//ReportApp.java
package com.javabrahman.boot.autoconfig.report;

import java.util.Map;
import java.util.TreeMap;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.condition.ConditionEvaluationReport;
import org.springframework.boot.autoconfigure.condition.ConditionEvaluationReport.ConditionAndOutcomes;

@SpringBootApplication
public class ReportApp {
  public static void main(String[] args) {
    try (var context = SpringApplication.run(ReportApp.class, args)) {
      ConditionEvaluationReport report = ConditionEvaluationReport.get(context.getBeanFactory());
      Map<String, ConditionAndOutcomes> results = new TreeMap<>(report.getConditionAndOutcomesBySource());

      System.out.println("MATCHED (applied):");
      results.keySet().removeIf(source -> !source.startsWith("org.springframework"));   // Spring Boot's own only
      results.forEach((source, outcomes) -> {
        if (outcomes.isFullMatch()) {
          System.out.println("  " + shorten(source));
        }
      });
      System.out.println("NOT MATCHED (skipped), with the reason:");
      results.forEach((source, outcomes) -> {
        if (!outcomes.isFullMatch()) {
          System.out.println("  " + shorten(source));
          outcomes.forEach(o -> {
            if (!o.getOutcome().isMatch()) {
              System.out.println("      " + o.getOutcome().getMessage());
            }
          });
        }
      });
    }
  }

  static String shorten(String className) {
    return className.replace("org.springframework.boot.", "").replace("autoconfigure.", "");
  }
}

//OwnExecutorConfig.java
package com.javabrahman.boot.extra;

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class OwnExecutorConfig {
  @Bean
  Executor reportExecutor() {
    return Executors.newFixedThreadPool(2);
  }
}

//BackOffApp.java
package com.javabrahman.boot.autoconfig.backoff;

import java.util.Arrays;
import java.util.concurrent.Executor;
import com.javabrahman.boot.extra.OwnExecutorConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class BackOffApp {
  public static void main(String[] args) {
    show("Boot's default:", SpringApplication.run(BackOffApp.class));
    // OwnExecutorConfig is outside the scanned package, so it is added as a second configuration source
    show("With our own Executor bean:", SpringApplication.run(new Class<?>[] {BackOffApp.class, OwnExecutorConfig.class}, args));
  }

  static void show(String label, ConfigurableApplicationContext context) {
    try (context) {
      System.out.println(label);
      Arrays.stream(context.getBeanNamesForType(Executor.class))
          .forEach(name -> System.out.println("  Executor bean '" + name + "' of type " + context.getType(name).getSimpleName()));
    }
  }
}

// 1. On the main class
@SpringBootApplication(exclude = TaskSchedulingAutoConfiguration.class)
public class ShopApplication { ... }

// 2. In application.properties (useful per environment, without a code change)
spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration

//Greeter.java
package com.javabrahman.greeting;

public class Greeter {
  private final String salutation;

  public Greeter(String salutation) {
    this.salutation = salutation;
  }

  public String greet(String name) {
    return salutation + ", " + name + "!";
  }
}

//GreetingAutoConfiguration.java
package com.javabrahman.greeting;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBooleanProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;

@AutoConfiguration
@ConditionalOnBooleanProperty(name = "greeting.enabled", matchIfMissing = true)
public class GreetingAutoConfiguration {

  @Bean
  @ConditionalOnMissingBean
  Greeter greeter(@Value("${greeting.salutation:Hello}") String salutation) {
    return new Greeter(salutation);
  }
}

com.javabrahman.greeting.GreetingAutoConfiguration

//GreetingApp.java
package com.javabrahman.boot.autoconfig.custom;

import com.javabrahman.greeting.Greeter;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class GreetingApp {
  public static void main(String[] args) {
    try (var context = SpringApplication.run(GreetingApp.class, args)) {
      var greeter = context.getBeanProvider(Greeter.class).getIfAvailable();
      System.out.println(String.join(" ", args) + " -> "
          + (greeter == null ? "no Greeter bean" : greeter.greet("Deborah Sprightly")));
    }
  }
}