核心类 & 方法
BeanDefinition
Bean 的定义信息, 封装 bean 的基本信息, 从中可以获取类名, 是否是单例, 是否被注入到其他 bean 中, 是否懒加载, bean 依赖的 bean 的名称等.
Aware
继承 Aware 的 bean 可以感知到他在容器中的一些属性, 如获取 bean 在容器中的 ID, 甚至获取到容器等.
BeanPostProcessor
Bean 的后置处理器, 可在 bean 的创建, 初始化等阶段的前后对 bean 进行增强处理等.
BeanFactory
以 Factory 结尾, 表示它是一个工厂类(接口), 用于管理 Bean 的一个工厂. 在 Spring 中, BeanFactory 是 IoC 容器的核心接口, 它的职责包括: 实例化, 定位, 配置应用程序中的对象及建立这些对象间的依赖.
是访问容器的顶层接口, 他的实现类中会有一个 MAP, 用于存储 bean 的 BeanDefinition.
- (与 FactoryBean 区别: 实现 FactoryBean 接口也是在容器中注入 bean 的方式之一, 但它不是一个普通的 bean, 而是生成指定 bean 的一个工厂)
- AbstractAutowireCapableBeanFactory:: populateBean(..)
DefaultListableBeanFactory 继承了 AbstractAutowireCapableBeanFactory
此方法用于给 bean 注入依赖的其他 bean
BeanWrapper
将交于容器管理的 bean 装饰, 屏蔽多样性, 统一的 set,get 方法, 方便统一操作
核心流程源码
AnnotationAwareAspectJAutoProxyCreator 创建过程
AOP 核心类: AnnotationAwareAspectJAutoProxyCreator, 本质是一种 BeanPostProcessor
容器启动时:
==》 org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.Class<?>...)
- register(annotatedClasses);// 加载, 注册配置类; 配置类也是一个被容器管理的 bean
- refresh();// 刷新容器, 注册, 创建相关 bean
==》 org.springframework.context.support.AbstractApplicationContext#refresh
- // Register bean processors that intercept bean creation.
- registerBeanPostProcessors(beanFactory);// 注册容器需要的核心 BeanPostProcessor
- // Instantiate all remaining (non-lazy-init) singletons.
- finishBeanFactoryInitialization(beanFactory);// 创建并初始化其他非懒加载的 bean, 主要是业务类 bean
==》 org.springframework.context.support.AbstractApplicationContext#registerBeanPostProcessors
==》 org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, org.springframework.context.support.AbstractApplicationContext)
- // Separate between BeanPostProcessors that implement PriorityOrdered, Ordered, and the REST.
- // 根据继承的 order 等级, 顺序创建 BeanPostProcessor
- //AnnotationAwareAspectJAutoProxyCreator 实现了 Order
- // 创建
- BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
- // 添加到容器 - FactoryBean 中
- org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, java.util.List<org.springframework.beans.factory.config.BeanPostProcessor>)
==》 org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String, java.lang.Class<T>)
==》 org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean//BeanPostProcessor 和业务 Bean 都用此创建 bean
- // 创建 bean
- return createBean(beanName, mbd, args);
==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])
- // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
- // 有一次通过代理直接返回对象的机会, 但一般都不会走到此方法中
- Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
- // 创建过程
- Object beanInstance = doCreateBean(beanName, mbdToUse, args);
==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
- // 创建 Bean, 通过 Wrapper 装饰
- if (instanceWrapper == null) {
- instanceWrapper = createBeanInstance(beanName, mbd, args);
- }
- // Initialize the bean instance.
- // 填充 bean 后初始化 bean
- Object exposedObject = bean;
- try {
- populateBean(beanName, mbd, instanceWrapper);
- if (exposedObject != null) {
- exposedObject = initializeBean(beanName, exposedObject, mbd);
- }
- }
==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)
- // 初始化 bean
- // 检查实现了哪些 aware, 并注入相应的值
- invokeAwareMethods(beanName, bean);
- //BeanPostProcessor 初始化前置处理
- wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
- // 调用 bean 的初始方法
- invokeInitMethods(beanName, wrappedBean, mbd);
- //BeanPostProcessor 初始化后置处理
- wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
==》 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization
// 此类做 Bean 初始化的后置处理, 若 bean 有 advice 则创建 proxy bean, 此 bean 无.
业务 Bean(proxy)创建过程
容器启动时:
==》 org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.Class<?>...)
- register(annotatedClasses);// 加载, 注册配置类; 配置类也是一个被容器管理的 bean
- refresh();// 刷新容器, 注册, 创建相关 bean
==》 org.springframework.context.support.AbstractApplicationContext#refresh
- // Register bean processors that intercept bean creation.
- registerBeanPostProcessors(beanFactory);// 注册容器需要的核心 BeanPostProcessor
- // Instantiate all remaining (non-lazy-init) singletons.
- finishBeanFactoryInitialization(beanFactory);// 创建并初始化其他非懒加载的 bean, 主要是业务类 bean
==》 org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization
- // Instantiate all remaining (non-lazy-init) singletons.
- beanFactory.preInstantiateSingletons();
==》 org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons
//getBean(beanName);
==》 org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)
==》 org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
return createBean(beanName, mbd, args);
==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])
- Object beanInstance = doCreateBean(beanName, mbdToUse, args);
- // 创建 Bean, 通过 Wrapper 装饰
- if (instanceWrapper == null) {
- instanceWrapper = createBeanInstance(beanName, mbd, args);
- }
- // Initialize the bean instance.
- // 填充 bean 后初始化 bean
- Object exposedObject = bean;
- try {
- populateBean(beanName, mbd, instanceWrapper);
- if (exposedObject != null) {
- exposedObject = initializeBean(beanName, exposedObject, mbd);
- }
- }
==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)
- // 初始化 bean
- // 检查实现了哪些 aware, 并注入相应的值
- invokeAwareMethods(beanName, bean);
- //BeanPostProcessor 初始化前置处理
- wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
- // 调用 bean 的初始方法
- invokeInitMethods(beanName, wrappedBean, mbd);
- //BeanPostProcessor 初始化后置处理
- wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization
- // 此类做 Bean 初始化的后置处理, 若 bean 有 advice 则创建 proxy bean
- // 遍历 bean 的后置处理器, 并做后置处理
- // 当后置处理器时 AnnotationAwareAspectJAutoProxyCreator 时进入方法, 判断是否需要做代理
- for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
- result = beanProcessor.postProcessAfterInitialization(result, beanName);
- if (result == null) {
- return result;
- }
- }
==》 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization
==》 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary
- // Create proxy if we have advice.
- 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;
- }
==》 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#createProxy
- //bean 需要被 aop 做代理进行增强时进入此方法
- // 取得 bean 对应的 advisors,advisors 会被封装成链式 Interceptors(责任链模式)供后期增强使用
- Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
- // 使用代理工厂创建代理
- return proxyFactory.getProxy(getProxyClassLoader());
==》 org.springframework.aop.framework.ProxyFactory#getProxy(java.lang.ClassLoader)
return createAopProxy().getProxy(classLoader);
==》 org.springframework.aop.framework.ProxyCreatorSupport#createAopProxy
return getAopProxyFactory().createAopProxy(this);
==》 org.springframework.aop.framework.DefaultAopProxyFactory#createAopProxy
- // 如果继承自接口使用 JDK 动态代理
- if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
- return new JdkDynamicAopProxy(config);
- }
- // 否则使用 CGLib 动态代理
- return new ObjenesisCglibAopProxy(config);
Bean 的创建梳理
包括工具 Bean, 业务 Bean
1,bean 在缓存中 (Map) 是否存在, 存在则直接返回, 不存在进入创建流程
2, 创建 BeanPostProcessor 后置处理器
是否实现 Aware, 实现则注入对应容器信息
3, 创建自身 bean
创建 àpopulateBeanàInvoke InitMethod(若有 advice 此时创建 proxy)
AOP advice 过程
在业务方法中加断点, 调试进入
==》 org.springframework.aop.framework.JdkDynamicAopProxy#invoke
- // 当被代理类实现了接口时使用 jdk 动态代理
- // Get the interception chain for this method.
- // 获取通知封装成的链
- List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
- // We need to create a method invocation...
- invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
- // Proceed to the joinpoint through the interceptor chain.
- // 容器在封装 advisors 成 Interceptors 时会进行排序, 此顺序和实际执行顺序相反, 因为 Interceptors 会以责任链的形式调用, 因此实际执行时顺序是正常的
- retVal = invocation.proceed();
AOP 方法增强梳理
1, 创建 AOP 核心类: AnnotationAwareAspectJAutoProxyCreator
2, 在注入时, CreateBean 时, 检查是否有 Advice, 如果有则创建 bean 的代理.
注意: 代理类对象 (proxy) 会加入容器, 但 Context::BeanFactory::BeanDefinition 中的定义信息仍是被代理类的, 所以取到的 name 也是被代理类的.
代理类会在被代理类调用 populateBean,InitMethod 后创建,
3, 被增强的方法在调用时, 会调用代理类的方法, 方法中获取相应通知做增强处理. 这些通知会被封装成 MethodInterceptor, 对切点进行拦截增强处理.
来源: https://www.cnblogs.com/little-sheep/p/10103797.html