springboot sourcecode: AOP

ProxyFactoryBean生成AOP代理对象

配置目标对象和切面行为Advice，通过其配置的拦截器名称interceptorNames即通知器Advisor将切面应用到目标对象中。原文：Spring AOP源码解读_stubborn_ugly的博客-CSDN博客_aop源码

public class ProxyFactoryBean extends ProxyCreatorSupport implements FactoryBean<Object>, BeanClassLoaderAware, BeanFactoryAware {

public static final String GLOBAL_SUFFIX = "*"; //全局后缀
protected final Log logger = LogFactory.getLog(this.getClass()); //日志
@Nullable
private String[] interceptorNames; //拦截器名称
@Nullable
private String targetName; //目标名称
private boolean autodetectInterfaces = true; //自动检测接口
private boolean singleton = true; //单例
private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance(); //新建默认advisor注册器：一个Advisor适配器list, 默认注册before, afterReturnning, Throws Adapter，即往list里添加对应的 advisorAdapter 拦截器：获取方法，方法参数，目标，检查权限，调用Method.invoke方法 具体执行内容可拓展
private boolean freezeProxy = false;//冻结代理
@Nullable
private transient ClassLoader proxyClassLoader = ClassUtils.getDefaultClassLoader();//默认类加载器
private transient boolean classLoaderConfigured = false; //类加载配置  加transient不会被序列化
@Nullable
private transient BeanFactory beanFactory;
private boolean advisorChainInitialized = false; //是否已实现链
@Nullable
private Object singletonInstance; //单例实例

public ProxyFactoryBean() {
}

//...一些set函数

@Nullable
public Object getObject() throws BeansException {
    this.initializeAdvisorChain(); //初始化链 准备拦截器 ->
    if (this.isSingleton()) {
        return this.getSingletonInstance(); //返回单例实例代理 -> todo
    } else {
        if (this.targetName == null) {
            this.logger.info("Using non-singleton proxies with singleton targets is often undesirable. Enable prototype proxies by setting the 'targetName' property.");
        }

        return this.newPrototypeInstance(); //返回原型实例代理 -> todo
    }
}

}

//初始化责任链
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 (name.endsWith("*")) {
        if (!(this.beanFactory instanceof ListableBeanFactory)) {
            throw new AopConfigException("Can only use global advisors or interceptors with a ListableBeanFactory");
        }

        this.addGlobalAdvisors((ListableBeanFactory)this.beanFactory, name.substring(0, name.length() - "*".length())); //添加全局advisor ->
    } else {

Object advice;
if (!this.singleton && !this.beanFactory.isSingleton(name)) {
    advice = new ProxyFactoryBean.PrototypePlaceholderAdvisor(name);
} else {
    advice = this.beanFactory.getBean(name);
}

this.addAdvisorOnChainCreation(advice);
                }
            }
        }

        this.advisorChainInitialized = true; //设置责任链初始化完成
    }
}

//添加全局advisor
private void addGlobalAdvisors(ListableBeanFactory beanFactory, String prefix) {
    String[] globalAdvisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, Advisor.class); //获取advisor通知器类的bean含有子孙bean的bean的名字
    String[] globalInterceptorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, Interceptor.class); //获取全局拦截器的名字
    if (globalAdvisorNames.length > 0 || globalInterceptorNames.length > 0) { //如果有通知器或拦截器
        List<Object> beans = new ArrayList(globalAdvisorNames.length + globalInterceptorNames.length);
        String[] var6 = globalAdvisorNames;
        int var7 = globalAdvisorNames.length;

int var8;
String name;
for(var8 = 0; var8 < var7; ++var8) {
    name = var6[var8];
    if (name.startsWith(prefix)) {
        beans.add(beanFactory.getBean(name)); //根据拦截器名字获取要用到的bean
    }
}

var6 = globalInterceptorNames;
var7 = globalInterceptorNames.length;

for(var8 = 0; var8 < var7; ++var8) {
    name = var6[var8];
    if (name.startsWith(prefix)) {
        beans.add(beanFactory.getBean(name));  //根据拦截器名字获取要用到的bean
    }
}

AnnotationAwareOrderComparator.sort(beans);
        Iterator var10 = beans.iterator(); //排序后的bean

        while(var10.hasNext()) {
            Object bean = var10.next();
            this.addAdvisorOnChainCreation(bean); //将拦截器bean包装为advisor, 加入到责任链list上, 清除缓存
        }
    }

}

