Spring 框架核心机制深度解析【AI模型互搏生成】

北漂老男孩2025-05-21 17:45

Spring 框架核心机制深度解析（玩转开源代码）

一、Bean 生命周期全流程剖析

1.1 核心生命周期阶段

以下是 Spring Bean 生命周期核心阶段的配图，结合实际流程图示清晰展现每一步执行顺序及扩展点挂载位置。

🧬Spring Bean 生命周期流程图

graph TD A[加载 BeanDefinition] --> B{postProcessBeforeInstantiation?} B -->|是| C[返回代理对象 -> 初始化完成] B -->|否| D[实例化 Bean（Constructor）] D --> E{postProcessAfterInstantiation?} E -->|false| Z[终止后续流程] E -->|true| F[属性注入 populateBean] F --> G[postProcessProperties（依赖注入）] G --> H[执行 @Autowired/@Resource 等注解注入] H --> I[调用 BeanNameAware 等 Aware 接口] I --> J[postProcessBeforeInitialization] J --> K[执行初始化方法（@PostConstruct / InitializingBean）] K --> L[postProcessAfterInitialization] L --> M[注册销毁回调（DisposableBean / @PreDestroy）] M --> N[完成创建 -> 放入单例池]

📌 说明：

  • postProcessBeforeInstantiation：拦截实例化前，可直接返回代理跳过后续流程。
  • postProcessAfterInstantiation：控制是否进行属性注入。
  • postProcessProperties：注解驱动的依赖注入处理器（如 @Autowired）。
  • postProcessBefore/AfterInitialization：通常用于 AOP 代理封装。
  • InitializingBean/@PostConstruct：执行开发者定义的初始化逻辑。
  • 最后阶段将 Bean 放入单例池，并注册销毁逻辑。
java 复制代码 
// AbstractAutowireCapableBeanFactory.java
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 1. 实例化阶段
    Object bean = instanceWrapper.getWrappedInstance();
    
    // 2. 属性填充阶段
    populateBean(beanName, mbd, instanceWrapper);
    
    // 3. 初始化阶段
    exposedObject = initializeBean(beanName, exposedObject, mbd);
    
    return exposedObject;
}

1.2 InstantiationAwareBeanPostProcessor 关键拦截点

1.2.1 实例化前拦截 (postProcessBeforeInstantiation)
java 复制代码 
// AbstractAutowireCapableBeanFactory.java
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                Object result = ((InstantiationAwareBeanPostProcessor) bp)
                    .postProcessBeforeInstantiation(beanClass, beanName);
                if (result != null) {
                    // 直接返回代理对象，跳过后续标准流程
                    return applyBeanPostProcessorsAfterInitialization(result, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = Boolean.TRUE;
    }
    return null;
}

关键特性：

  • 返回非空对象会完全替代原始 Bean
  • 常用于提前生成代理（如 LoadTimeWeaving）
1.2.2 实例化后处理 (postProcessAfterInstantiation)
java 复制代码 
// AbstractAutowireCapableBeanFactory.java
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    boolean continueWithPropertyPopulation = true;
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            if (!((InstantiationAwareBeanPostProcessor) bp)
                .postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                continueWithPropertyPopulation = false;
                break;
            }
        }
    }
    if (!continueWithPropertyPopulation) return;
    
    // 执行属性注入...
}

作用：控制是否进行属性注入

1.2.3 属性处理 (postProcessProperties)
java 复制代码 
// CommonAnnotationBeanPostProcessor.java
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    // 处理 @Resource 注解注入
    InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
    try {
        metadata.inject(bean, beanName, pvs);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(...);
    }
    return pvs;
}

1.3 初始化阶段扩展点

回调接口 执行时机 典型应用场景
BeanPostProcessor 初始化前后 代理增强（AOP）
InitializingBean 属性设置后 自定义初始化逻辑
@PostConstruct 初始化方法阶段 生命周期回调
SmartInitializingSingleton 所有单例初始化完成后 应用启动后操作

二、AOP 实现机制深度解析

2.1 AOP 代理创建流程

二、AOP代理创建流程

2.1 代理创建决策流程图
graph TD A[创建ProxyFactory实例] --> B[设置目标对象和切面配置] B --> C[调用getProxy()] C --> D{是否设置proxyTargetClass或目标类无接口?} D -->|是| E{目标类是否是接口或已是代理类?} E -->|是| F[JDK动态代理] E -->|否| G[CGLIB动态代理] D -->|否| F F --> H[生成代理对象] G --> H

