@EnableAspectJAutoProxy文件：@Import(AspectJAutoProxyRegistrar.class)
所以AspectJAutoProxyRegistrar起关键作用，看一下它的实现：
// 继承了 ImportBeanDefinitionRegistrar 接口，该接口用于生成自定义的 Bean
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar
public void registerBeanDefinitions(
AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry){
...
// 注册这个组件，跟进去看一下
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
...
}
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
}
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
BeanDefinitionRegistry registry, @Nullable Object source) {
// 传入一个 class，用它来创建 Bean，它很重要，下面会详细分析。跟进去
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
public static final String AUTO_PROXY_CREATOR_BEAN_NAME =
"org.springframework.aop.config.internalAutoProxyCreator"; //BeanID
private static BeanDefinition registerOrEscalateApcAsRequired(
Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
...
// 看看有没有现成的，第一次进入肯定返回 false
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {...}
//根据传入的 class 创建 bean 的定义，用于生成 bean
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
...
// 生成 bean， 参数是 BeanID 和 bean 定义
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
return beanDefinition;
}
那么 IOC 容器对处理器的创建过程是怎样的呢
首先看一下AnnotationAwareAspectJAutoProxyCreator类（就是刚刚生成 bean 的类）的继承关系：
我们发现它实现了两个关键的接口：
BeanFactoryAware：获得BeanFactory
InstantiationAwareBeanPostProcessor：实例化的过程，这个很重要，下面会讲到它的作用。
现在进入 IOC 的创建过程，只关注 AnnotationAwareAspectJAutoProxyCreator 对应的 Bean
AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MainConfig.class);
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
this();
register(componentClasses); //注册配置类
refresh(); // 进入这个方法
}
public void refresh() throws BeansException, IllegalStateException {
...
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory); // 先进入这个方法
...
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory); // 注册完处理器后会进入该方法实例化（肯定是单例）
...
}
1.先进入registerBeanPostProcessors：
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);// 进入
}
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 先获取ioc容器已经定义了的需要创建对象的所有 BeanPostProcessor
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
...
// orderedPostProcessorNames 是实现了 Ordered 接口的处理器
for (String ppName : orderedPostProcessorNames) { //上面的继承关系图可知，继承了 Ordered 接口
//获取（如果没有就创建） Bean，跟进去
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
}
...
}
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);// 跟进去
}
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
...
// 看看有没有现成的，第一次肯定没有，接着往下走
Object sharedInstance = getSingleton(beanName);
...
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
// 创建 Bean，进去！
return createBean(beanName, mbd, args);
}
...
}
...
}
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
...
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 这里进去进行前置操作和后置操作，此处返回 null。原因在下面有讲到
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
...
try {
// 创建 Bean，进去
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
...
return beanInstance;
}
...
}
1.1进入 resolveBeforeInstantiation
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
// 在上面的继承关系图中发现已经实现了 InstantiationAwareBeanPostProcessor 接口
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
// 这个方法相当于前置处理
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 后置处理在后面，不是这个
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
1.1.1 applyBeanPostProcessorsBeforeInstantiation
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 肯定实现了 InstantiationAwareBeanPostProcessor 接口
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 这就是前面讲的前置操作
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
...
// 获得定制的目标源，这里没有，返回 null
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
if (StringUtils.hasLength(beanName)) {
this.targetSourcedBeans.add(beanName);
}
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
// 创建代理对象
Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
...
}
1.1.2 applyBeanPostProcessorsAfterInitialization
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 标志为代理
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
1.2 doCreateBean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
...
if (instanceWrapper == null) {
// 创建 Bean 包装器 （反射）
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
...
try {
// 设置参数
populateBean(beanName, mbd, instanceWrapper);
// 初始化，进去看看，有前置操作和后置操作
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
...
// 调用 Aware 方法（实现哪些 Aware 接口）
invokeAwareMethods(beanName, bean);
...
// 前置操作和后置操作的实现需要继承 BeanPostProcessorsr 接口
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 前置操作，这里是怎么进去的怎么出来
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 反射调用初始化方法
// 顺便提一下初始化和销毁的用法：
// @Bean(initMethod="", destroyMethod="")
// 接口：InitializingBean, DisposableBean
// JSR250(jdk--javax):
// @PostConstruct
// @PreDestroy
invokeInitMethods(beanName, wrappedBean, mbd);
}
...
if (mbd == null || !mbd.isSynthetic()) {
// 后置操作，进入
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
// Bean 创建结束，返回
return wrappedBean;
}
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 上面讲的后置处理，进入
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
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) {
...
// 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;
}
...
}
protected Object[] getAdvicesAndAdvisorsForBean(
Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
// 找一些合适的通知，进入
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
// 进入
List<Advisor> candidateAdvisors = findCandidateAdvisors();
// 检查是否可用
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
// 排序，通知方法的执行时机
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
protected List<Advisor> findCandidateAdvisors() {
Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
// 进入
return this.advisorRetrievalHelper.findAdvisorBeans();
}
public List<Advisor> findAdvisorBeans() {
...
// 把切面类中的通知方法加进来
advisors.add(this.beanFactory.getBean(name, Advisor.class));
...
}
- 现在进入 finishBeanFactoryInitialization 看看它是怎么初始化单例 Bean 的
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
...
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();// 关注它就可以
}
public void preInstantiateSingletons() throws BeansException {
...
getBean(beanName);// 它是关键
...
}
public Object getBean(String name) throws BeansException {
// 又回到这里，下面就和刚刚的一样了
return doGetBean(name, null, null, false);
}
小结：
未完待续（内容安排不合理，打算重写）。。。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
