深入Spring源码：IoC、AOP、事务管理与SpringMVC的核心实现 Spring框架以其强大的功能和灵活的设计在Java生态系统中占据重要地位。本文将深入Spring的源码,详细分析IoC容器、AOP、事务管理和SpringMVC的核心实现原理,为高级Java开发者提供深度技术洞察。
1. IoC容器：控制反转的核心实现 Spring的IoC容器是整个框架的基础,其核心实现主要在org.springframework.beans和org.springframework.context包中。
1.1 BeanFactory接口 BeanFactory是Spring IoC容器的根接口,定义了访问Spring容器的基本方法:
javapublic interface BeanFactory {
Object getBean(String name) throws BeansException;
// ... 其他方法
}1.2 ApplicationContext接口 ApplicationContext是BeanFactory的子接口,提供了更多的企业级功能:
javapublic interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
// ... 继承自父接口的方法
}1.3 容器启动流程 以AnnotationConfigApplicationContext为例,其启动流程如下:
javapublic class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
public AnnotationConfigApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
public AnnotationConfigApplicationContext(Class... componentClasses) {
this();
register(componentClasses);
refresh();
}
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 1. 准备刷新上下文环境
prepareRefresh();
// 2. 初始化BeanFactory,并进行XML文件读取
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 3. 对BeanFactory进行各种功能填充
prepareBeanFactory(beanFactory);
try {
// 4. 子类覆盖方法做额外的处理
postProcessBeanFactory(beanFactory);
// 5. 激活各种BeanFactory处理器
invokeBeanFactoryPostProcessors(beanFactory);
// 6. 注册拦截Bean创建的Bean处理器
registerBeanPostProcessors(beanFactory);
// 7. 初始化消息源
initMessageSource();
// 8. 初始化应用事件广播器
initApplicationEventMulticaster();
// 9. 子类重写方法,在容器刷新中可以自定义逻辑
onRefresh();
// 10. 注册监听器
registerListeners();
// 11. 初始化所有剩下的单例Bean
finishBeanFactoryInitialization(beanFactory);
// 12. 完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent通知
finishRefresh();
}
catch (BeansException ex) {
// 销毁已经创建的单例Bean
destroyBeans();
// 重置'active'标志
cancelRefresh(ex);
throw ex;
}
}
}
}1.4 容器启动主要扩展点 BeanFactoryPostProcessor: 允许在容器实例化任何bean之前读取bean的定义,并可以修改它。
javapublic interface BeanFactoryPostProcessor {
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}BeanPostProcessor: 允许在Bean初始化前后进行额外的处理。
javapublic interface BeanPostProcessor {
@Nullable
default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Nullable
default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
}ApplicationListener: 用于监听应用程序中的事件。
javapublic interface ApplicationListener
void onApplicationEvent(E event);
}1.5 Spring内置注解的解析 Spring通过AnnotatedBeanDefinitionReader来解析注解。以@Component注解为例:
ClassPathBeanDefinitionScanner扫描类路径。ClassPathScanningCandidateComponentProvider识别带有@Component及其派生注解的类。AnnotationConfigUtils注册相关的后处理器。ConfigurationClassPostProcessor处理@Configuration类。AutowiredAnnotationBeanPostProcessor处理@Autowired和@Value注解。关键代码片段:
javapublic class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
protected Set
Set
for (String basePackage : basePackages) {
Set
for (BeanDefinition candidate : candidates) {
// ... 解析作用域等信息
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
beanDefinitions.add(definitionHolder);
registerBeanDefinition(definitionHolder, this.registry);
}
}
return beanDefinitions;
}
}AutowiredAnnotationBeanPostProcessor处理@Autowired注解:
javapublic class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}
}1.6 Bean的生命周期 Bean的生命周期在AbstractAutowireCapableBeanFactory的doCreateBean方法中得到了充分体现:
javaprotected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
// 1. 实例化Bean
BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
final Object bean = instanceWrapper.getWrappedInstance();
// 2. 属性填充
populateBean(beanName, mbd, instanceWrapper);
// 3. 初始化Bean
Object exposedObject = initializeBean(beanName, exposedObject, mbd);
// ... 其他逻辑
return exposedObject;
}在这个过程中,Spring会调用各种生命周期回调方法,如BeanNameAware、BeanFactoryAware、InitializingBean等接口方法,以及@PostConstruct和@PreDestroy注解标记的方法。
2. AOP：面向切面编程的实现 Spring AOP的核心实现位于org.springframework.aop包中。AOP代理的创建是在Bean实例化之后，初始化之前完成的。
2.1 AOP代理创建流程 Spring AOP代理的创建主要发生在AbstractAutoProxyCreator类中，这个类实现了BeanPostProcessor接口：
javapublic abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
// ... 前置检查
// 获取适用于bean的通知器
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 创建代理
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
protected Object createProxy(Class beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors, TargetSource targetSource) {
ProxyFactory proxyFactory = new ProxyFactory();
// ... 设置ProxyFactory的属性
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);
return proxyFactory.getProxy(getProxyClassLoader());
}
}2.2 AOP代理创建时机 AOP代理的创建时机是在Bean的生命周期中的初始化阶段。具体来说：
Bean实例化属性注入初始化前（@PostConstruct）AOP代理创建（在AbstractAutoProxyCreator.postProcessAfterInitialization中）初始化后2.3 Spring内部代理示例：事务管理 Spring的声明式事务管理就是通过AOP实现的。以@Transactional注解为例：
TransactionInterceptor实现了MethodInterceptor接口，用于在方法调用前后处理事务。
BeanFactoryTransactionAttributeSourceAdvisor将TransactionInterceptor和TransactionAttributeSource组合在一起，形成一个Advisor。
ProxyTransactionManagementConfiguration配置类创建了这些组件：
java@Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
advisor.setTransactionAttributeSource(transactionAttributeSource());
advisor.setAdvice(transactionInterceptor());
advisor.setOrder(this.enableTx.
return advisor;
}
@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public TransactionAttributeSource transactionAttributeSource() {
return new AnnotationTransactionAttributeSource();
}
@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public TransactionInterceptor transactionInterceptor() {
TransactionInterceptor interceptor = new TransactionInterceptor();
interceptor.setTransactionAttributeSource(transactionAttributeSource());
if (this.txManager != null) {
interceptor.setTransactionManager(this.txManager);
}
return interceptor;
}
}当Spring容器处理带有@Transactional注解的Bean时：
AbstractAutoProxyCreator检测到BeanFactoryTransactionAttributeSourceAdvisor适用于该Bean。创建一个代理，将TransactionInterceptor应用到相应的方法上。当调用带有@Transactional注解的方法时，TransactionInterceptor会在方法执行前开启事务，方法执行后提交或回滚事务。2.4 ProxyFactory ProxyFactory是创建AOP代理的核心类：
javapublic class ProxyFactory extends ProxyCreatorSupport {
public ProxyFactory() {
}
public ProxyFactory(Object target) {
setTarget(target);
setInterfaces(ClassUtils.getAllInterfaces(target));
}
public Object getProxy() {
return createAopProxy().getProxy();
}
// ... 其他方法
}2.5 AopProxy Spring使用AopProxy接口的实现来创建代理：
javapublic interface AopProxy {
Object getProxy();
Object getProxy(@Nullable ClassLoader classLoader);
}根据目标对象是否实现接口，Spring会选择使用JDK动态代理或CGLIB：
JdkDynamicAopProxy javafinal class JdkDynamicAopProxy implements AopProxy, InvocationHandler {
// ... 其他代码
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
MethodInvocation invocation;
Object oldProxy = null;
boolean setProxyContext = false;
TargetSource targetSource = this.advised.targetSource;
Object target = null;
try {
// ... 省略了一些检查和特殊处理
Object retVal;
if (this.advised.exposeProxy) {
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
target = targetSource.getTarget();
Class targetClass = (target != null ? target.getClass() : null);
List
if (chain.isEmpty()) {
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
else {
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
retVal = invocation.proceed();
}
Class returnType = method.getReturnType();
if (retVal != null && retVal == target &&
returnType != Object.class && returnType.isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
retVal = proxy;
}
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
targetSource.releaseTarget(target);
}
if (setProxyContext) {
AopContext.setCurrentProxy(oldProxy);
}
}
}
}CglibAopProxy javaclass CglibAopProxy implements AopProxy, Serializable {
// ... 其他代码
@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
// ... 省略了一些准备工作
Enhancer enhancer = createEnhancer();
if (classLoader != null) {
enhancer.setClassLoader(classLoader);
if (classLoader instanceof SmartClassLoader &&
((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
enhancer.setUseCache(false);
}
}
enhancer.setSuperclass(proxySuperClass);
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
Callback[] callbacks = getCallbacks(rootClass);
Class[] types = new Class[callbacks.length];
for (int x = 0; x < types.length; x++) {
types[x] = callbacks[x].getClass();
}
enhancer.setCallbackFilter(new ProxyCallbackFilter(
this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
enhancer.setCallbackTypes(types);
return createProxyClassAndInstance(enhancer, callbacks);
}
// ... 其他方法
}3. 事务管理：声明式事务的实现 Spring的事务管理主要通过AOP实现,核心类位于org.springframework.transaction包中。
3.1 TransactionInterceptor TransactionInterceptor是实现声明式事务的关键:
javapublic class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
Class targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
}
}3.2 TransactionAspectSupport TransactionAspectSupport包含了事务管理的核心逻辑:
javapublic abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {
protected Object invokeWithinTransaction(Method method, @Nullable Class targetClass,
final InvocationCallback invocation) throws Throwable {
TransactionAttributeSource tas = getTransactionAttributeSource();
final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
final PlatformTransactionManager tm = determineTransactionManager(txAttr);
// ... 事务执行逻辑
}
// ... 其他方法
}4. SpringMVC：Web应用的核心实现 SpringMVC的核心实现位于org.springframework.web.servlet包中。
4.1 DispatcherServlet DispatcherServlet是SpringMVC的核心,负责请求的分发:
javapublic class DispatcherServlet extends FrameworkServlet {
@Override
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
// ... 请求预处理
try {
doDispatch(request, response);
}
finally {
// ... 请求后处理
}
}
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
// 1. 确定处理器
mappedHandler = getHandler(processedRequest);
// 2. 确定处理器适配器
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
// 3. 执行处理器
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
// 4. 视图解析
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}
// ... 其他方法
}4.2 HandlerMapping HandlerMapping负责根据请求找到对应的处理器:
javapublic interface HandlerMapping {
@Nullable
HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;
}4.3 ViewResolver ViewResolver负责解析视图名称:
javapublic interface ViewResolver {
@Nullable
View resolveViewName(String viewName, Locale locale) throws Exception;
}总结 通过深入分析Spring的源码,我们可以看到框架的核心组件是如何协同工作的。IoC容器通过BeanFactory和ApplicationContext管理对象生命周期,AOP利用动态代理实现横切关注点的模块化,声明式事务借助AOP实现透明的事务管理,而SpringMVC则通过DispatcherServlet统一处理Web请求。