@SpringBootApplication
SpringBootApplication是springboot启动类的必备注解,对于启动springboot至关重要,以下是我个人对该注解的详细阅读解释。
下面我们进入该注解内部从上到下逐层见解。

1.@Target({ElementType.TYPE})
这个注解是 Java 元注解,作用是限制自定义注解的适用范围,ElementType.TYPE表示该注解只能使用在类、接口(包括注解)还有枚举类。
2.@Retention(RetentionPolicy.RUNTIME)
这个注解也是 Java 中的元注解,用于标注该自定义注解在程序周期的哪个阶段可见。
3. @Documented
该注解也是Java 中的元注解,它的作用是标记该注解应该被 Javadoc 工具记录,如果一个自定义注解添加了 @Documented,那么当其他类使用了这个注解时,该注解的信息会出现在生成的 Javadoc 文档(Javadoc 是 Java 编程语言官方提供的文档生成工具)中。
4. @Inherited
该注解也是Java 中的元注解,标记该注解具有继承性(对添加该注解的类),也就是说当一个父类使用了该自定义注解,继承这个父类的子类也会拥有该注解。
接下来就是核心的内容了。
5.@SpringBootConfiguration
本质:
@Configuration (使用 @Configuration定义的类可以作为bean定义的来源,可以在类中定义bean组件)的特化版本,那么特化,特化,特化在哪儿呢?
在 Spring Boot 应用中,通常只有一个类被标注为 @SpringBootConfiguration,该类被视为应用程序的主配置类
接下来我们再进入里面看看

对吧,里面是有@Configuration的!
5.1@Configuration
接下来我们进入Configuration内详解

5.1.1 proxyBeanMethods()
控制配置类是否被 CGLIB 代理,以确保 @Bean 方法之间的调用能遵循单例模式。
true :Spring 会使用 CGLIB 生成配置类的子类(代理)。当你在一个 @Bean 方法中调用另一个 @Bean 方法(例如 methodA() 调用 methodB())时,实际调用的是代理对象的方法。这会拦截调用并直接从 Spring 容器中返回 methodB 对应的单例 Bean,而不是执行 methodB 的代码创建新实例。这保证了 Bean 的单例性。
false (Lite @Configuration 模式):Spring 不会生成代理类,配置类按普通类处理。如果在 @Bean 方法内部直接调用另一个 @Bean 方法,会像普通 Java 方法调用一样执行代码,导致创建新的对象实例,从而破坏单例模式。
5.1.2 enforceUniqueMethods()
这个是用来控制在处理配置类时,是否强制要求 @Bean 方法不能重复定义(即同一个配置类中不能有两个同名的 @Bean 方法,或者重写的父类方法签名冲突)。
true :Spring 会严格检查。如果在同一个配置类中发现两个方法生成了相同名称的 Bean,或者在继承体系中出现了无法解析的方法冲突,Spring 会在启动时抛出异常,阻止应用启动。这有助于尽早发现配置错误。
false :Spring 可能会放宽检查,允许某些特定的方法覆盖或重复定义场景,但这可能导致难以排查的 Bean 覆盖问题。
5.1.3@Component
接下来还有一个@Component没有解释,那就让我们再次深入到里面

这里唯一需要解释的就是value(),它就是作为bean的名称,如果没有就默认首字母小写。
5.2@Indexed
它的作用是标记一个实体类(Entity)需要被索引。
告诉 Hibernate Search (Hibernate Search(一个基于 Lucene 或 Elasticsearch 的全文本搜索库))监听该实体类的生命周期事件(如持久化、更新、删除),并自动同步更新对应的搜索引擎索引。
5.3@AliasFor(annotation = Configuration.class) boolean proxyBeanMethods() default true;
@AliasFor(annotation = Configuration.class) 表示当前注解(如 @SpringBootConfiguration)中的 proxyBeanMethods 属性,实际上是 @Configuration 注解中 proxyBeanMethods 属性的别名。即当 @SpringBootConfiguration(proxyBeanMethods = false))时,Spring 容器会将其视为直接配置了 @Configuration(proxyBeanMethods = false)。这允许 Spring Boot 在封装原生 Spring 注解时,暴露相同的配置项供用户调整,而无需用户同时写两个注解。
6. @EnableAutoConfiguration
接下来就是要进入到@EnableAutoConfiguration里喽。
先来介绍一下这个注解再深入,@EnableAutoConfiguration是 Spring Boot 的核心注解之一,其主要作用是启用 Spring Boot 的自动配置机制。
它具体有两个作用:
自动装配 Bean:它会根据项目中引入的依赖(classpath 下的 jar 包)、已定义的 Bean 以及各种配置属性,自动推断并创建应用程序所需的 Bean 实例。
简化配置:开发者无需手动编写大量的 XML 或 Java Config 配置类。例如,如果 classpath 下有 HSQLDB 和 spring-jdbc,它会自动配置一个内存数据库和数据源;如果有 spring-webmvc 和 Tomcat,它会自动配置嵌入式 Tomcat 和 DispatcherServlet。
如果我们想要了解它具体是怎么实现的,还是要进入这个注解里面逐个解析。

