@SpringBootConfiguration is a specialization of @Configuration. It marks a class as the primary configuration class of a Spring Boot application, so it can declare @Bean methods just like a regular @Configuration class.

Definition of SpringBootConfiguration

 package org.springframework.boot;
 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Configuration
 @Indexed
 public @interface SpringBootConfiguration {
     @AliasFor(annotation = Configuration.class)
     boolean proxyBeanMethods() default true; 1
 }

@SpringBootConfiguration is itself annotated with @Configuration, so it is nothing but a configuration meta-annotation: it behaves exactly like @Configuration and simply gives Spring Boot a dedicated marker for the application's primary configuration class.

• @Configuration - Marks the class as a source of bean definitions (@Bean methods). Because it is a meta-annotation here, any class annotated with @SpringBootConfiguration is processed as a configuration class. Its proxyBeanMethods attribute is exposed through @AliasFor so it can be set directly on @SpringBootConfiguration.
• @Indexed - A Spring marker that tells the annotation processor (spring-context-indexer) to add the annotated class to a build-time META-INF/spring.components index. At startup, component scanning can read this index instead of scanning the classpath, which speeds up startup in large applications. The index is only an optimization, and the indexer has been deprecated in recent Spring versions.
• @Documented - A standard Java meta-annotation. It makes @SpringBootConfiguration show up in the generated Javadoc of any class annotated with it. It has no effect at runtime.

How @SpringBootConfiguration relates to @SpringBootApplication

@SpringBootApplication is a convenience annotation composed of three annotations:

• @SpringBootConfiguration - marks the class as the Boot configuration
• @EnableAutoConfiguration - turns on auto-configuration
• @ComponentScan - scans the package and sub-packages for components

So the following two classes are equivalent:

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

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

Why use it without @SpringBootApplication?

1. Configuration without auto-configuration or component scanning. Use it when you want a Boot-recognized configuration class but want to control everything explicitly, for example with @Import or selected @Bean methods.
2. Test configuration. Test annotations such as @SpringBootTest, @WebMvcTest and @DataJpaTest look for a class annotated with @SpringBootConfiguration. They search upward from the test class package. A plain @Configuration class is not picked up by this search.
3. Tutorials and focused examples. You can keep a tiny application context with only the beans you need, without the scanning and auto-configuration that @SpringBootApplication brings in.

Example

Build configuration

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>


 <groupId>com.logicbig.example</groupId>
 <artifactId>spring-boot-configuration-annotation</artifactId>
 <version>1.0-SNAPSHOT</version>

 <parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>4.1.2</version>
 </parent>

 <properties>
  <java.version>1.8</java.version>
 </properties>
 <dependencies>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter</artifactId>
  </dependency>
 </dependencies>

</project>

plugins {
    java
    id("org.springframework.boot") version "4.1.2"
    id("io.spring.dependency-management") version "1.1.7"
}

println(">>> EXECUTING SCRIPT: build.gradle.kts (Kotlin DSL)")

group = "com.logicbig.example"
version = "1.0-SNAPSHOT"

java {
    sourceCompatibility = JavaVersion.VERSION_25
}

repositories {
    mavenCentral()
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter")
}

plugins {
    id 'java'
    id 'org.springframework.boot' version '4.1.2'
    id 'io.spring.dependency-management' version '1.1.7'
}

println ">>> EXECUTING SCRIPT: build.gradle (Groovy DSL)"

group = 'com.logicbig.example'
version = '1.0-SNAPSHOT'

java {
    sourceCompatibility = JavaVersion.VERSION_25
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter'
}

MyBean

package com.logicbig.example;

public class MyBean {
    public void doSomething() {
        System.out.println("my bean doSomething method");
    }
}

Main class

package com.logicbig.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;

@SpringBootConfiguration
public class MainExample {

    @Bean
    public MyBean myBean() {
        return new MyBean();
    }

    public static void main(String[] args) {
        SpringApplication.run(MainExample.class, args)
                         .getBean(MyBean.class)
                         .doSomething();
    }
}

Output

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.4.2.RELEASE)

2026-10-31 21:08:37.225  INFO 616 --- [           main] com.logicbig.example.MainExample         : Starting MainExample on JoePC with PID 616 (D:\LogicBig\example-projects\spring-boot\spring-boot-configuration-annotation\target\classes started by joe2 in D:\LogicBig\example-projects\spring-boot\spring-boot-configuration-annotation)
2026-10-31 21:08:37.228  INFO 616 --- [           main] com.logicbig.example.MainExample         : No active profile set, falling back to default profiles: default
2026-10-31 21:08:37.473  INFO 616 --- [           main] com.logicbig.example.MainExample         : Started MainExample in 0.544 seconds (JVM running for 3.333)
my bean doSomething method

In above example, we ran the main class directly from IntelliJ IDEA. Alternatively, you can execute it from the command line using your build tool:

• Maven: mvn spring-boot:run
• Gradle: gradle bootRun