6.Java Spring框架源码分析-AOP-Spring_AOP源码分析总结

源码分析

源码分析

1. @EnableAspectJAutoProxy

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)//导入了AspectJAutoProxyRegistrar组件
public @interface EnableAspectJAutoProxy {

boolean proxyTargetClass() default false;
boolean exposeProxy() default false;

}

2. AspectJAutoProxyRegistrar

//实现了ImportBeanDefinitionRegistrar接口，可以向ioc容器导入bean
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

@Override
public void registerBeanDefinitions(
AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

//向容器中注册AnnotationAwareAspectJAutoProxyCreator bean
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

AnnotationAttributes enableAspectJAutoProxy =
AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}

}

3. AopConfigUtils

3.1. registerAspectJAnnotationAutoProxyCreatorIfNecessary

public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
//导入AnnotationAwareAspectJAutoProxyCreator
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}

3.2. registerOrEscalateApcAsRequired

private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");

//已经存在org.springframework.aop.config.internalAutoProxyCreator的bean
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
int requiredPriority = findPriorityForClass(cls);
if (currentPriority < requiredPriority) {
apcDefinition.setBeanClassName(cls.getName());
}
}
return null;
}

//不存在则创建该AnnotationAwareAspectJAutoProxyCreator bean，放入ioc容器
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.setSource(source);
beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
return beanDefinition;
}

4. AnnotationAwareAspectJAutoProxyCreator

4.1. 类体系

由下图可看出AnnotationAwareAspectJAutoProxyCreator主要实现了
BeanFactoryAware接口。setBeanFactory方法（为bean注入BeanFactory）
以及BeanPostProcessor接口。postProcessBeforeInitialization方法（bean初始化之前做一些事情）和postProcessAfterInitialization方法（bean初始化之后做一些事情））

5. 流程分析

5.1. 调试

为AnnotationAwareAspectJAutoProxyCreator类体系的关键方法加上断点，运行。
1）、传入配置类，创建ioc容器
2）、注册配置类，调用refresh()刷新容器
3）、registerBeanPostProcessors(beanFactory)；注册bean的后置处理器拦截bean的创建
1）、先获取ioc容器中的所有BeanPostProcessor
2）、给容器中加入别的BeanPostProcessor
3）、优先注册实现了PriorityOrdered接口的BeanPostProcessor
4）、然后注册实现了Ordered接口的BeanPostProcessor
5）、接着注册没实现接口的BeanPostProcessor
6）、注册BeanPostProcessor，实际上就是创建BeanPostProcessor保存在容器中
创建internalAutoProxyCreator的BeanPostProcessor[]
1）、创建Bean的实例
2）、populateBean，给bean的各种属性赋值
3）、initializeBean，初始化bean
1）、invokeAwareMethods()，处理Aware接口的方法回调
2）、applyBeanPostProcessorsBeforeInitialization()
3）、invokeInitMethods()，执行自定义的初始化方法
4）、applyBeanPostProcessorsAfterInitialization()
4）、BeanPostProcessor（AnnotationAwareAspecJAutoProxyCreater）
7）、把BeanPostProcessor注册到BeanFactory中
beanFactory.addBeanPostProcessor(processor)
通过以上过程就把AnnotationAwareAspecJAutoProxyCreater注册进容器中=================

5.2. AbstractAutoProxyCreator

5.2.1. postProcessBeforeInstantiation

public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
//获取缓存key
Object cacheKey = getCacheKey(beanClass, beanName);

if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {
//判断是否在已经增强的bean里
if (this.advisedBeans.containsKey(cacheKey)) {
//是的话说明已经增强过，直接返回
return null;
}
//调用AnnotationAwareAspectJAutoProxyCreator的isInfrastructureClass方法以及shouldSkip方法
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}

// Create proxy here if we have a custom TargetSource.
// Suppresses unnecessary default instantiation of the target bean:
// The TargetSource will handle target instances in a custom fashion.
if (beanName != null) {
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
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;
}
}

return null;
}

5.2.2. isInfrastructureClass

protected boolean isInfrastructureClass(Class<?> beanClass) {
//判断是否是Advice、Pointcut、Advisor、AopInfrastructureBean类
boolean retVal = Advice.class.isAAopInfrastructureBeanssignableFrom(beanClass) ||
Pointcut.class.isAssignableFrom(beanClass) ||
Advisor.class.isAssignableFrom(beanClass) ||
AopInfrastructureBean.class.isAssignableFrom(beanClass);
if (retVal && logger.isTraceEnabled()) {
logger.trace("Did not attempt to auto-proxy infrastructure class [" + beanClass.getName() + "]");
}
return retVal;
}

5.2.3. postProcessAfterInitialization

//创建完Calc对象后会调用这个方法
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
//必要时包装Calc
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}