6.1@AutoConfigurationPackage
6.1.1@Import({AutoConfigurationPackages.Registrar.class})
这个注解的作用就是标注了该注解的配置类所在的包名(Package Name)注册到 Spring 容器中。
用途:这个包名会被其他 Spring Boot 组件(如 Spring Data JPA、Spring Session 等)作为默认扫描路径。
这个注解的工作原理就是
Registrar 模式
当 Spring 容器处理到 @Import 注解时,会调用 Registrar 的 registerBeanDefinitions 方法。
获取当前导入该注解的配置类所在的包名,并将该包名列表存储在一个名为 AutoConfigurationPackages 的单例 Bean 中(Key 通常为 org.springframework.boot.autoconfigure.AutoConfigurationPackages)。
其他组件可以通过注入 AutoConfigurationPackages 或使用 @EnableJpaRepositories 等注解隐式读取这个列表,从而确定扫描范围
6.1.2 Class<?>[] basePackageClasses() default {}
作用:通过类数组指定包名。Spring 会提取这些类所在的包作为扫描路径。
6.1.3 String[] basePackages() default {}
作用:通过字符串数组直接指定包名。
上面两个只是记录一个包名供 JPA 等框架做默认参考。即使你没配这个,只要 @ComponentScan 扫到了,你的 @Component 依然能正常工作。为什么我们要提 @ComponentScan
解读完了@AutoConfigurationPackage我们再回到@EnableAutoConfiguration
6.2Class<?>[] exclude() default {};和String[] excludeName() default {};
还记得我们上面提到的@AliasFor(annotation = Configuration.class) 吗?
@AliasFor 可以把本注解上的注解里面的属性映射到本注解
Class<?>[] exclude() default {}
作用:通过类引用直接指定要排除的配置类或组件类。
String[] excludeName() default {}
作用:通过类的全限定名字符串指定要排除的类。
对于他们的作用如下
扫描与读取阶段
Spring Boot 启动时,AutoConfigurationImportSelector 会读取 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports (或旧版的 spring.factories) 文件。
此时,所有的自动配置类(包括你写在 exclude 或 excludeName 中的那些类)都会被读取到内存中。
过滤阶段
在决定要导入哪些配置类之前,Spring 会检查 exclude 和 excludeName 列表。
如果某个自动配置类的全限定名出现在这两个列表中,它会被直接从候选列表中移除。
结果
不会实例化:被排除的类不会经过 @Conditional 条件判断,也不会被实例化,其内部的 @Bean 方法更不会执行。
类文件依然存在:.class 文件依然在 classpath 中,只是 Spring 容器选择忽略它,不把它当作配置类处理。
它们在@SpringBootApplication是这一被映射得
它的用法就是
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class MyApplication { }
这样写的意思就是排除DataSourceAutoConfiguration.class。到此,我们解释完了@EnableAutoConfiguration,我们再次回到SpringBootApplication。
7.@ComponentScan
(
excludeFilters = {
@Filter(
type = FilterType.CUSTOM, // 指定过滤器类型为“自定义”
classes = {TypeExcludeFilter.class} // 使用 TypeExcludeFilter 实现逻辑
),
@Filter(
type = FilterType.CUSTOM, // 指定过滤器类型为“自定义”
classes = {AutoConfigurationExcludeFilter.class} // 使用 AutoConfigurationExcludeFilter 实现逻辑
)
}
)
7.1. TypeExcludeFilter.class
作用:这是一个基于类型匹配的自定义过滤器。
机制:它允许开发者通过实现 TypeExcludeFilter 接口或配置 spring.factories (或新的 imports 文件),动态地指定哪些类应该被排除。
典型场景:
排除测试配置类(如带有 @TestConfiguration 的类),防止它们在主应用启动时被加载。
根据特定条件动态排除某些组件。
如果不加上这个,可能会误将测试专用的配置类加载到生产环境中。
7.2. AutoConfigurationExcludeFilter.class
作用:这是一个专门用于排除自动配置类的过滤器。
机制:它会检查扫描到的类是否是 Spring Boot 的自动配置类(即带有 @Configuration 且通常在 META-INF/spring.factories 中注册的类)。
典型场景:
防止 @ComponentScan 意外扫描并重复注册那些本应由 @EnableAutoConfiguration 按需加载的自动配置类。
确保自动配置类只通过标准的自动配置机制生效,而不是作为普通组件被扫描。
如果不加这个可能会重复加载自动配置类,导致 Bean 定义冲突或初始化顺序混乱。
接下来我们进入@ComponentScan。
7.3@Repeatable(ComponentScans.class)
它是 Java 中的一个元注解,用于声明一个注解可以被重复使用,也就是说在同一个类中可以使用多次@ComponentScan。

