Spring AOP 源码

Advice通知：

public interface Advice {}public interface BeforeAdvice extends Advice {}public interface MethodBeforeAdvice extends BeforeAdvice {    // 实现回调函数    void before(Method method, Object[] args, Object target) throws Throwable;}

PointCut 切点：

public interface Pointcut {    ClassFilter getClassFilter();    MethodMatcher getMethodMatcher();    Pointcut TRUE = TruePointcut.INSTANCE;}

实现

@SuppressWarnings("serial")public class JdkRegexpMethodPointcut extends AbstractRegexpMethodPointcut {    private Pattern[] compiledPatterns = new Pattern[0];    private Pattern[] compiledExclusionPatterns = new Pattern[0];    @Override    protected void initPatternRepresentation(String[] patterns) throws PatternSyntaxException {        this.compiledPatterns = compilePatterns(patterns);    }    @Override    protected void initExcludedPatternRepresentation(String[] excludedPatterns) throws PatternSyntaxException {        this.compiledExclusionPatterns = compilePatterns(excludedPatterns);    }    // 匹配方法名    @Override    protected boolean matches(String pattern, int patternIndex) {        Matcher matcher = this.compiledPatterns[patternIndex].matcher(pattern);        return matcher.matches();    }    @Override    protected boolean matchesExclusion(String candidate, int patternIndex) {        Matcher matcher = this.compiledExclusionPatterns[patternIndex].matcher(candidate);        return matcher.matches();    }    private Pattern[] compilePatterns(String[] source) throws PatternSyntaxException {        Pattern[] destination = new Pattern[source.length];        for (int i = 0; i < source.length; i++) {            destination[i] = Pattern.compile(source[i]);        }        return destination;    }}

Adviser 通知器：

@SuppressWarnings("serial")public class DefaultPointcutAdvisor extends AbstractGenericPointcutAdvisor implements Serializable {    // 切点    private Pointcut pointcut = Pointcut.TRUE;    public DefaultPointcutAdvisor() {    }    // 通知    public DefaultPointcutAdvisor(Advice advice) {        this(Pointcut.TRUE, advice);    }    public DefaultPointcutAdvisor(Pointcut pointcut, Advice advice) {        this.pointcut = pointcut;        setAdvice(advice);    }    public void setPointcut(Pointcut pointcut) {        this.pointcut = (pointcut != null ? pointcut : Pointcut.TRUE);    }    @Override    public Pointcut getPointcut() {        return this.pointcut;    }    @Override    public String toString() {        return getClass().getName() + ": pointcut [" + getPointcut() + "]; advice [" + getAdvice() + "]";    }}class TruePointcut implements Pointcut, Serializable {    // 单例模式    public static final TruePointcut INSTANCE = new TruePointcut();    ...}

动态代理：

aop代理工厂：

public interface AopProxyFactory {    AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException;}

默认代理工厂实现类：

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {    @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.");            }            // 如果目标类型是接口，则使用JDK动态代理，因为cglib是采用继承的方式实现动态代理的            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {                return new JdkDynamicAopProxy(config);            }            return new ObjenesisCglibAopProxy(config);        }        else {            return new JdkDynamicAopProxy(config);        }    }    private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {        Class<?>[] ifcs = config.getProxiedInterfaces();        return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));    }}

动态代理invoke方法实现：

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;        TargetSource targetSource = this.advised.targetSource;        Class<?> targetClass = null;        Object target = null;        try {            ...            Object retVal;            if (this.advised.exposeProxy) {                // Make invocation available if necessary.                oldProxy = AopContext.setCurrentProxy(proxy);                setProxyContext = true;            }            // 得到目标对象            target = targetSource.getTarget();            if (target != null) {                targetClass = target.getClass();            }            // 得到拦截器链            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);            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);                // Proceed to the joinpoint through the interceptor chain.                retVal = invocation.proceed();            }            // Massage return value if necessary.            Class<?> returnType = method.getReturnType();            if (retVal != null && retVal == target && 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);            }        }    }    ...}

ReflectiveMethodInvocation :

public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {    ...    @Override    public Object proceed() throws Throwable {        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {            return invokeJoinpoint();        }        Object interceptorOrInterceptionAdvice =                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {            InterceptorAndDynamicMethodMatcher dm =                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {                // 进行拦截器操作成功，执行拦截器                return dm.interceptor.invoke(this);            }            else {                // 拦截失败，进行下一个拦截器的匹配进行，直至所有拦截器都被运行过                return proceed();            }        }        else {            // 如果是拦截器，直接获取拦截器直接执行             return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);        }    }    ...}

获取拦截器链：

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) {        // 利用缓存储存        MethodCacheKey cacheKey = new MethodCacheKey(method);        List<Object> cached = this.methodCache.get(cacheKey);        if (cached == null) {            // 首次生成            cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(                    this, method, targetClass);            // 加入缓存            this.methodCache.put(cacheKey, cached);        }        return cached;    }

DefaultAdvisorChainFactory 生成拦截器链：

public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, Class<?> targetClass) {        ArrayList interceptorList = new ArrayList(config.getAdvisors().length);        Class actualClass = targetClass != null?targetClass:method.getDeclaringClass();        boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);        // 拦截器通过AdvisorAdapterRegistry进行注册        AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();        Advisor[] var8 = config.getAdvisors();        int var9 = var8.length;        for(int var10 = 0; var10 < var9; ++var10) {            Advisor advisor = var8[var10];            MethodInterceptor[] interceptors1;            if(advisor instanceof PointcutAdvisor) {                PointcutAdvisor var20 = (PointcutAdvisor)advisor;                if(config.isPreFiltered() || var20.getPointcut().getClassFilter().matches(actualClass)) {                    interceptors1 = registry.getInterceptors(advisor);                    MethodMatcher mm = var20.getPointcut().getMethodMatcher();                    if(MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {                        if(mm.isRuntime()) {                            MethodInterceptor[] var15 = interceptors1;                            int var16 = interceptors1.length;                            for(int var17 = 0; var17 < var16; ++var17) {                                MethodInterceptor interceptor = var15[var17];                                interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));                            }                        } else {                            interceptorList.addAll(Arrays.asList(interceptors1));                        }                    }                }            } else if(advisor instanceof IntroductionAdvisor) {                IntroductionAdvisor var19 = (IntroductionAdvisor)advisor;                if(config.isPreFiltered() || var19.getClassFilter().matches(actualClass)) {                    interceptors1 = registry.getInterceptors(advisor);                    interceptorList.addAll(Arrays.asList(interceptors1));                }            } else {                MethodInterceptor[] interceptors = registry.getInterceptors(advisor);                interceptorList.addAll(Arrays.asList(interceptors));            }        }        return interceptorList;    }

Advisor的获取和初始化：

private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {        if(!this.advisorChainInitialized) {            if(!ObjectUtils.isEmpty(this.interceptorNames)) {                if(this.beanFactory == null) {                    throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) - cannot resolve interceptor names " + Arrays.asList(this.interceptorNames));                }                if(this.interceptorNames[this.interceptorNames.length - 1].endsWith("*") && this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {                    throw new AopConfigException("Target required after globals");                }                String[] var1 = this.interceptorNames;                int var2 = var1.length;                for(int var3 = 0; var3 < var2; ++var3) {                    String name = var1[var3];                    if(this.logger.isTraceEnabled()) {                        this.logger.trace("Configuring advisor or advice \'" + name + "\'");                    }                    if(name.endsWith("*")) {                        if(!(this.beanFactory instanceof ListableBeanFactory)) {                            throw new AopConfigException("Can only use global advisors or interceptors with a ListableBeanFactory");                        }                        this.addGlobalAdvisor((ListableBeanFactory)this.beanFactory, name.substring(0, name.length() - "*".length()));                    } else {                        Object advice;                        // 判断是否单件还是ProtoType类型                        if(!this.singleton && !this.beanFactory.isSingleton(name)) {                        // 获取bean，单件                            advice = new ProxyFactoryBean.PrototypePlaceholderAdvisor(name);                        } else {                        // 生成bean，protoType                            advice = this.beanFactory.getBean(name);                        }                        this.addAdvisorOnChainCreation(advice, name);                    }                }            }            this.advisorChainInitialized = true;        }    }

Advice 通知的实现：

public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, Class<?> targetClass) {        ArrayList interceptorList = new ArrayList(config.getAdvisors().length);        Class actualClass = targetClass != null?targetClass:method.getDeclaringClass();        boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);        // 得到注册器 DefaultAdvisorAdapterRegistry 注册单件        // GlobalAdvisorAdapterRegistry为单例模式        AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();        Advisor[] var8 = config.getAdvisors();        int var9 = var8.length;        for(int var10 = 0; var10 < var9; ++var10) {            Advisor advisor = var8[var10];            MethodInterceptor[] interceptors1;            if(advisor instanceof PointcutAdvisor) {                PointcutAdvisor var20 = (PointcutAdvisor)advisor;                if(config.isPreFiltered() || var20.getPointcut().getClassFilter().matches(actualClass)) {                    interceptors1 = registry.getInterceptors(advisor);                    MethodMatcher mm = var20.getPointcut().getMethodMatcher();                    if(MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {                        if(mm.isRuntime()) {                            MethodInterceptor[] var15 = interceptors1;                            int var16 = interceptors1.length;                            for(int var17 = 0; var17 < var16; ++var17) {                                MethodInterceptor interceptor = var15[var17];                                interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));                            }                        } else {                            interceptorList.addAll(Arrays.asList(interceptors1));                        }                    }                }            } else if(advisor instanceof IntroductionAdvisor) {                IntroductionAdvisor var19 = (IntroductionAdvisor)advisor;                if(config.isPreFiltered() || var19.getClassFilter().matches(actualClass)) {                    interceptors1 = registry.getInterceptors(advisor);                    interceptorList.addAll(Arrays.asList(interceptors1));                }            } else {                MethodInterceptor[] interceptors = registry.getInterceptors(advisor);                interceptorList.addAll(Arrays.asList(interceptors));            }        }        return interceptorList;    }

GlobalAdvisorAdapterRegistry：

public abstract class GlobalAdvisorAdapterRegistry {    // 单例模式    private static AdvisorAdapterRegistry instance = new DefaultAdvisorAdapterRegistry();    // 适配器，返回单例适配器注册器    public GlobalAdvisorAdapterRegistry() {    }    public static AdvisorAdapterRegistry getInstance() {        return instance;    }    static void reset() {        instance = new DefaultAdvisorAdapterRegistry();    }}

DefaultAdvisorAdapterRegistry ：

//// Source code recreated from a .class file by IntelliJ IDEA// (powered by Fernflower decompiler)//package org.springframework.aop.framework.adapter;import java.io.Serializable;import java.util.ArrayList;import java.util.Iterator;import java.util.List;import org.aopalliance.aop.Advice;import org.aopalliance.intercept.MethodInterceptor;import org.springframework.aop.Advisor;import org.springframework.aop.framework.adapter.AdvisorAdapter;import org.springframework.aop.framework.adapter.AdvisorAdapterRegistry;import org.springframework.aop.framework.adapter.AfterReturningAdviceAdapter;import org.springframework.aop.framework.adapter.MethodBeforeAdviceAdapter;import org.springframework.aop.framework.adapter.ThrowsAdviceAdapter;import org.springframework.aop.framework.adapter.UnknownAdviceTypeException;import org.springframework.aop.support.DefaultPointcutAdvisor;public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {    // AdvisorAdapter列表，包含MethodBeforeAdvice、MethodAfterAdvice等等    private final List<AdvisorAdapter> adapters = new ArrayList(3);    public DefaultAdvisorAdapterRegistry() {        this.registerAdvisorAdapter(new MethodBeforeAdviceAdapter());        this.registerAdvisorAdapter(new AfterReturningAdviceAdapter());        this.registerAdvisorAdapter(new ThrowsAdviceAdapter());    }    public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {        if(adviceObject instanceof Advisor) {            return (Advisor)adviceObject;        } else if(!(adviceObject instanceof Advice)) {            throw new UnknownAdviceTypeException(adviceObject);        } else {            Advice advice = (Advice)adviceObject;            if(advice instanceof MethodInterceptor) {                return new DefaultPointcutAdvisor(advice);            } else {                Iterator var3 = this.adapters.iterator();                AdvisorAdapter adapter;                do {                    if(!var3.hasNext()) {                        throw new UnknownAdviceTypeException(advice);                    }                    adapter = (AdvisorAdapter)var3.next();                } while(!adapter.supportsAdvice(advice));                return new DefaultPointcutAdvisor(advice);            }        }    }    public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {        ArrayList interceptors = new ArrayList(3);        Advice advice = advisor.getAdvice();        if(advice instanceof MethodInterceptor) {            // 如果是MethodInterceptor，不需要适配，直接加入列表            interceptors.add((MethodInterceptor)advice);        }        Iterator var4 = this.adapters.iterator();        while(var4.hasNext()) {            AdvisorAdapter adapter = (AdvisorAdapter)var4.next();            if(adapter.supportsAdvice(advice)) {                // 遍历MethodBeforeAdviceAdapter，AfterReturningAdviceAdapter列表，看看是否适配，适配则加入拦截器链                interceptors.add(adapter.getInterceptor(advisor));            }        }        if(interceptors.isEmpty()) {            throw new UnknownAdviceTypeException(advisor.getAdvice());        } else {            return (MethodInterceptor[])interceptors.toArray(new MethodInterceptor[interceptors.size()]);        }    }    public void registerAdvisorAdapter(AdvisorAdapter adapter) {        this.adapters.add(adapter);    }}class AfterReturningAdviceAdapter implements AdvisorAdapter, Serializable {    AfterReturningAdviceAdapter() {    }    public boolean supportsAdvice(Advice advice) {        // 直接判断类型        return advice instanceof AfterReturningAdvice;    }    public MethodInterceptor getInterceptor(Advisor advisor) {        AfterReturningAdvice advice = (AfterReturningAdvice)advisor.getAdvice();        return new AfterReturningAdviceInterceptor(advice);    }}

ThrowsAdviceInterceptor ：

public class ThrowsAdviceInterceptor implements MethodInterceptor, AfterAdvice {    ....    public Object invoke(MethodInvocation mi) throws Throwable {        try {            return mi.proceed();        } catch (Throwable var4) {            Method handlerMethod = this.getExceptionHandler(var4);            if(handlerMethod != null) {                this.invokeHandlerMethod(mi, var4, handlerMethod);            }            throw var4;        }    }    ...}

Proxy：
通过JDK或者CGLIB的动态代理策略，生成AopProxy，得到拦截器链后，先遍历拦截器链然后才进行对实体指定方法的执行。而Advisor通知器也正因为拦截器链的存在才能起作用。