//获取单例实例代理
private synchronized Object getSingletonInstance() {
    if (this.singletonInstance == null) {
        this.targetSource = this.freshTargetSource(); //获取目标资源
        if (this.autodetectInterfaces && this.getProxiedInterfaces().length == 0 && !this.isProxyTargetClass()) {
            Class<?> targetClass = this.getTargetClass();
            if (targetClass == null) {
                throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
            }

this.setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader)); //为目标类设置接口
}

uper.setFrozen(this.freezeProxy);
        this.singletonInstance = this.getProxy(this.createAopProxy()); //返回代理对象 jdk动态代理或cglib： 包括AdvisedSupport, 代理的接口，接口的方法 
    }

    return this.singletonInstance;
}

 

JdkDynamicAopProxy.invoke:

@Nullable
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    Object oldProxy = null;
    boolean setProxyContext = false;
    TargetSource targetSource = this.advised.targetSource;
    Object target = null;

Class var8;
try {
    if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
        Boolean var18 = this.equals(args[0]);
        return var18;
    }

if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
    Integer var17 = this.hashCode();
    return var17;
}

if (method.getDeclaringClass() != DecoratingProxy.class) {
    Object retVal;
    if (!this.advised.opaque && method.getDeclaringClass().isInterface() && method.getDeclaringClass().isAssignableFrom(Advised.class)) {
        retVal = AopUtils.invokeJoinpointUsingReflection(this.advised, method, args); //使用反射激活连接点
        return retVal;
    }

if (this.advised.exposeProxy) {
    oldProxy = AopContext.setCurrentProxy(proxy);
    setProxyContext = true;
}

target = targetSource.getTarget();
Class<?> targetClass = target != null ? target.getClass() : null;
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); //获取拦截器 ->
if (chain.isEmpty()) {
    Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
    retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
} else {
    MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
    retVal = invocation.proceed();  //沿着拦截器链执行
}

Class<?> returnType = method.getReturnType();
    if (retVal != null && retVal == target && returnType != Object.class && returnType.isInstance(proxy) && !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
        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);
    }

    Object var12 = retVal;
    return var12;
}

public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, @Nullable Class<?> targetClass) {
    AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance(); //获取默认的全局注册器
    Advisor[] advisors = config.getAdvisors();
    List<Object> interceptorList = new ArrayList(advisors.length); //拦截器列表
    Class<?> actualClass = targetClass != null ? targetClass : method.getDeclaringClass(); //目标类
    Boolean hasIntroductions = null; 
    Advisor[] var9 = advisors;
    int var10 = advisors.length;

for(int var11 = 0; var11 < var10; ++var11) {
    Advisor advisor = var9[var11]; //遍历通知器
    if (advisor instanceof PointcutAdvisor) { //如果是切点：包含advice
        PointcutAdvisor pointcutAdvisor = (PointcutAdvisor)advisor;
        if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) { //获取类描述匹配目标类的话
            MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher(); //方法匹配
            boolean match;
            if (mm instanceof IntroductionAwareMethodMatcher) {
                if (hasIntroductions == null) {
                    hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
                }

match = ((IntroductionAwareMethodMatcher)mm).matches(method, actualClass, hasIntroductions);
} else {
    match = mm.matches(method, actualClass);
}

if (match) {
    MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
    if (mm.isRuntime()) {
        MethodInterceptor[] var17 = interceptors;
        int var18 = interceptors.length;

for(int var19 = 0; var19 < var18; ++var19) {
                MethodInterceptor interceptor = var17[var19];
                interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
            }
        } else {
            interceptorList.addAll(Arrays.asList(interceptors));
        }
    }
}

} else if (advisor instanceof IntroductionAdvisor) {
    IntroductionAdvisor ia = (IntroductionAdvisor)advisor;
    if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
        Interceptor[] interceptors = registry.getInterceptors(advisor);
        interceptorList.addAll(Arrays.asList(interceptors));
    }

} else {
            Interceptor[] interceptors = registry.getInterceptors(advisor);
            interceptorList.addAll(Arrays.asList(interceptors));
        }
    }

    return interceptorList;
}