AOP是切面的意思,面向对象的思想,设计出来的结构都是树状的,最大程度的提升代码的复用率、扩展性、易读性。但是这里有个问题,树状结构大家都是知道是一种关系型结构,擅长处理关系结构,扩展等方面适合业务功能核心代码的开发。但是对于一些重复的、每个功能都需要用到的功能比如,日志、监控、权限、统计、事务等横向的功能(所有功能都需要的),使用面向对象的思想处理起来的结果就是导致代码重复率高、不易扩展、阅读体验比较差,每次都要看非业务代码。这种情况就适合用切面来处理。因为这个过程和织布机,横向织入横线的过程一样,所以这个过程被称为织入。
切面的核心点,就是切入点,point,我们需要一个切入点 point cut,围绕这个点进行一些增强处理,可能是前,后,或者环绕式的,这些具体的增强就是advice,而切面 aspect 是包含这两个部分的。但是切面生成之后,如果放到合适的地方,就是需要织入 weaving。
面向对象的设计中,一个类有两部分组成,成员变量,成员方法。成员变量是属性,运行时标识当前对象的状态,成员方法是action,标识这个类可以做哪些事情。所以AOP增强的最小单位就是成员方法,是对方法的增强。但是方法属于类,所以切入点的通过规则表达式(可以理解过正则表达式)来选定类+方法,具体规则看
所以增强的单位肯定也是方法,可以理解为方法增强。最后的织入过程,我们都知道设计模式中的代理模式,这里就是基于代理模式的思想,通过spring的IOC机制生成代理对象,spring通过IOC获取的都是代理对象,所以很方便的就完成了织入过程。
基于以上的概念,spring aop是分开设计了4种接口
切入点,主要是用来解析表达式,并且进行类、方法的 match操作,PointCut
增强器,主要用来对方法进行增强:Advice
切面,切入点和增强器的组合具体是流程控制: PointCutAdvisor
织入,获取目标对象是否需要进行代理,如果需要则获取需要进行代理的切面(可能有多个),生成代理对象放入到容器中替换目标对象,AutoProxyCreator
public class InstalmentApiServer {
public static void main(String[] args) {
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
log.info("starting main");
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[]{
"classpath:context/applicationContext.xml",
}, false);
IHello testA = (IHello) context.getBean("testA");
testA.sayHello();
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
default-lazy-init="false">
<aop:aspectj-autoproxy/>
<bean id="testA" class="com.xiaomi.mifi.instalment.api.server.TestA" init-method="initMethod"> </bean>
<bean id="logAspect" class="com.xiaomi.mifi.instalment.api.server.LogAspect" />
<!--注册annotation-->
<context:annotation-config/>
</beans>
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
@Aspect
public class LogAspect {
@Around("execution(* com..*(..))")
private Object errorHandlerAround(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("-----------> LogAspect before");
Object rs = joinPoint.proceed();
System.out.println("-----------> LogAspect After");
return rs;
}
}
public class HelloImpl implements IHello{
@Override
public void sayHello() {
System.out.println("hello world");
}
}
import org.springframework.beans.factory.InitializingBean;
import javax.annotation.PostConstruct;
public class TestA implements InitializingBean , IHello{
public TestA() {
System.out.println("---->TestA constructor this is ");
}
@PostConstruct
public void init() {
System.out.println("PostConstruct");
}
public void initMethod() {
System.out.println("initMethod");
}
public void fooA() {
System.out.println("----> TestA.fooA this is ");
}
public void foo() {
System.out.println("----> TestA.foo this is ");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("afterPropertiesSet");
}
@Override
public void sayHello() {
System.out.println("----> TestA sayHello implement ");
}
}
这个触发操作是由于配置
// spring 配置文件, 启动spring AOP
<beans // aop 命令空间
xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
default-lazy-init="false">
// 开启 aop配置
<aop:aspectj-autoproxy/>
org.springframework.aop.config.AopNamespaceHandler
这个类用来解析xml配置文件中,aop开头的配置
这个aop命令空间(http://www.springframework.org/schema/aop) 是如何映射到这个类是通过配置文件spring.handlers,来完成的,这个文件在
srping-aop-4.3.30.jar包的,META-INF 目录下面的,spring会加载所有这个名称的文件,用来解析xml文件中的命令空间的
文件内容
http\://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler
org.springframework.aop.config.AopNamespaceHandler
@Override
public void init() {
// In 2.0 XSD as well as in 2.5+ XSDs
registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
// 属性 aspectj-autoproxy 的解析
registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
// Only in 2.0 XSD: moved to context namespace in 2.5+
registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
}
具体的细节就是使用AnnotationAwareAspectJAutoProxyCreator类,去向
BeanDefinitionRegistry把beanDefinition注册到工厂类中,bean的创建过程是先创建bena的定义,通过bean的定义再生成的对象。
通过下面的方法完成类:AnnotationAwareAspectJAutoProxyCreator的注册,所有aop的增强都是通过这个类来完成的如果是通过@Aspect注解,注解的切面。
该类的优先级别是最高级别的,先执行
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
AbstractAutoProxyCreator
是 AnnotationAwareAspectJAutoProxyCreator 的祖先类的,实现对类的增强是流程主入口。
AnnotationAwareAspectJAutoProxyCreator本身只处理和Aspect注解相关的事情,充分体现面向对象
抽象、继承,的特点,体现了高扩展能力。
org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator
AbstractAutowireCapableBeanFactory.initializeBean
->applyBeanPostProcessorsAfterInitialization
开始执行 .postProcessAfterInitialization
// spring 解决单例循环依赖的时候,会提前注册一个BeanFactory,这里会提前生成代理类
@Override
public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 写入这个map的原因,是为了保证单例,这里提前生成了代理类(因为循环依赖),
// A->B->A , 这种情况下,在创建B的时候,会调用这里提前生成A的代理类,
// 这个时候B里面的对A的引用已经是新的代理类了,但是A本身的还在初始化的过程中还没完成
// 需要完成A的初始化,但是还不能重新生成新的代理类否则就不是单例了,所以这里记录
// 在postProcessAfterInitialization的时候,对比引用,如果一样,就不重新生成代理类了
// 同时这个方法只会被调用一次,因为单例对象生成过成中会加锁,而且进行缓存,保证创建完成之后
// 只会从缓存里面取。同时最终A初始化完成之后,会把最终返回的引用对象体会为这里生成的代理对象,保证单例
this.earlyProxyReferences.put(cacheKey, bean);
// 生成代理类的具体实现
return wrapIfNecessary(bean, beanName, cacheKey);
}
// 正常的非循环依赖的对象,都从这里进行AOP的增强
// 这里的循环依赖指的是单例循环依赖(非构造函数依赖)
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 1, 如果是循环依赖则remove返回的bean ,和 当前是bean地址一样,这里是false,直接结束
// 2, 非循环依赖,那这里remove返回的是null,而bean不为空是先决条件,所以这里返回 true,进行类的增强,生成代理类
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
// 生成代理类的具体实现
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
// 生成代理类
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.
//获取需要增强的切面
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
// 缓存该类,需要 AOP 增强
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 生成代理类对象
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors
// 被代理的对象,在代理类最后调用
, new SingletonTargetSource(bean));
// 缓存
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
// 缓存该类,不需要 AOP 增强
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// 生成代理类
protected Object createProxy(
Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
// 设置属性,把原始类名称,设置到 BeanDefiniiton的属性中
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);
// 检查类,是需要代理类,还是代理接口,因为有的类没有接口,只能代理类
// java JDK proxy只能代理接口,如果是代理类需要使用cgLib生成子类才行
if (!proxyFactory.isProxyTargetClass()) {
// 检查类属性是否有生命
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
// 如果实现的类是内部类,最后也会代理类
// proxyFactory.setProxyTargetClass(true);
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);
}
// 生成代理对象
return proxyFactory.getProxy(getProxyClassLoader());
}
// 检查是否需要代理类
protected void evaluateProxyInterfaces(Class<?> beanClass, ProxyFactory proxyFactory) {
Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
boolean hasReasonableProxyInterface = false;
for (Class<?> ifc : targetInterfaces) {
if (!isConfigurationCallbackInterface(ifc) && !isInternalLanguageInterface(ifc) &&
ifc.getMethods().length > 0) {
hasReasonableProxyInterface = true;
break;
}
}
// 有需要代理的接口,则添加代理接口,这里有个问题,就是只能代理接口的方法,
// 非接口方法无法代理,即使符合pointCut的条件
if (hasReasonableProxyInterface) {
// Must allow for introductions; can't just set interfaces to the target's interfaces only.
for (Class<?> ifc : targetInterfaces) {
proxyFactory.addInterface(ifc);
}
}
else {
// 否则只能代理类
proxyFactory.setProxyTargetClass(true);
}
}
// 生成最终的advisor
protected Advisor[] buildAdvisors(String beanName, Object[] specificInterceptors) {
// Handle prototypes correctly...
// 通过配置文件配置的,目前都是通过注解,所以这里一般都是空的
Advisor[] commonInterceptors = resolveInterceptorNames();
List<Object> allInterceptors = new ArrayList<Object>();
if (specificInterceptors != null) {
allInterceptors.addAll(Arrays.asList(specificInterceptors));
if (commonInterceptors.length > 0) {
if (this.applyCommonInterceptorsFirst) {
allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
}
else {
allInterceptors.addAll(Arrays.asList(commonInterceptors));
}
}
}
Advisor[] advisors = new Advisor[allInterceptors.size()];
for (int i = 0; i < allInterceptors.size(); i++) {
// wrap 是进行一次适配的过程,因为要兼容老的切面,所以进行一次兼容处理
advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
}
return advisors;
}
org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator
是 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator
的子类,提供和切面相关的逻辑
@Override
protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, 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) {
// 获取所有的切面, 注意是逻辑见AnnotationAwareAspectJAutoProxyCreator
List<Advisor> candidateAdvisors = findCandidateAdvisors();
// 取出符合该对象的切面
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
// 扩展切面,这个是因为有一些切面比较老,需要去兼容一些,做一些适配
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
// 切面排序,决定执行先后顺序
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
对Aspect注解,进行解析,获取所有的Aspect注解,切面
以及表达式
org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
主流程
@Override
protected List findCandidateAdvisors() {
// 先调用父类接口,兼容父类
List advisors = super.findCandidateAdvisors();
// 获取Aspect注解的切面
advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
return advisors;
}
// 获取增强列表,
// 来自类:org.springframework.aop.aspectj.annotation.BeanFactoryAspectJAdvisorsBuilder
public List buildAspectJAdvisors() {
List aspectNames = this.aspectBeanNames;
if (aspectNames == null) {
// 加锁,防止重复操作
synchronized (this) {
aspectNames = this.aspectBeanNames;
// double check
if (aspectNames == null) {
List advisors = new LinkedList();
aspectNames = new LinkedList();
// 由于Aspect注解本身无法直接识别,所以通过这种方式获取所有的已经
// 这个地方会获取所有的bean,包含继承Object的子类,由于Asject注解,的类本身是没有类型的
// 所以这里使用Object获取所有的,调用这个方法会进行缓存
//所以没有直接调用this.beanFactory.getBeanDefinitionNames 这个方法
String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this.beanFactory, Object.class, true, false);
for (String beanName : beanNames) {
if (!isEligibleBean(beanName)) {
continue;
}
// We must be careful not to instantiate beans eagerly as in this case they
// would be cached by the Spring container but would not have been weaved.
Class beanType = this.beanFactory.getType(beanName);
if (beanType == null) {
continue;
}
// 判断是否有Aspect注解
if (this.advisorFactory.isAspect(beanType)) {
aspectNames.add(beanName);
AspectMetadata amd = new AspectMetadata(beanType, beanName);
if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
// 创建工厂类,这个工厂类只包含当前aspect一个beanName,为了后续生成advice使用
MetadataAwareAspectInstanceFactory factory =
new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
// 解析Aspect注解的类,获取方法上面的注解,每个增强方法都是一个切面增强
// 具体的可以看下代码细节,比较简单就是解析 Around After before这些注解
List classAdvisors = this.advisorFactory.getAdvisors(factory);
if (this.beanFactory.isSingleton(beanName)) {
this.advisorsCache.put(beanName, classAdvisors);
}
else {
this.aspectFactoryCache.put(beanName, factory);
}
advisors.addAll(classAdvisors);
}
else {
// Per target or per this.
if (this.beanFactory.isSingleton(beanName)) {
throw new IllegalArgumentException("Bean with name '" + beanName +
"' is a singleton, but aspect instantiation model is not singleton");
}
MetadataAwareAspectInstanceFactory factory =
new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
this.aspectFactoryCache.put(beanName, factory);
advisors.addAll(this.advisorFactory.getAdvisors(factory));
}
}
}
this.aspectBeanNames = aspectNames;
return advisors;
}
}
}
if (aspectNames.isEmpty()) {
return Collections.emptyList();
}
List advisors = new LinkedList();
for (String aspectName : aspectNames) {
// 单例
List cachedAdvisors = this.advisorsCache.get(aspectName);
if (cachedAdvisors != null) {
advisors.addAll(cachedAdvisors);
}
else {
// 非单例的每次都需要通过工厂类生成新的对象
MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
advisors.addAll(this.advisorFactory.getAdvisors(factory));
}
}
return advisors;
}
// 获取@aspect 注解类中的 advice
@Override
public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
validate(aspectClass);
// We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
// so that it will only instantiate once.
// 为了延迟初始化对象
MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
List<Advisor> advisors = new ArrayList<Advisor>();
// 过滤掉pointCut 切面注解,
for (Method method : getAdvisorMethods(aspectClass)) {
// 获取所有的注解方法, @around @before等
Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
if (advisor != null) {
advisors.add(advisor);
}
}
// If it's a per target aspect, emit the dummy instantiating aspect.
if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
advisors.add(0, instantiationAdvisor);
}
// Find introduction fields.
for (Field field : aspectClass.getDeclaredFields()) {
Advisor advisor = getDeclareParentsAdvisor(field);
if (advisor != null) {
advisors.add(advisor);
}
}
return advisors;
}
//
@Override
public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
int declarationOrderInAspect, String aspectName) {
validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
AspectJExpressionPointcut expressionPointcut = getPointcut(
candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
if (expressionPointcut == null) {
return null;
}
// 这里会根据注解 @around before after 生成不同的advice实现类
return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}
//
public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
this.declaredPointcut = declaredPointcut;
this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
this.methodName = aspectJAdviceMethod.getName();
this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
this.aspectJAdviceMethod = aspectJAdviceMethod;
this.aspectJAdvisorFactory = aspectJAdvisorFactory;
this.aspectInstanceFactory = aspectInstanceFactory;
this.declarationOrder = declarationOrder;
this.aspectName = aspectName;
// A singleton aspect.
this.pointcut = this.declaredPointcut;
this.lazy = false;
// 这里进行advice的初始化
this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
}
// 实例化增强器 advice
private Advice instantiateAdvice(AspectJExpressionPointcut pcut) {
return this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pcut,
this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
}
// 根据不同的注解,生成不同的advice实例,代理的时候调用的是这个实例
@Override
public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
Class candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
validate(candidateAspectClass);
AspectJAnnotation aspectJAnnotation =
AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
if (aspectJAnnotation == null) {
return null;
}
// If we get here, we know we have an AspectJ method.
// Check that it's an AspectJ-annotated class
if (!isAspect(candidateAspectClass)) {
throw new AopConfigException("Advice must be declared inside an aspect type: " +
"Offending method '" + candidateAdviceMethod + "' in class [" +
candidateAspectClass.getName() + "]");
}
if (logger.isDebugEnabled()) {
logger.debug("Found AspectJ method: " + candidateAdviceMethod);
}
AbstractAspectJAdvice springAdvice;
switch (aspectJAnnotation.getAnnotationType()) {
case AtPointcut:
if (logger.isDebugEnabled()) {
logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
}
return null;
// around 注解,
case AtAround:
// 这里把facotyr作为参数放进去,是为了延迟获取实例化对象,等需要的时候再生成
springAdvice = new AspectJAroundAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtBefore:
springAdvice = new AspectJMethodBeforeAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtAfter:
springAdvice = new AspectJAfterAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtAfterReturning:
springAdvice = new AspectJAfterReturningAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
if (StringUtils.hasText(afterReturningAnnotation.returning())) {
springAdvice.setReturningName(afterReturningAnnotation.returning());
}
break;
case AtAfterThrowing:
springAdvice = new AspectJAfterThrowingAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
}
break;
default:
throw new UnsupportedOperationException(
"Unsupported advice type on method: " + candidateAdviceMethod);
}
// Now to configure the advice...
springAdvice.setAspectName(aspectName);
springAdvice.setDeclarationOrder(declarationOrder);
String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
if (argNames != null) {
springAdvice.setArgumentNamesFromStringArray(argNames);
}
springAdvice.calculateArgumentBindings();
return springAdvice;
}
pointCut表达式文档
// 匹配符合条件的切面
protected List findAdvisorsThatCanApply(
List candidateAdvisors, Class beanClass, String beanName) {
// 设置到 ThrealLocal里面,其他地方会调用这个来进行切面的匹配,从这里获取要增强的类
// 决定是否要进行增强
ProxyCreationContext.setCurrentProxiedBeanName(beanName);
try {
return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
}
finally {
// 清除 ThrealLocal
ProxyCreationContext.setCurrentProxiedBeanName(null);
}
}
// org.springframework.aop.support.AopUtils
public static List findAdvisorsThatCanApply(List candidateAdvisors, Class clazz) {
if (candidateAdvisors.isEmpty()) {
return candidateAdvisors;
}
for (Advisor candidate : candidateAdvisors) {
if (candidate instanceof IntroductionAdvisor) {
// already processed
continue;
}
// Spring Aop Aspect 注解走的都是这里
if (canApply(candidate, clazz, hasIntroductions)) {
eligibleAdvisors.add(candidate);
}
}
return eligibleAdvisors;
}
// org.springframework.aop.support.AopUtils
public static boolean canApply(Advisor advisor, Class targetClass, boolean hasIntroductions) {
if (advisor instanceof IntroductionAdvisor) {
return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
}
// 走这里,切面增强
else if (advisor instanceof PointcutAdvisor) {
PointcutAdvisor pca = (PointcutAdvisor) advisor;
return canApply(pca.getPointcut(), targetClass, hasIntroductions);
}
else {
// It doesn't have a pointcut so we assume it applies.
return true;
}
}
// org.springframework.aop.support.AopUtils
public static boolean canApply(Pointcut pc, Class targetClass, boolean hasIntroductions) {
Assert.notNull(pc, "Pointcut must not be null");
// 类过滤,如果类不符合条件,直接结束,看了一点没看明白,大概意思就是进行字符串匹配,
// 但是匹配方式比较复杂
if (!pc.getClassFilter().matches(targetClass)) {
return false;
}
MethodMatcher methodMatcher = pc.getMethodMatcher();
if (methodMatcher == MethodMatcher.TRUE) {
// No need to iterate the methods if we're matching any method anyway...
return true;
}
IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
}
// 获取该类的实现的所有接口类
Set> classes = new LinkedHashSet>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
// 把当前类添加进去
classes.add(targetClass);
// 遍历当前类以及其所有接口类的,所有方法,先遍历接口,最后遍历当前类
for (Class clazz : classes) {
Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
for (Method method : methods) {
if ((introductionAwareMethodMatcher != null &&
// 方法匹配,具体实现细节没有看懂
introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) ||
// 更大范围的匹配,大概就是把类,入参,返回值等拆成不同的token 进行匹配,具体实现细节没有看懂
methodMatcher.matches(method, targetClass)) {
// 只要有一个方法符合条件则直接返回,快速返回,
// 因为只要有一个就必须生成代理类了,没必要遍历所有的方法
return true;
}
}
}
return false;
}
// 来自 org.springframework.aop.framework.DefaultAopProxyFactory
// 先根据配置,或者当前类的情况,生成代理工厂类,如果该类一个自定义接口都没有实现
// 则会使用CGLib进行代理,通过生成子类的方式,增强需要增强的方法。
// 否则使用JDk动态代理工厂类,但是该类只会生成接口包含的方法的代理类,不会对实现类内所有方法都进行代理
// 总之都是有条件的,对于符合条件的方法进行代理。但是JDK动态代理生成的代理对象的类型必须是其实现的
// 接口否则会因为类型不匹配报错。
@Override
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);
}
}
// 来自 org.springframework.aop.framework.JdkDynamicAopProxy
@Override
public Object getProxy(ClassLoader classLoader) {
// 获取所有需要代理的接口,这里会新增一些springAOP特有的接口
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
// 检查、标识,是否有,equal ,hashCode, 方法,没有需要特殊处理
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
// 使用JDK动态代理,生成代理类,具体的可以看下面的生成的代理类
// 这里使用this当前对象是因为,具体的操作要由该对象来完成,每个需要代理的对象都会新生成一个该对象
//该类实现了InvocationHandler接口,具体代理在invoder方法中 final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, {
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
// 来自 org.springframework.aop.framework.AopProxyUtils
static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised, boolean decoratingProxy) {
Class<?>[] specifiedInterfaces = advised.getProxiedInterfaces();
if (specifiedInterfaces.length == 0) {
// No user-specified interfaces: check whether target class is an interface.
Class<?> targetClass = advised.getTargetClass();
if (targetClass != null) {
if (targetClass.isInterface()) {
advised.setInterfaces(targetClass);
}
else if (Proxy.isProxyClass(targetClass)) {
advised.setInterfaces(targetClass.getInterfaces());
}
specifiedInterfaces = advised.getProxiedInterfaces();
}
}
// 如果没有,则需要代理该接口, 该接口没有具体方法,只是用来标识是是最顶层的抽象定义接口,划分类别
boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);
// 如果没有,则需要代理该接口, 这个里面有所有增强器需要的基础方法,但是默认JDK动态代理都已经实现了
boolean addAdvised = !advised.isOpaque() && !advised.isInterfaceProxied(Advised.class);
// 如果没有,则需要代理该接口
boolean addDecoratingProxy = (decoratingProxy && !advised.isInterfaceProxied(DecoratingProxy.class));
int nonUserIfcCount = 0;
if (addSpringProxy) {
nonUserIfcCount++;
}
if (addAdvised) {
nonUserIfcCount++;
}
if (addDecoratingProxy) {
nonUserIfcCount++;
}
Class<?>[] proxiedInterfaces = new Class<?>[specifiedInterfaces.length + nonUserIfcCount];
System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length);
int index = specifiedInterfaces.length;
if (addSpringProxy) {
proxiedInterfaces[index] = SpringProxy.class;
index++;
}
if (addAdvised) {
proxiedInterfaces[index] = Advised.class;
index++;
}
if (addDecoratingProxy) {
proxiedInterfaces[index] = DecoratingProxy.class;
}
return proxiedInterfaces;
}
// 来自 org.springframework.aop.framework.DefaultAopProxyFactory
// 查找其接口中,是否包含的有 equal , hashCode 两个方法
// 因为要是没有的话就需要进行特殊处理,因为这两个方法是必须要要有的,属于所有对象都有的
// 因为所有对象都继承自 Object类
private void findDefinedEqualsAndHashCodeMethods(Class<?>[] proxiedInterfaces) {
for (Class<?> proxiedInterface : proxiedInterfaces) {
Method[] methods = proxiedInterface.getDeclaredMethods();
for (Method method : methods) {
if (AopUtils.isEqualsMethod(method)) {
this.equalsDefined = true;
}
if (AopUtils.isHashCodeMethod(method)) {
this.hashCodeDefined = true;
}
if (this.equalsDefined && this.hashCodeDefined) {
return;
}
}
}
}
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package com.sun.proxy;
import com.xiaomi.mifi.instalment.api.server.IHello;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import org.aopalliance.aop.Advice;
import org.springframework.aop.Advisor;
import org.springframework.aop.SpringProxy;
import org.springframework.aop.TargetSource;
import org.springframework.aop.framework.Advised;
import org.springframework.aop.framework.AopConfigException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.DecoratingProxy;
public final class $Proxy9 extends Proxy implements InitializingBean, IHello, SpringProxy, Advised, DecoratingProxy {
private static Method m1;
private static Method m15;
private static Method m26;
private static Method m22;
private static Method m17;
private static Method m12;
private static Method m5;
private static Method m21;
private static Method m10;
private static Method m9;
private static Method m0;
private static Method m13;
private static Method m19;
private static Method m25;
private static Method m23;
private static Method m2;
private static Method m27;
private static Method m14;
private static Method m28;
private static Method m16;
private static Method m6;
private static Method m7;
private static Method m18;
private static Method m24;
private static Method m4;
private static Method m3;
private static Method m20;
private static Method m8;
private static Method m11;
public $Proxy9(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
// super.h 指的是org.springframework.aop.framework.JdkDynamicAopProxy
// 类生成的对象,invoder 就是其invoder方法,具体看下面的调用流程
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void addAdvisor(Advisor var1) throws AopConfigException {
try {
super.h.invoke(this, m15, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final boolean isExposeProxy() throws {
try {
return (Boolean)super.h.invoke(this, m26, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final boolean isProxyTargetClass() throws {
try {
return (Boolean)super.h.invoke(this, m22, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void removeAdvisor(int var1) throws AopConfigException {
try {
super.h.invoke(this, m17, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final Class[] getProxiedInterfaces() throws {
try {
return (Class[])super.h.invoke(this, m12, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int indexOf(Advisor var1) throws {
try {
return (Integer)super.h.invoke(this, m5, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final TargetSource getTargetSource() throws {
try {
return (TargetSource)super.h.invoke(this, m21, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void addAdvice(int var1, Advice var2) throws AopConfigException {
try {
super.h.invoke(this, m10, new Object[]{var1, var2});
} catch (RuntimeException | Error var4) {
throw var4;
} catch (Throwable var5) {
throw new UndeclaredThrowableException(var5);
}
}
public final void addAdvice(Advice var1) throws AopConfigException {
try {
super.h.invoke(this, m9, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final boolean isInterfaceProxied(Class var1) throws {
try {
return (Boolean)super.h.invoke(this, m13, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final boolean removeAdvice(Advice var1) throws {
try {
return (Boolean)super.h.invoke(this, m19, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void setExposeProxy(boolean var1) throws {
try {
super.h.invoke(this, m25, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void setTargetSource(TargetSource var1) throws {
try {
super.h.invoke(this, m23, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final Class getTargetClass() throws {
try {
return (Class)super.h.invoke(this, m27, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void addAdvisor(int var1, Advisor var2) throws AopConfigException {
try {
super.h.invoke(this, m14, new Object[]{var1, var2});
} catch (RuntimeException | Error var4) {
throw var4;
} catch (Throwable var5) {
throw new UndeclaredThrowableException(var5);
}
}
public final Class getDecoratedClass() throws {
try {
return (Class)super.h.invoke(this, m28, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final boolean removeAdvisor(Advisor var1) throws {
try {
return (Boolean)super.h.invoke(this, m16, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final int indexOf(Advice var1) throws {
try {
return (Integer)super.h.invoke(this, m6, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final boolean isFrozen() throws {
try {
return (Boolean)super.h.invoke(this, m7, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final boolean replaceAdvisor(Advisor var1, Advisor var2) throws AopConfigException {
try {
return (Boolean)super.h.invoke(this, m18, new Object[]{var1, var2});
} catch (RuntimeException | Error var4) {
throw var4;
} catch (Throwable var5) {
throw new UndeclaredThrowableException(var5);
}
}
public final void setPreFiltered(boolean var1) throws {
try {
super.h.invoke(this, m24, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void sayHello() throws {
try {
super.h.invoke(this, m4, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void afterPropertiesSet() throws Exception {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (Exception | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final String toProxyConfigString() throws {
try {
return (String)super.h.invoke(this, m20, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final Advisor[] getAdvisors() throws {
try {
return (Advisor[])super.h.invoke(this, m8, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final boolean isPreFiltered() throws {
try {
return (Boolean)super.h.invoke(this, m11, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m15 = Class.forName("org.springframework.aop.framework.Advised").getMethod("addAdvisor", Class.forName("org.springframework.aop.Advisor"));
m26 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isExposeProxy");
m22 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isProxyTargetClass");
m17 = Class.forName("org.springframework.aop.framework.Advised").getMethod("removeAdvisor", Integer.TYPE);
m12 = Class.forName("org.springframework.aop.framework.Advised").getMethod("getProxiedInterfaces");
m5 = Class.forName("org.springframework.aop.framework.Advised").getMethod("indexOf", Class.forName("org.springframework.aop.Advisor"));
m21 = Class.forName("org.springframework.aop.framework.Advised").getMethod("getTargetSource");
m10 = Class.forName("org.springframework.aop.framework.Advised").getMethod("addAdvice", Integer.TYPE, Class.forName("org.aopalliance.aop.Advice"));
m9 = Class.forName("org.springframework.aop.framework.Advised").getMethod("addAdvice", Class.forName("org.aopalliance.aop.Advice"));
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
m13 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isInterfaceProxied", Class.forName("java.lang.Class"));
m19 = Class.forName("org.springframework.aop.framework.Advised").getMethod("removeAdvice", Class.forName("org.aopalliance.aop.Advice"));
m25 = Class.forName("org.springframework.aop.framework.Advised").getMethod("setExposeProxy", Boolean.TYPE);
m23 = Class.forName("org.springframework.aop.framework.Advised").getMethod("setTargetSource", Class.forName("org.springframework.aop.TargetSource"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m27 = Class.forName("org.springframework.aop.framework.Advised").getMethod("getTargetClass");
m14 = Class.forName("org.springframework.aop.framework.Advised").getMethod("addAdvisor", Integer.TYPE, Class.forName("org.springframework.aop.Advisor"));
m28 = Class.forName("org.springframework.core.DecoratingProxy").getMethod("getDecoratedClass");
m16 = Class.forName("org.springframework.aop.framework.Advised").getMethod("removeAdvisor", Class.forName("org.springframework.aop.Advisor"));
m6 = Class.forName("org.springframework.aop.framework.Advised").getMethod("indexOf", Class.forName("org.aopalliance.aop.Advice"));
m7 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isFrozen");
m18 = Class.forName("org.springframework.aop.framework.Advised").getMethod("replaceAdvisor", Class.forName("org.springframework.aop.Advisor"), Class.forName("org.springframework.aop.Advisor"));
m24 = Class.forName("org.springframework.aop.framework.Advised").getMethod("setPreFiltered", Boolean.TYPE);
m4 = Class.forName("com.xiaomi.mifi.instalment.api.server.IHello").getMethod("sayHello");
m3 = Class.forName("org.springframework.beans.factory.InitializingBean").getMethod("afterPropertiesSet");
m20 = Class.forName("org.springframework.aop.framework.Advised").getMethod("toProxyConfigString");
m8 = Class.forName("org.springframework.aop.framework.Advised").getMethod("getAdvisors");
m11 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isPreFiltered");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
注意,这里只能代理接口,生成的代理类继承 com.sun.Proxy 类,生成的代理方法来自于接口,而不是实现类,所以如果在实现类外面引用了实现类,而不是接口,这个类还被增强 了,那就会报错。提示
com.sun.Proxy 无法转换为需要的类型。就是因为这个原因。但是类内部的方法调用是不影响,属于内部调用(内部调用使用的是实现类对象的而不是代理对象,所以没有影响。
org.springframework.aop.framework.JdkDynamicAopProxy
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
// 代理类,会让所有的代理方法最终调用到这里,具体原因看上面生成的代理类
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
MethodInvocation invocation;
Object oldProxy = null;
boolean setProxyContext = false;
// 被代理的对象,testA
TargetSource targetSource = this.advised.targetSource;
Class<?> targetClass = null;
Object target = null;
try {
// 之前检查做的标记,如果没有equal方法,并且正在调用则进行特殊处理,这里
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
// The target does not implement the equals(Object) method itself.
// 这里的比较还是比较特殊的,可以看看,会对比很多东西,不会对比hashCode
return equals(args[0]);
}
// 之前检查做的标记,如果没有hashCode 方法,并且正在调用则进行特殊处理
else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
// 使用当前对象的hashCode,加上 被代理对象的hashCode保证其唯一性
return hashCode();
}
else if (method.getDeclaringClass() == DecoratingProxy.class) {
// There is only getDecoratedClass() declared -> dispatch to proxy config.
// 默认实现,因为目前的代理类本身都不会实现这个方法,所有这里特殊处理
return AopProxyUtils.ultimateTargetClass(this.advised);
}
else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}
Object retVal;
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 = targetSource.getTarget();
if (target != null) {
targetClass = target.getClass();
}
// 这里获取的就是advice列表了,比如 AspectJAroundAdvice
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
// 没有需要代理的则直接调用被代理对象就好了
if (chain.isEmpty()) {
// 对于Strig ..args这种可变参数,进行兼容处理
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
// 反射调用方法
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
else {
// 生成代理调用类,通过下标,根据filter这种链式调用,执行所有代理
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// 开始执行
retVal = invocation.proceed();
}
// Massage return value if necessary.
Class<?> returnType = method.getReturnType();
if (retVal != null && retVal == target &&
returnType != Object.class && returnType.isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
// Special case: it returned "this" and the return type of the method
// is type-compatible. Note that we can't help if the target sets
// a reference to itself in another returned object.
retVal = proxy;
}
else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
throw new AopInvocationException(
"Null return value from advice does not match primitive return type for: " + method);
}
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
// Must have come from TargetSource.
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
// 来自: org.springframework.aop.framework.ReflectiveMethodInvocation
@Override
public Object proceed() throws Throwable {
// 最后执行,被代理对象的方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
// 从-1开始,所以先加+1,再使用
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have
// been evaluated and found to match.
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
// Dynamic matching failed.
// Skip this interceptor and invoke the next in the chain.
return proceed();
}
}
else {
// aroundAdvice这种都是实现了MethodInterceptor接口,走这里
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
// org.springframework.aop.aspectj.AspectJAroundAdvice
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
if (!(mi instanceof ProxyMethodInvocation)) {
throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
}
ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi);
JoinPointMatch jpm = getJoinPointMatch(pmi);
return invokeAdviceMethod(pjp, jpm, null, null);
}
// org.springframework.aop.aspectj.AbstractAspectJAdvice
// 调用切面增强器方法
protected Object invokeAdviceMethod(JoinPoint jp, JoinPointMatch jpMatch, Object returnValue, Throwable t)
throws Throwable {
// argBinding 进行参数的绑定
return invokeAdviceMethodWithGivenArgs(argBinding(jp, jpMatch, returnValue, t));
}
protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
Object[] actualArgs = args;
if (this.aspectJAdviceMethod.getParameterTypes().length == 0) {
actualArgs = null;
}
try {
ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);
// this.aspectInstanceFactory.getAspectInstance() 通过前面创建的工厂类,获取增强器的额对象
// 通过反射执行增强器的方法, 因为 around里面会继续调用 jointPoint.process()方法,所以这里不需要显示调用
return this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs);
}
catch (IllegalArgumentException ex) {
throw new AopInvocationException("Mismatch on arguments to advice method [" +
this.aspectJAdviceMethod + "]; pointcut expression [" +
this.pointcut.getPointcutExpression() + "]", ex);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}