Spring Boot Internal Working

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
        // This single line, in order:
        // 1. Creates a SpringApplication instance
        // 2. Determines application type (SERVLET / REACTIVE / NONE)
        // 3. Loads listeners and initializers from spring.factories
        // 4. Prepares the Environment (application.properties, profiles, env vars)
        // 5. Creates the ApplicationContext and refreshes it
        //    (bean definitions are loaded, beans are created, web server is created)
        // 6. Starts accepting web requests
        // 7. Runs CommandLineRunners and ApplicationRunners
    }
}

// You can customize SpringApplication before run():
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(MyApplication.class);
        app.setBannerMode(Banner.Mode.OFF);      // disable startup banner
        app.setLazyInitialization(true);         // lazy bean initialization
        app.setDefaultProperties(Map.of(         // lowest-priority default properties
            "server.port", "9090"
        ));
        app.run(args);
    }
}

// Inside app.jar:
//
// META-INF/MANIFEST.MF
//   Main-Class: org.springframework.boot.loader.launch.JarLauncher   (Boot 3.2+)
//               org.springframework.boot.loader.JarLauncher          (older versions)
//   Start-Class: com.example.MyApplication      ← your real main class
//
// BOOT-INF/classes/        ← your compiled code and application.properties
// BOOT-INF/lib/            ← all dependency JARs (nested)
// org/springframework/boot/loader/   ← the launcher classes
//
// Startup flow:
// java -jar app.jar
//   → JVM runs JarLauncher.main()
//   → JarLauncher builds a class loader that understands BOOT-INF/classes and BOOT-INF/lib
//   → JarLauncher reads Start-Class and calls MyApplication.main()
//   → SpringApplication.run() begins

// Inspect it yourself:
// jar tf target/app.jar | head -30
// unzip -p target/app.jar META-INF/MANIFEST.MF

// Spring Boot checks the classpath (WebApplicationType.deduceFromClasspath):

// Reactive classes present (DispatcherHandler) AND no Servlet MVC (DispatcherServlet)
// AND no Jersey ServletContainer:
//   → WebApplicationType.REACTIVE
//   → Creates AnnotationConfigReactiveWebServerApplicationContext
//   → Starts embedded Netty (by default)

// Servlet API or Spring's web context class missing:
//   → WebApplicationType.NONE
//   → Creates AnnotationConfigApplicationContext
//   → No web server started (batch jobs, CLI tools, etc.)

// Otherwise (jakarta.servlet.Servlet and ConfigurableWebApplicationContext present):
//   → WebApplicationType.SERVLET
//   → Creates AnnotationConfigServletWebServerApplicationContext
//   → Starts embedded Tomcat (or Jetty/Undertow)

// You can force the type in code:
SpringApplication app = new SpringApplication(MyApplication.class);
app.setWebApplicationType(WebApplicationType.NONE);   // force non-web
app.run(args);

// Or with a property:
// spring.main.web-application-type=none

// @SpringBootApplication =
//   @SpringBootConfiguration  (a specialized @Configuration)
// + @EnableAutoConfiguration
// + @ComponentScan

// @ComponentScan scans the main class package and all sub-packages:
// Finds: @Component, @Service, @Repository, @Controller, @RestController,
//        @Configuration, @Aspect, and other stereotype annotations
// Registers found classes as bean definitions in the BeanFactory

// @SpringBootConfiguration marks the class as a bean definition source:
// Any @Bean methods in the class produce beans

// @EnableAutoConfiguration is the key Spring Boot addition:
// It imports AutoConfigurationImportSelector
// Which reads META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
// (Boot 2.7 deprecated, and Boot 3.0 removed, the spring.factories way)
// That file, inside spring-boot-autoconfigure, lists well over 100 auto-configuration classes

// Example entries in AutoConfiguration.imports:
// org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration
// org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration
// org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration
// org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration
// ... and many more

// Package layout that works:
// com.example.myapp.MyApplication          ← main class (root package)
// com.example.myapp.controller.UserController   ← scanned
// com.example.myapp.service.UserService         ← scanned
// com.example.other.Something                   ← NOT scanned

// Simplified idea of DataSourceAutoConfiguration
// (real class differs between Boot versions):

