Spring 核心：IoC 与 AOP 源码级解析

Sun, 19 Jul 2026 00:00:00 +0000

前言

Spring 是 Java 后端开发的基石。面试必问的两个核心概念：IoC（控制反转） 和 AOP（面向切面编程）。

学会 Spring 的源码级理解，是面试和实际工作的分水岭。

一、IoC（控制反转）与 DI（依赖注入）

1.1 是什么

不用 IoC 的做法：

public class UserService {
    private UserDao userDao = new UserDao(); // 自己 new，硬编码
}

用了 Spring 的做法：

@Service
public class UserService {
    @Autowired
    private UserDao userDao; // 由 Spring 注入，对象什么时候创建、什么时候销毁不归我管
}

控制反转：对象创建和管理的控制权从程序员转交给 Spring 容器。 依赖注入：容器帮我们创建对象并注入到需要的地方（字段/构造器/Setter）。

1.2 Spring IoC 容器

容器管理所有 Bean 的生命周期：

启动 → 扫描 → 解析配置(注解/XML) → 定义BeanDefinition
    → 实例化Bean → 填充属性(依赖注入) → BeanPostProcessor前置处理
    → 初始化(InitializingBean/@PostConstruct) → BeanPostProcessor后置处理
    → 就绪(可使用) → 销毁(DisposableBean/@PreDestroy)

1.3 BeanFactory vs ApplicationContext

// BeanFactory — 最底层容器（延迟加载）
BeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml"));
UserService userService = factory.getBean(UserService.class);

// ApplicationContext — 更常用（预加载+额外功能）
ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = ctx.getBean(UserService.class);

	BeanFactory	ApplicationContext
Bean 加载	延迟（getBean时创建）	默认预加载（scope=singleton）
事件机制	❌	✅ 事件发布+监听
国际化	❌	✅ MessageSource
AOP 支持	需手动集成	✅ 自动支持
注解支持	❌	✅ @ComponentScan 等

1.4 Bean 的作用域

@Component
@Scope("singleton")     // 默认：一个容器只有一个实例
public class UserService { }

@Scope("prototype")     // 每次 getBean 都是一个新的
@Scope("request")       // 每个 HTTP 请求一个（Web 应用）
@Scope("session")       // 每个 Session 一个（Web 应用）

注意：prototype 作用域的 Bean 在注入到 singleton Bean 时，每次获取的都是同一个。解决方式：

// 方法一：方法注入（@Lookup）
@Component
@Scope("singleton")
public class SingleBean {
    @Lookup
    public PrototypeBean getPrototypeBean() { return null; }  // Spring会代理重写
}

// 方法二：ObjectFactory
@Autowired
private ObjectFactory<PrototypeBean> prototypeBeanFactory;

1.5 循环依赖（重点）

@Service
public class AService {
    @Autowired
    private BService bService;
}

@Service
public class BService {
    @Autowired
    private AService aService;
}

如果没三级缓存，这种就报错了。Spring 怎么解决的？

三级缓存（DefaultSingletonBeanRegistry）：

public class DefaultSingletonBeanRegistry {
    // 一级：完整创建好的单例（成品）
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    
    // 二级：提前暴露的、未完成初始化的 Bean（半成品）
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
    
    // 三级：ObjectFactory，生产二级缓存中的对象
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
}

解决流程（简化）：

1. 创建 A → 实例化 A（调构造器，得到一个"半成品"A）
2. 将 A 放入三级缓存（singletonFactories），存的是 lambda：提前暴露 A 的引用
3. 填充 A 的属性：发现需要 B
4. 去容器找 B → 发现 B 还没创建 → 创建 B
5. 实例化 B（半成品）
6. 填充 B 的属性：发现需要 A
7. 从三级缓存拿到 A（通过工厂生成）→ 放入二级缓存 → B 拿到了 A 的引用（虽然 A 还没初始化完）
8. B 创建完成 → 放入一级缓存
9. 回到 A → 继续初始化 → 把完整 A 放入一级缓存

关键条件：

只解决 singleton + 字段/Setter 注入 的循环依赖
构造器注入 的循环依赖无法解决（实例化时就卡住了）

二、AOP（面向切面编程）

2.1 核心概念

┌─ Aspect（切面）─────────────────────────────────┐
│  ┌─ Pointcut（切点）：WHERE — 哪些方法需要增强    │
│  │   execution(* com.example.service.*.*(..))    │
│  ├─ Advice（通知）：WHAT — 执行什么增强逻辑       │
│  │   @Before / @AfterReturning / @Around 等      │
│  ├─ JoinPoint（连接点）：WHEN — 方法执行时的某个时机 │
│  └─ Weaving（织入）：将切面应用到目标对象的过程    │
└─────────────────────────────────────────────────┘

