欢迎光临
我们一直在努力

@SpringBootApplication阅读笔记

@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解析完毕。

这是本人第一次发表文章,如有不足请见解。

赞(0)
未经允许不得转载:171主机测评 » @SpringBootApplication阅读笔记
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址