7.4@AliasFor("basePackages") String[] value() default {};
@AliasFor("value")String[] basePackages() default {};
看到这个大家可能会有点疑惑?那就是为什么这两个属性相互起别名,别名不是引用该类用的注解中的属性吗?那我们必须来讲一下@AliasFor
7.4.1@AliasFor的两种用法对比
1.同一个注解内部,让多个属性(本注解的属性)互为别名,形成双向映射关系。
例如
public @interface ComponentScan {
// value 是 basePackages 的别名
@AliasFor("basePackages")
String[] value() default {};
// basePackages 是 value 的别名
@AliasFor("value")
String[] basePackages() default {};
}
也就是说让他们两个等价,在外面就可以这么用。
@ComponentScan( basePackages="com.example.package")
// 等价于
@ComponentScan(value = "com.example.package")
2.引用该注解上面的注解里面的属性。
要求:
1.当前注解必须包含目标注解作为元注解(使用 @TargetAnno(…))
2.必须明确指定 annotation 参数
3.只能映射到元注解的属性,不能随便引用其他注解
例如 :@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
7.5Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
这个属性的作用就是当你使用 @Component、@Service、@Repository 等注解时,Spring 需要给这些类生成一个 Bean ID(名称),这个属性就是用来指定命名策略的。
可以这样用。
@Configuration
@ComponentScan(
basePackages = "com.example",
nameGenerator = MyCustomBeanNameGenerator.class // 使用自定义生成器
)
public class AppConfig {
}
MyCustomB….的实现
public class MyCustomBeanNameGenerator implements BeanNameGenerator {
@Override
public String generateName(BeanDefinition definition, BeanDefinitionRegistry registry) {
String className = definition.getBeanClassName();
// 自定义规则:根据包名添加前缀
if (className.contains(".service.")) {
return "svc_" + className.substring(className.lastIndexOf(".") + 1);
} else if (className.contains(".controller.")) {
return "ctrl_" + className.substring(className.lastIndexOf(".") + 1);
}
// 默认:首字母小写
return Introspector.decapitalize(className.substring(className.lastIndexOf(".") + 1));
}
}
在springboot中默认会使用
1.AnnotationBeanNameGenerator()
优先从 @Component("customName") 中获取
如果没有,就用类名首字母小写:UserService -> userService
有时候也会使用
2.FullyQualifiedAnnotationBeanNameGenerator
使用完整的类名作为 Bean 名
com.example.service.UserService -> 直接作为 Bean 名
7.6Class<? extends ScopeMetadataResolver> scopeMetadataResolver() default AnnotationScopeMetadataResolver.class;
这个属性是决定 Spring 如何解析 Bean 的作用域(Scope)。
Bean 的作用域就是:这个 Bean 是单例的(singleton)?还是每次请求都创建新的(prototype)?还是跟 HTTP 请求绑定(request)?等等。
它和@Scope的作用是一样的,不过它可以自定义策略例如:
@Configuration
@ComponentScan(
basePackages = "com.example",
scopeResolver = SmartScopeResolver.class // 使用自定义解析器
)
public class AppConfig {
}
SmartScopeResolver.class的实现如下
// 1. 自定义一个智能解析器
public class SmartScopeResolver implements ScopeMetadataResolver {
@Override
public ScopeMetadata resolve(BeanDefinition definition) {
ScopeMetadata metadata = new ScopeMetadata();
String className = definition.getBeanClassName();
try {
Class<?> clazz = Class.forName(className);
// 规则 1:有 @Scope 注解的优先遵守
if (clazz.isAnnotationPresent(Scope.class)) {
Scope scope = clazz.getAnnotation(Scope.class);
metadata.setScopeName(scope.value());
return metadata;
}
// 规则 2:根据类名后缀判断
if (className.endsWith("Controller")) {
metadata.setScopeName(BeanDefinition.SCOPE_PROTOTYPE);
} else if (className.endsWith("Mapper") ||
className.endsWith("Repository")) {
metadata.setScopeName(BeanDefinition.SCOPE_SINGLETON);
} else if (className.contains("Session")) {
metadata.setScopeName("session");
} else {
// 默认 singleton
metadata.setScopeName(BeanDefinition.SCOPE_SINGLETON);
}
} catch (ClassNotFoundException e) {
metadata.setScopeName(BeanDefinition.SCOPE_SINGLETON);
}
return metadata;
}
}
// 2. 配置使用
@Configuration
@ComponentScan(
basePackages = "com.sky",
scopeResolver = SmartScopeResolver.class
)
public class ApplicationConfig {
}
// 3. 效果
@Controller // 自动 prototype(因为以 Controller 结尾)
public class UserController {}
@Service // 自动 singleton(默认)
public class UserService {}
@Scope("request") // 显式指定的优先
@Controller
public class OrderController {}
接着我们继续解析ComponentScand的其他属性
7.7ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;
它的作用是决定是否需要为 Bean 创建代理对象,以及创建什么类型的代理。
这在不同作用域的 Bean 相互注入时特别重要!
为什么需要代理?看经典场景!
问题场景:Singleton 注入 Prototype
@Service // singleton(默认单例)
public class OrderService {
@Autowired
private ShoppingCart cart; // ❌ 有问题!
}
@Scope("prototype") // prototype(多例)
@Service
public class ShoppingCart {
private List<String> items = new ArrayList<>();
}
// 第一次请求
OrderService orderService1 = context.getBean(OrderService.class);
orderService1.getCart().addItem("商品 A");
// 第二次请求(期望新的购物车,但实际是同一个!)
OrderService orderService2 = context.getBean(OrderService.class);
orderService2.getCart().addItem("商品 B");
// 结果:两个订单共享同一个购物车!
// 因为 singleton 的 OrderService 只在第一次创建时注入了 cart(OrderService是单例,就会造成伪单例)
// 之后每次都复用同一个 cart(虽然是 prototype)
@Service
public class OrderService {
@Autowired
@Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
private ShoppingCart cart; // ✅ 现在没问题了!
}
// Spring 实际注入的是 ShoppingCart 的代理对象
// 每次调用 cart.addItem() 时:
// 1. 先通过代理对象获取真实的 ShoppingCart 实例
// 2. 从容器中请求一个新的 prototype Bean
// 3. 调用真实实例的方法
orderService1.getCart().addItem("商品 A"); // 获取新的 cart1
orderService2.getCart().addItem("商品 B"); // 获取新的 cart2
// ✅ 完美!每个请求都是独立的购物车
7.8String resourcePattern() default "**/*.class";
这个属性的作用是指定扫描哪些类文件,用于控制 Spring 在组件扫描时的资源过滤规则。
默认值 "**/*.class" 的含义
这是一个 Ant 风格的通配符模式:
** – 表示任意深度的目录(包括 0 层或多层)
* – 表示任意字符(文件名)
.class – 只匹配编译后的字节码文件
实际效果: 扫描所有 .class 文件
7.9boolean useDefaultFilters() default true;
控制是否使用 Spring 默认的组件扫描过滤规则。
默认值 true 的含义
当 useDefaultFilters = true 时,Spring 会自动扫描并注册带有以下注解的类:
@Component // 通用组件
@Service // 服务层
@Repository // 数据访问层
@Controller // Web 控制器(需要 spring-webmvc)
@RestController // RESTful 控制器(需要 spring-webmvc)
@ControllerAdvice // 控制器通知(需要 spring-webmvc)
@Configuration // 配置类
当为true时spring会自动实现
// 扫描 com.sky 包下的所有类
for (Class<?> clazz : allClassesInPackage("com.sky")) {
// 自动检查是否有特定注解
if (clazz.isAnnotationPresent(Component.class) ||
clazz.isAnnotationPresent(Service.class) ||
clazz.isAnnotationPresent(Repository.class) ||
clazz.isAnnotationPresent(Controller.class) ||
clazz.isAnnotationPresent(RestController.class) ||
clazz.isAnnotationPresent(Configuration.class)) {
// 注册为 Bean
registry.registerBeanDefinition(clazz);
}
}
当为false时候
@ComponentScan(
basePackages = "com.sky",
useDefaultFilters = false, // ❌ 不使用默认过滤器
includeFilters = {
// 必须手动指定要扫描的类型
@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Service.class),
@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Repository.class)
}
)
public class AppConfig {
}
此时spirng只会扫描你指定的类。
// 只检查是否有 @Service 或 @Repository 注解
for (Class<?> clazz : allClassesInPackage("com.sky")) {
if (clazz.isAnnotationPresent(Service.class) ||
clazz.isAnnotationPresent(Repository.class)) {
// ✅ 只有这些会被注册
registry.registerBeanDefinition(clazz);
}
}
// @Controller 不会被扫描!
// @Component 也不会被扫描!
7.10Filter[] includeFilters() default {};Filter[] excludeFilters() default {};
includeFilters – 白名单:指定要扫描哪些组件
excludeFilters – 黑名单:指定不扫描哪些组件
当7.9中属性为false时候就是关闭全量扫描,此时就需要这两个属性来配置该扫描的和不该扫描的。
具体用法如下
@ComponentScan(
basePackages = "com.sky",
useDefaultFilters = false, // 关闭默认的全量扫描
includeFilters = {
// 只扫描这些类型
@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Service.class),
@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Repository.class)
}
)
public class AppConfig {
}
7.11boolean lazyInit() default false;
这个属性的作用是控制 Bean 是否延迟初始化。
lazyInit = false(默认)→ 立即初始化(容器启动时就创建所有 Bean)
lazyInit = true → 延迟初始化(第一次使用时才创建 Bean)
7.12:public @interface Filter {}

