【Spring Boot注解】

Spring Boot 注解是如何工作的？（理解 AOP 的前置知识）

很多初学者在学 Spring Boot 和 AOP 时，都会有类似的疑惑：

@ServicepublicclassUserService{}

❓ 我没有 new，它怎么就能用？
❓ 加个@Aspect，怎么方法就被“代理”了？
❓ Spring 到底在启动时做了什么？

这篇文章，我们不讲源码细节，而是用通俗 + 可运行的代码，把 Spring 注解背后的机制讲清楚。

一、Spring 到底在干什么？一句话版本

Spring 的核心工作只有一件事：
扫描类 → 创建对象 → 管理对象 → 在合适的时机“加工”对象

AOP、事务、依赖注入，本质都是这条流水线上的不同“加工步骤”。

二、为什么 @Service 的类不用 new？

1️⃣ 一个最简单的 Spring Boot 程序

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);}}

当你运行这行代码时，Spring 会：

1. 启动容器（ApplicationContext）
2. 扫描 classpath
3. 找出“需要交给 Spring 管理的类”

三、@Service / @Component 是干嘛的？

@ServicepublicclassUserService{publicvoidregister(){System.out.println("注册用户");}}

这行@Service的真实含义是：

“请 Spring 在启动时，帮我创建这个类的对象，并放进容器里。”

本质效果等价于（伪代码）：

UserServiceuserService=newUserService();springContainer.put("userService",userService);

👉你没 new，但 Spring new 了

四、@Autowired 是怎么注入的？

@RestControllerpublicclassUserController{@AutowiredprivateUserServiceuserService;}

Spring 在启动时会：

1. 创建UserController
2. 发现字段上有@Autowired
3. 去容器里找UserService
4. 通过反射赋值

userController.userService=springContainer.get(UserService.class);

👉这一步仍然是反射 + 容器

五、Spring 启动时的“对象生命周期”（非常关键）

简化版流程如下：

扫描类 ↓ 解析注解（@Component、@Service、@Aspect…） ↓ 创建 Bean 对象 ↓ Bean 后处理（BeanPostProcessor） ↓ 放入容器

⚠️AOP 就是在“Bean 后处理”阶段介入的

六、AOP 的注解是从什么时候开始生效的？

我们先看一个切面：

@Aspect@ComponentpublicclassLoggingAspect{@Before("execution(* com.example.UserService.*(..))")publicvoidbefore(){System.out.println("记录日志");}}

很多人会误以为：

❌ Spring 在调用方法时“突然拦截了”

这是错的。

七、真相：代理对象在「启动阶段」就创建好了

当 Spring 启动时：

1. 发现UserService是一个 Bean
2. 发现有@Aspect
3. 发现切点匹配UserService
4. Spring 决定：这个 Bean 需要被代理

于是它不会直接放入原始对象，而是：

UserService 原始对象 ↓ Spring AOP ↓ 代理对象（JDK / CGLIB） ↓ 放入容器

👉容器里从一开始拿到的，就是代理对象

八、这也是为什么 AOP 不会对 this.xxx() 生效

@ServicepublicclassUserService{publicvoida(){this.b();// ❌ 不走代理}publicvoidb(){System.out.println("b");}}

原因很简单：

• this指的是当前对象内部
• 不是 Spring 容器里的代理对象

👉AOP 是通过“代理对象”生效的，不是魔法

九、@Aspect 本质上是什么？

@Aspect@ComponentpublicclassLoggingAspect{}

拆开看：

• @Component：让 Spring 管理这个类

• @Aspect：告诉 Spring ——

  “这个 Bean 不普通，它是用来生成代理规则的”

Spring 会把它交给AOP 解析器处理。

十、@Before / @AfterReturning 是怎么用到的？

@Before("execution(* com.example.UserService.*(..))")publicvoidbefore(){}

Spring 会在启动时：

1. 解析表达式
2. 建立「方法 → 增强逻辑」的映射关系
3. 生成代理类时，把这些逻辑织入进去

👉不是运行时临时判断，而是提前准备好的

十一、总结一条完整因果链（非常重要）

@SpringBootApplication ↓ Spring 启动 ↓ 扫描 @Component / @Service / @Aspect ↓ 创建 Bean ↓ AOP 判断是否需要代理 ↓ 生成代理对象 ↓ 放入容器 ↓ 你 @Autowired 拿到的是代理对象

十二、所以 AOP “自动代理”并不神秘

你现在应该能理解这句话了：

AOP 之所以能“自动生效”，
是因为 Spring 在启动阶段就已经替你生成了代理对象。

十三、给读者的最终认知模型（建议放在文章结尾）

• Spring 注解 ≠ 魔法
• 注解 = “规则声明”
• Spring = 规则执行者
• AOP = Spring 在创建 Bean 时顺手做的“代理加工”

结语

当你理解了：

• Spring 是“容器”
• 注解是“标记”
• AOP 是“Bean 创建阶段的加工逻辑”

你再回头看@Aspect、@Before，只会觉得：

哦，原来如此。