代理选择策略：

  • JDK代理：要求目标类至少实现一个接口
  • CGLIB代理：通过生成子类实现代理，需注意final方法限制
  • proxyTargetClass=true 强制使用CGLIB

📌 说明：

  • ProxyFactory：核心代理工厂，封装代理创建逻辑。
  • proxyTargetClass=true 或目标类无接口：优先选择 CGLIB。
  • JDK 动态代理：代理接口，轻量高效。
  • CGLIB 代理：子类代理，适用于无接口的类。
  • AopProxy 实例：真正生成代理对象的实现类。
2.1.1 代理工厂核心配置
java 复制代码 
// ProxyFactory.java
public class ProxyFactory extends ProxyCreatorSupport {
    public Object getProxy(ClassLoader classLoader) {
        if (this.proxyInterfaces.length == 0 && !isProxyTargetClass()) {
            // 自动检测接口
            Class<?> targetClass = getTargetClass();
            if (targetClass != null) {
                setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, classLoader));
            }
        }
        
        // 创建 AopProxy 实例
        AopProxy aopProxy = createAopProxy();
        return aopProxy.getProxy(classLoader);
    }
}
2.1.2 代理类型选择策略
java 复制代码 
// DefaultAopProxyFactory.java
public AopProxy createAopProxy(AdvisedSupport config) {
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
        Class<?> targetClass = config.getTargetClass();
        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
            return new JdkDynamicAopProxy(config);
        }
        return new ObjenesisCglibAopProxy(config);
    }
    else {
        return new JdkDynamicAopProxy(config);
    }
}

2.2 拦截器链执行机制（拦截器调用时序图）

Client Proxy Invocation Target Interceptor1 Interceptor2 调用方法 创建ReflectiveMethodInvocation invoke() proceed() invoke() proceed() loop 拦截器链 invokeJoinpoint() 返回结果 返回结果 返回结果 Client Proxy Invocation Target Interceptor1 Interceptor2

执行特点：

  • 责任链模式实现
  • 递归调用机制（proceed()方法推动链式执行）
  • 执行顺序：前置通知 -> 目标方法 -> 后置通知（实际为嵌套执行）

📌 说明：

  • 拦截器链（Interceptor Chain） ：本质是一个环状递归结构，每个拦截器执行完后调用 proceed() 进入下一个。
  • ReflectiveMethodInvocation 是关键入口，按顺序调用所有增强方法。
  • 当最后一个拦截器执行完毕后，进入 invokeJoinpoint()，即目标方法本体。
  • 执行顺序符合"洋葱模型"：进入是从外到内，返回是从内到外。
2.2.1 拦截器链构建
java 复制代码 
// DefaultAdvisorChainFactory.java
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
        Advised config, Method method, Class<?> targetClass) {
    
    List<Object> interceptorList = new ArrayList<>(config.getAdvisors().length);
    for (Advisor advisor : config.getAdvisors()) {
        if (advisor instanceof PointcutAdvisor) {
            PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
            if (pointcutAdvisor.getPointcut().getClassFilter().matches(targetClass)) {
                MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                if (MethodMatchers.matches(mm, method, targetClass, hasIntroductions)) {
                    interceptorList.addAll(Arrays.asList(interceptors));
                }
            }
        }
    }
    return interceptorList;
}
2.2.2 方法调用堆栈
java 复制代码 
// ReflectiveMethodInvocation.java
public Object proceed() throws Throwable {
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return invokeJoinpoint(); // 执行原始方法
    }
    
    Object interceptorOrInterceptionAdvice =
        this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    
    if (interceptorOrInterceptionAdvice instanceof MethodInterceptor) {
        MethodInterceptor mi = (MethodInterceptor) interceptorOrInterceptionAdvice;
        return mi.invoke(this);
    }
    else {
        // 动态匹配处理
        return ((InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice)
            .methodMatcher.matches(...) ? mi.invoke(this) : proceed();
    }
}

三、事务管理实现机制

3.1 事务传播机制实现

java 复制代码 
// AbstractPlatformTransactionManager.java
private TransactionStatus handleExistingTransaction(
        TransactionDefinition definition, Object transaction, boolean debugEnabled) {
    
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
        throw new IllegalTransactionStateException(...);
    }

    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
        Object suspendedResources = suspend(transaction);
        return newTransactionStatus(
            definition, null, false, newSynchronization, debugEnabled, suspendedResources);
    }
    
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
        SuspendedResourcesHolder suspendedResources = suspend(transaction);
        return startTransaction(definition, transaction, debugEnabled, suspendedResources);
    }
    
    // 其他传播行为处理...
}

3.2 事务同步管理