@AutoConfiguration(before = SqlInitializationAutoConfiguration.class)
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceAutoConfiguration {

    // Applies only when an embedded DB (H2, HSQL, Derby) is on the classpath
    // and you have not defined your own DataSource
    @Configuration(proxyBeanMethods = false)
    @Conditional(EmbeddedDatabaseCondition.class)
    @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
    @Import(EmbeddedDataSourceConfiguration.class)
    protected static class EmbeddedDatabaseConfiguration { }

    // Applies when a connection pool (HikariCP by default) is available
    // and spring.datasource.url is set
    @Configuration(proxyBeanMethods = false)
    @Conditional(PooledDataSourceCondition.class)
    @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
    protected static class PooledDataSourceConfiguration { }
}

// The key @Conditional annotations:
// @ConditionalOnClass          — applies if a class IS on the classpath
// @ConditionalOnMissingClass   — applies if a class is NOT on the classpath
// @ConditionalOnBean           — applies if a bean IS already defined
// @ConditionalOnMissingBean    — applies if a bean is NOT already defined
// @ConditionalOnProperty       — applies if a property has a specific value
// @ConditionalOnWebApplication — applies in web applications only
// @ConditionalOnExpression     — applies based on a SpEL expression

// This is why defining your own bean OVERRIDES auto-configuration:
@Bean
public DataSource dataSource() {
    // Your custom DataSource — @ConditionalOnMissingBean on auto-config
    // sees your bean and skips the default one
    return myCustomDataSource();
}

// The refresh() phases, in order:

// 1. prepareRefresh / obtainFreshBeanFactory
//    — Environment validated, empty BeanFactory ready

// 2. invokeBeanFactoryPostProcessors
//    — ConfigurationClassPostProcessor parses @Configuration classes,
//      runs @ComponentScan, processes @Import and @Bean methods
//    — Auto-configurations are imported LAST (DeferredImportSelector),
//      so your beans are registered first and @ConditionalOnMissingBean sees them
//    — At this point only bean DEFINITIONS exist, no objects yet

// 3. registerBeanPostProcessors
//    — e.g. AutowiredAnnotationBeanPostProcessor, AOP proxy creators

// 4. onRefresh
//    — Web applications: the embedded server (Tomcat/Netty) is created here

// 5. finishBeanFactoryInitialization
//    — Every non-lazy singleton bean is created, in this order per bean:
//      a. Instantiate (call constructor, resolving constructor arguments)
//      b. Inject dependencies (@Autowired fields and setters)
//      c. Aware callbacks (BeanNameAware, ApplicationContextAware, ...)
//      d. BeanPostProcessor before-init
//      e. @PostConstruct, then InitializingBean.afterPropertiesSet(), then custom init
//      f. BeanPostProcessor after-init (AOP proxies for @Transactional, @Async, etc.
//         are created here)

// 6. finishRefresh
//    — Lifecycle beans start; the web server starts accepting requests
//    — ContextRefreshedEvent and WebServerInitializedEvent are published

// Hook points:

// Run code after a specific bean's dependencies are injected:
@Component
public class StartupValidator {
    @PostConstruct   // jakarta.annotation.PostConstruct (Boot 3+)
    public void validate() {
        System.out.println("Validating configuration...");
    }
}

// Run code after the context is started, before ApplicationReadyEvent:
@Component
@Order(1)   // control the order of multiple runners
public class DataSeeder implements CommandLineRunner {
    @Override
    public void run(String... args) {
        System.out.println("Seeding initial data...");
    }
}

// ApplicationRunner — same, but receives parsed ApplicationArguments:
@Component
public class AppStartup implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) {
        System.out.println("App started with args: " + args.getOptionNames());
    }
}

// What happens for the embedded server:
// 1. During refresh (onRefresh), TomcatServletWebServerFactory creates the server
//    — port from server.port (default 8080)
//    — connector, compression and SSL settings applied
// 2. Spring's DispatcherServlet is registered with the server
//    — it routes incoming HTTP requests to your controllers
// 3. At the end of refresh (finishRefresh), the server starts accepting requests
//    and WebServerInitializedEvent is published
// 4. ApplicationStartedEvent is published
// 5. CommandLineRunners and ApplicationRunners execute
// 6. ApplicationReadyEvent is published — app is ready

// Customize the embedded server in code:
@Configuration
public class ServerConfig {
    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory> tomcatCustomizer() {
        return factory -> {
            factory.setPort(9090);
            factory.addConnectorCustomizers(connector -> {
                connector.setMaxPostSize(10 * 1024 * 1024);  // 10MB max POST body
            });
        };
    }
}

// Or via application.properties (preferred for simple settings):
// server.port=8080
// server.tomcat.connection-timeout=10s
// server.tomcat.max-connections=10000
// server.tomcat.threads.max=200
// server.tomcat.threads.min-spare=10
// server.compression.enabled=true
// server.ssl.key-store=classpath:keystore.p12