5.2.4. wrapIfNecessary

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}

// Create proxy if we have advice.
//获取Calc所有的增强器
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
//创建代理类增强当前bean
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;
}

5.2.5. createProxy

protected Object createProxy(
Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}

ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);

if (!proxyFactory.isProxyTargetClass()) {
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}

Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);

proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}

//用ProxyFactory代理工厂创建对象
return proxyFactory.getProxy(getProxyClassLoader());
}

5.3. AnnotationAwareAspectJAutoProxyCreator

5.3.1. isInfrastructureClass

protected boolean isInfrastructureClass(Class<?> beanClass) {
//AbstractAutoProxyCreator.isInfrastructureClass || AbstractAspectJAdvisorFactory.isAspect
return (super.isInfrastructureClass(beanClass) || this.aspectJAdvisorFactory.isAspect(beanClass));
}

5.3.2. isAspect

public boolean isAspect(Class<?> clazz) {
//有@Aspect注解并且没有以ajc$开头的属性
return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
}

5.4. AspectJAwareAdvisorAutoProxyCreator

5.4.1. shouldSkip

protected boolean shouldSkip(Class<?> beanClass, String beanName) {
// TODO: Consider optimization by caching the list of the aspect names
//找到所有增强的切面：就是LogAspect中的增强方法
List candidateAdvisors = findCandidateAdvisors();
for (Advisor advisor : candidateAdvisors) {
//只要有一个增强器是AspectJPointcutAdvisor类型的并且增强器修饰的bean就是beanName，那么返回true
if (advisor instanceof AspectJPointcutAdvisor) {
if (((AbstractAspectJAdvice) advisor.getAdvice()).getAspectName().equals(beanName)) {
return true;
}
}
}
return super.shouldSkip(beanClass, beanName);
}

5.5. AbstractAdvisorAutoProxyCreator

5.5.1. getAdvicesAndAdvisorsForBean

protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
List advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}

5.5.2. findEligibleAdvisors

protected List findEligibleAdvisors(Class<?> beanClass, String beanName) {
//获取所有的增强器
List candidateAdvisors = findCandidateAdvisors();
//筛选出能应用到当前bean上的增强器
List eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}

5.5.3. findAdvisorsThatCanApply

protected List findAdvisorsThatCanApply(
List candidateAdvisors, Class<?> beanClass, String beanName) {

ProxyCreationContext.setCurrentProxiedBeanName(beanName);
try {
//调用AopUtils获取能应用的增强器
return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
}
finally {
ProxyCreationContext.setCurrentProxiedBeanName(null);
}
}

5.6. AopUtils

5.6.1. findAdvisorsThatCanApply

public static List findAdvisorsThatCanApply(List candidateAdvisors, Class<?> clazz) {
if (candidateAdvisors.isEmpty()) {
return candidateAdvisors;
}
List eligibleAdvisors = new LinkedList();
//遍历所有增强器，最后调用的都是getClassFilter().matches()方法判断的
for (Advisor candidate : candidateAdvisors) {
if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
eligibleAdvisors.add(candidate);
}
}
boolean hasIntroductions = !eligibleAdvisors.isEmpty();
for (Advisor candidate : candidateAdvisors) {
if (candidate instanceof IntroductionAdvisor) {
// already processed
continue;
}
if (canApply(candidate, clazz, hasIntroductions)) {
eligibleAdvisors.add(candidate);
}
}
return eligibleAdvisors;
}

5.7. ProxyFactory

5.7.1. getProxy

public Object getProxy(ClassLoader classLoader) {
//ProxyCreatorSupport的createAopProxy
return createAopProxy().getProxy(classLoader);
}

5.8. ProxyCreatorSupport

5.8.1. createAopProxy

protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
//调用DefaultAopProxyFactory的createAopProxy方法
return getAopProxyFactory().createAopProxy(this);
}

5.9. DefaultAopProxyFactory

5.9.1. createAopProxy

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
//没有的话使用cglib继承
return new ObjenesisCglibAopProxy(config);
}
else {
//有接口的话使用jdk代理
return new JdkDynamicAopProxy(config);
}
}

6. 目标方法执行

6.1. CglibAopProxy

6.1.1. intercept

//拦截目标方法的执行
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
Class<?> targetClass = null;
Object target = null;
try {
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// May be null. Get as late as possible to minimize the time we
// "own" the target, in case it comes from a pool...
target = getTarget();
if (target != null) {
targetClass = target.getClass();
}
//获取目标方法的拦截器链:AdvisedSupportAdvisedSupport.getInterceptorsAndDynamicInterceptionAdvice()
List

posted @ 2025-07-04 11:24 ThinkerQAQ 阅读(108) 评论(0) 收藏举报

刷新页面返回顶部

ThinkerQAQ