java 复制代码 
// TransactionSynchronizationManager.java
public abstract class TransactionSynchronizationManager {
    private static final ThreadLocal<Map<Object, Object>> resources =
        new NamedThreadLocal<>("Transactional resources");
    
    private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
        new NamedThreadLocal<>("Transaction synchronizations");
    
    public static void bindResource(Object key, Object value) {
        Map<Object, Object> map = resources.get();
        if (map == null) {
            map = new HashMap<>();
            resources.set(map);
        }
        Object oldValue = map.put(key, value);
        if (oldValue != null) {
            throw new IllegalStateException(...);
        }
    }
}

3.3 事务异常处理机制

java 复制代码 
// TransactionAspectSupport.java
protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
    if (txInfo != null && txInfo.getTransactionStatus() != null) {
        if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
            try {
                txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
            }
            catch (TransactionSystemException ex2) {
                // 处理回滚失败
            }
        }
        else {
            try {
                txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
            }
            catch (TransactionSystemException ex2) {
                // 处理提交异常
            }
        }
    }
}

事务回滚规则矩阵：

异常类型 默认回滚? 可配置覆盖
RuntimeException 是 可通过 @Transactional 修改
Checked Exception 否 可配置 rollbackFor
Error 是 不可修改

四、核心设计模式应用

4.1 模板方法模式

  • 应用场景：AbstractAutowireCapableBeanFactory 的 createBean 方法

  • 实现方式：

    java 复制代码 
    protected Object createBean(...) {
    // 前置处理
    Object bean = resolveBeforeInstantiation(...);
    if (bean != null) return bean;
    
    // 标准创建流程
    return doCreateBean(...);
}

protected abstract Object doCreateBean(...);

4.2 责任链模式

  • 应用场景：BeanPostProcessor 调用链、AOP 拦截器链

  • 典型实现：

    java 复制代码 
    // AbstractAdvisorAutoProxyCreator.java
public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (bean instanceof AopInfrastructureBean) {
        return bean;
    }
    return wrapIfNecessary(bean, beanName);
}

4.3 代理模式

  • JDK 动态代理示例：

    java 复制代码 
    public class JdkDynamicProxy implements InvocationHandler {
    private final Object target;
    
    public Object invoke(Object proxy, Method method, Object[] args) {
        // 前置处理
        Object result = method.invoke(target, args);
        // 后置处理
        return result;
    }
}

五、性能优化建议

  1. Bean 生命周期优化：

    • 避免在 BeanPostProcessor 中进行耗时操作
    • 合理使用 lazy-init 延迟初始化

  2. AOP 优化策略：

    • 精确配置切点表达式减少匹配开销
    • 优先使用 JDK 动态代理（生成速度更快）

  3. 事务管理优化：

    • 合理设置事务超时时间
    • 避免在事务方法中进行远程调用

是 否 Bean定义加载 实例化前处理 是否返回代理? 直接使用代理对象 反射实例化 属性注入 初始化前处理 执行初始化方法 初始化后处理 注册销毁方法

本解析文档结合 Spring Framework 5.3.x 版本源码实现，深入剖析了 Spring 框架的核心工作机制。建议结合官方文档和实际调试进行验证，以加深对底层原理的理解。

相关推荐
程序员cxuan2 分钟前
本地跑一个 Qwen 3.8，你将拥有一个 Opus 4.6
人工智能·后端·程序员
土司大王23 分钟前
LeetCode hot100——移动零
java·算法·leetcode
thefool11226638 分钟前
相同的树`
java
凤山老林1 小时前
高保真集成测试：Spring Boot 结合 Testcontainers 的工程落地
spring boot·后端·集成测试
步行cgn1 小时前
MyBatis <trim> 标签完全解析：动态 SQL 的终极武器
后端
XPoet1 小时前
AI 编程工程化：实战——从 0 到 1 搭建 AI 编程工作流
前端·后端·ai编程
掘金者阿豪1 小时前
向量数据库不是终点，企业AI真正需要的是融合数据库
后端
程序员cxuan1 小时前
OpenAI Linux 版来了！
人工智能·后端·程序员
原野池予1 小时前
深入Java集合框架：HashMap源码解析（JDK 8）
java·开发语言
大黄评测1 小时前
Angular 表单：响应式表单高级用法，Typed Forms 类型化表单实战
后端
热门推荐
01GitHub 镜像站点02国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）03微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新042026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？05Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费06历年考研数学一、数学二、数学三真题试卷及答案PDF07VSCode+CodeX扩展，无法启动08AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路092026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片10如何新建文件夹？ 电脑新建文件夹的4种方法