2.2 使用示例

@Aspect
@Component
public class LogAspect {
    
    @Around("execution(* com.example.service.*.*(..))")
    public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
        // 前置
        long start = System.currentTimeMillis();
        log.info("调用: {}", pjp.getSignature());
        
        Object result = pjp.proceed(); // 执行目标方法
        
        // 后置
        long cost = System.currentTimeMillis() - start;
        log.info("耗时: {}ms", cost);
        return result;
    }
}

2.3 AOP 源码级理解 — 代理机制

AOP 底层是代理模式。Spring 会根据目标类是否实现接口，选择不同的代理方式：

目标类实现接口 → JDK 动态代理（反射+InvocationHandler）
目标类没有接口 → CGLIB 代理（字节码增强，生成子类）

JDK 动态代理原理：

// 简化版源码逻辑
public class JdkDynamicAopProxy implements InvocationHandler {
    private Object target; // 目标对象
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 1. 执行 @Before 通知
        for (MethodInterceptor interceptor : advisors) {
            interceptor.invoke(/* ... */);
        }
        
        // 2. 执行目标方法
        Object result = method.invoke(target, args);
        
        // 3. 执行 @AfterReturning 通知
        return result;
    }
}

CGLIB 原理：

目标类 → CGLIB Enhancer → 生成目标类的子类
                           → 子类重写父类方法
                           → 重写的方法中加入拦截器链

注意：CGLIB 通过继承实现，不能代理 final 类和方法。

2.4 Spring AOP 限制

Spring AOP 是基于代理的 AOP，==> 只能拦截 public 方法。同一个类内部调用被拦截方法也不会生效：

@Service
public class UserService {
    public void methodA() {
        this.methodB(); // 这个调用不会走 AOP 拦截！
        // 因为 this 是原始对象，不是代理对象
    }
    
    @Transactional
    public void methodB() { }
}

解法：

// 方法一：注入自己（代理对象）
@Autowired
private UserService userService;

// 方法二：AopContext.currentProxy()
((UserService) AopContext.currentProxy()).methodB();
// 需要 @EnableAspectJAutoProxy(exposeProxy = true)

// 方法三：拆到不同 Service 中

AspectJ（编译期织入）没有这个限制，因为它直接修改了字节码。

三、事务管理

3.1 @Transactional 原理

@Transactional 本质是 AOP 的应用：

@Around("@annotation(transactional)")
public Object handleTransaction(ProceedingJoinPoint pjp) throws Throwable {
    // 1. 获取或创建事务
    TransactionStatus status = transactionManager.getTransaction(definition);
    try {
        Object result = pjp.proceed();  // 执行目标方法
        transactionManager.commit(status);  // 2. 提交
        return result;
    } catch (Exception e) {
        transactionManager.rollback(status);  // 3. 回滚
        throw e;
    }
}

3.2 事务传播行为

@Transactional(propagation = Propagation.REQUIRED)  // 默认：有就用，没有就新建
@Transactional(propagation = Propagation.REQUIRES_NEW) // 每次新建事务
@Transactional(propagation = Propagation.NESTED)    // 内嵌事务（Savepoint）
@Transactional(propagation = Propagation.MANDATORY) // 必须有事务，没有就抛异常

经典场景：

// REQUIRED — 日志和业务在同个事务，日志回滚业务也回滚
// REQUIRES_NEW — 日志单独事务，不管业务是否回滚，日志都记录

3.3 事务失效的常见原因

1. @Transactional 加到 private 方法上（代理只能拦截 public）
2. 方法内部调用（this.xxx()，同上）
3. 异常被 catch 了没抛出去
4. 抛的异常不是 RuntimeException（默认只回滚 RuntimeException 和 Error）
   → @Transactional(rollbackFor = Exception.class)
5. 数据源没配置事务管理器

面试重点速记

题目	要点
IoC 是什么？	对象创建控制权交给容器，DI 是 IoC 的实现方式
Bean 生命周期？	实例化→填充属性→BeanPostProcessor→初始化→就绪→销毁
三级缓存解决什么？	singleton + field/setter 注入的循环依赖
AOP 底层原理？	JDK 动态代理（有接口） / CGLIB（无接口）
AOP 哪些方法不拦截？	private、内部 this 调用、final 方法
事务失效原因？	private、内部调用、catch 未抛、异常类型不对

依赖注入 on 奇伏禾