// Application events in order of publication:

// 1. ApplicationStartingEvent            — very early, before anything is prepared
// 2. ApplicationEnvironmentPreparedEvent — Environment ready, context not created yet
// 3. ApplicationContextInitializedEvent  — context created, bean definitions not loaded
// 4. ApplicationPreparedEvent            — bean definitions loaded, context not refreshed
// 5. ContextRefreshedEvent               — context refreshed, beans created
// 6. WebServerInitializedEvent           — embedded web server is accepting requests
// 7. ApplicationStartedEvent             — context refreshed, before runners
// 8. AvailabilityChangeEvent (LivenessState.CORRECT)           — app is live
// 9. CommandLineRunners and ApplicationRunners are called
// 10. ApplicationReadyEvent              — runners finished, app fully started
// 11. AvailabilityChangeEvent (ReadinessState.ACCEPTING_TRAFFIC) — ready for traffic
//
// ApplicationFailedEvent is published instead if startup fails at any point.

// Normal listener beans — fine for events 5 to 11:
@Component
public class StartupListener {

    @EventListener(ApplicationReadyEvent.class)
    public void onReady(ApplicationReadyEvent event) {
        System.out.println("Application fully started and ready!");
        // Safe to make external connections, start schedulers, etc.
    }
}

// Early events (1 to 4, and ApplicationFailedEvent) need special registration:
public class EarlyListener implements ApplicationListener<ApplicationEnvironmentPreparedEvent> {
    @Override
    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
        System.out.println("Active profiles: "
            + Arrays.toString(event.getEnvironment().getActiveProfiles()));
    }
}

// Option 1 — register in code:
SpringApplication app = new SpringApplication(MyApplication.class);
app.addListeners(new EarlyListener());
app.run(args);

// Option 2 — register in META-INF/spring.factories:
// org.springframework.context.ApplicationListener=com.example.EarlyListener

// Enable the conditions report (choose one):
//   java -jar app.jar --debug
//   debug=true   in application.properties
//   GET /actuator/conditions   (with spring-boot-starter-actuator, endpoint exposed)

// The report shows these sections:
// POSITIVE MATCHES — auto-configs that were applied and why:
//   DataSourceAutoConfiguration matched:
//     - @ConditionalOnClass found required classes 'javax.sql.DataSource'
//     - @ConditionalOnMissingBean did not find any beans of type ConnectionFactory

// NEGATIVE MATCHES — auto-configs that were skipped and why:
//   MongoAutoConfiguration:
//     Did not match:
//       - @ConditionalOnClass did not find required class 'com.mongodb.client.MongoClient'

// EXCLUSIONS — auto-configs you explicitly disabled
// UNCONDITIONAL CLASSES — auto-configs applied with no conditions

// Exclude specific auto-configurations in code:
@SpringBootApplication(exclude = {
    SecurityAutoConfiguration.class,
    DataSourceAutoConfiguration.class
})
public class Application { }

// Or in application.properties (comma-separated, keep it on one line):
// spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration

// See all beans in the context:
// GET /actuator/beans (with Actuator enabled)
// Or programmatically:
@Component
public class BeanPrinter implements CommandLineRunner {
    private final ApplicationContext context;

    public BeanPrinter(ApplicationContext context) {
        this.context = context;
    }

    @Override
    public void run(String... args) {
        Arrays.stream(context.getBeanDefinitionNames())
            .sorted()
            .forEach(System.out::println);
    }
}

// 1. Record startup steps — pass a BufferingApplicationStartup:
public static void main(String[] args) {
    SpringApplication app = new SpringApplication(MyApplication.class);
    app.setApplicationStartup(new BufferingApplicationStartup(2048));
    app.run(args);
}
// Then expose the endpoint and call: GET /actuator/startup
// management.endpoints.web.exposure.include=startup

// 2. Lazy initialization — beans are created when first needed:
// spring.main.lazy-initialization=true
// Trade-off: faster startup, slower first request, wiring errors found later.
// Opt a single bean out of it:
@Component
@Lazy(false)
public class CacheWarmer { }

// 3. Cut work done at startup:
//    - Remove unused starters (each one adds auto-configurations to evaluate)
//    - Move slow initialization out of @PostConstruct into async or ApplicationReadyEvent
//    - Exclude auto-configurations you never use (see previous section)

// 4. Read the "Started MyApplication in X seconds" log line as a baseline
//    and compare after every change.