7.12.1FilterType type() default FilterType.ANNOTATION;
作用:指定过滤器的类型
五种可选值:
public enum FilterType {
ANNOTATION, // 按注解过滤(默认)
ASSIGNABLE_TYPE, // 按具体类过滤
ASPECTJ, // 按 AspectJ 表达式过滤
REGEX, // 按正则表达式过滤
CUSTOM // 按自定义规则过滤
}
7.12.2@AliasFor("classes")
Class<?>[] value() default {};
@AliasFor("value")
Class<?>[] classes() default {};
value 和 classes 是互为别名的关系,它们指向同一个值,可以互换使用,都是用来指定过滤条件的类或注解。
7.12.3String[] pattern() default {};
指定过滤模式(用于 ASPECTJ 和 REGEX 类型)
具体用法:
1:ASPECTJ 表达式
@Filter(
type = FilterType.ASPECTJ,
pattern = "com.sky..service.*Service*" // 扫描 service 包下所有以 Service 结尾的类
)
2:正则表达
@Filter(
type = FilterType.REGEX,
pattern = ".*Service.*" // 匹配类名包含 Service 的类
)
注意:pattern 必须配合 type 使用!
// 错误:没有指定 type
@Filter(pattern = ".*Service.*") // 不知道用哪种方式解析 pattern
// 正确
@Filter(type = FilterType.REGEX, pattern = ".*Service.*")
具体在外面的用法
@ComponentScan(
basePackages = "com.sky",
useDefaultFilters = false,
includeFilters = {
// 只扫描带有 @Service 注解的类
@Filter(type = FilterType.ANNOTATION, classes = Service.class),
// 或者使用 value(省略 type,因为默认就是 ANNOTATION)
@Filter(classes = Repository.class)
}
)
至此,我们已经把@SpringBootApplication解析完毕。
这是本人第一次发表文章,如有不足请见解。




