第十八章 Spring之假如让你来写AOP——Advice（通知）下篇-CSDN博客

本文链接：https://blog.csdn.net/weixin_42789334/article/details/143516149

Spring源码阅读目录

第一部分——IOC篇

第一章 Spring之最熟悉的陌生人——IOC
第二章 Spring之假如让你来写IOC容器——加载资源篇
第三章 Spring之假如让你来写IOC容器——解析配置文件篇
第四章 Spring之假如让你来写IOC容器——XML配置文件篇
第五章 Spring之假如让你来写IOC容器——BeanFactory和FactoryBean
第六章 Spring之假如让你来写IOC容器——Scope和属性填充
第七章 Spring之假如让你来写IOC容器——属性填充特别篇：SpEL表达式
第八章 Spring之假如让你来写IOC容器——拓展篇
第九章 Spring之源码阅读——环境搭建篇
第十章 Spring之源码阅读——IOC篇

第二部分——AOP篇

第三部分——事务篇

第二十五章 Spring之曾经的老朋友——事务
第二十六章 Spring之假如让你来写事务——初稿篇
第二十七章 Spring之假如让你来写事务——铁三角篇
第二十八章 Spring之假如让你来写事务——属性篇
第二十九章 Spring之假如让你来写事务——状态篇
第三十章 Spring之假如让你来写事务——管理篇
第三十一章 Spring之假如让你来写事务——融入IOC容器篇
第三十二章 Spring之源码阅读——事务篇

第四部分——MVC篇

第五部分——Boot篇

文章目录

Spring源码阅读目录
前言
尝试动手写IOC容器
- - 第十九版（下） Advice（通知）
  - - - Joinpoint参数
        
        Advice（通知）支持参数
        
        环绕通知
        
        异常通知
        
        引介通知
        
        又是AOP联盟，又是AspectJ，转来转去真烦
总结

前言

对于Spring一直都是既熟悉又陌生，说对它熟悉吧，平时用用没啥问题，但面试的时候被问的一脸懵逼，就很尴尬，都不好意思在简历上写着熟悉Spring了
在这里插入图片描述

所以决定花点时间研究研究Spring的源码。主要参考的书籍是：《Spring源码深度解析（第2版）》、《Spring揭秘》、《Spring技术内幕：深入解析Spring架构与设计原理（第2版）》

书接上回，在上篇 第十七章 Spring之假如让你来写AOP——Advice（通知）上篇 中，A君已经实现了 Advice（通知） 参数匹配器，只不过现在还没有整合到 Advice（通知） 里边去。接下来看看 A君会有什么骚操作吧

尝试动手写IOC容器

出场人物：A君（苦逼的开发）、老大（项目经理）

背景：老大要求A君在一周内开发个简单的 IOC容器

前情提要： A君已经实现了 Advice（通知） 参数匹配器，还没有整合到 Advice（通知） 里边去。。。

第十九版（下） Advice（通知）

Joinpoint参数

昨天 A君才把参数匹配器折腾完，吃饭都不安生，满脑子都是后续要怎么实现。首先第一个出现的拦路虎就是：无论是Joinpoint、还是returning、throwing，这些参数从哪里来？返回值、异常不是所有通知都有的，可以由各自的通知。Joinpoint这个需要由框架提供，这个参数包含了方法运行的信息

正当 A君准备从Joinpoint参数入手时，忽然又发现一个问题：Joinpoint有两个。“@#￥%……&” 这让 A君一阵骂街。为什么会有两个？原因很简单 AspectJ 并没有按 AOP联盟 的来。没办法，只能适配了。可问题又来了：要用哪个？经过一番考量，A君决定用 AspectJ 的，因为 AspectJ 提供的方法更全面，而 AOP 联盟把这些功能分的很细。设计原则之一：最少知道原则。嘿嘿。A君定义 MethodInvocationProceedingJoinPoint 类，实现 AspectJ 相关接口，代码如下：

import com.hqd.ch03.v19.aop.ProxyMethodInvocation;
import com.hqd.ch03.v19.core.DefaultParameterNameDiscoverer;
import com.hqd.ch03.v19.core.ParameterNameDiscoverer;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.reflect.MethodSignature;
import org.aspectj.lang.reflect.SourceLocation;
import org.aspectj.runtime.internal.AroundClosure;

import java.lang.reflect.Method;

/**
 * 适配器，将aop联盟的joinpoint接口，包装成Aspectj接口
 */
public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint, JoinPoint.StaticPart {
   
    private static final ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();

    private final ProxyMethodInvocation methodInvocation;
    private Object[] args;

    private Signature signature;


    private SourceLocation sourceLocation;

    public MethodInvocationProceedingJoinPoint(ProxyMethodInvocation methodInvocation) {
   
        this.methodInvocation = methodInvocation;
    }

    @Override
    public int getId() {
   
        return 0;
    }

    @Override
    public void set$AroundClosure(AroundClosure arc) {
   
        throw new UnsupportedOperationException();
    }

    @Override
    public Object proceed() throws Throwable {
   
        return this.methodInvocation.invocableClone().proceed();
    }

    @Override
    public Object proceed(Object[] args) throws Throwable {
   
        this.methodInvocation.setArguments(args);
        return this.methodInvocation.invocableClone(args).proceed();
    }

    @Override
    public String toShortString() {
   
        return "execution(" + getSignature().toShortString() + ")";
    }

    @Override
    public String toLongString() {
   
        return "execution(" + getSignature().toLongString() + ")";
    }

    @Override
    public String toString() {
   
        return "execution(" + getSignature().toString() + ")";
    }

    /**
     * 此处返回代理类
     *
     * @return
     */
    @Override
    public Object getThis() {
   
        return this.methodInvocation.getProxy();
    }

    @Override
    public Object getTarget() {
   
        return this.methodInvocation.getThis();
    }

    @Override
    public Object[] getArgs() {
   
        if (args == null) {
   
            this.args = this.methodInvocation.getArguments().clone();
        }
        return this.args;
    }

    @Override
    public Signature getSignature() {
   
        if (this.signature == null) {
   
            this.signature = new MethodSignatureImpl();
        }
        return this.signature;
    }

    @Override
    public SourceLocation getSourceLocation() {
   
        if (this.sourceLocation == null) {
   
            this.sourceLocation = new SourceLocationImpl();
        }
        return this.sourceLocation;
    }

    @Override
    public String getKind() {
   
        return ProceedingJoinPoint.METHOD_EXECUTION;
    }

    @Override
    public StaticPart getStaticPart() {
   
        return this;
    }


    private class SourceLocationImpl implements SourceLocation {
   

        @Override
        public Class getWithinType() {
   
            return methodInvocation.getThis().getClass();
        }

        @Override
        public String getFileName() {
   
            throw new UnsupportedOperationException();
        }

        @Override
        public int getLine() {
   
            throw new UnsupportedOperationException();
        }

        @Override
        public int getColumn() {
   
            throw new UnsupportedOperationException();
        }
    }

    private class MethodSignatureImpl implements MethodSignature {
   
        private String[] parameterNames;
        private Method method = methodInvocation.getMethod();

        @Override
        public Class getReturnType() {
   
            return method.getReturnType();
        }

        @Override
        public Method getMethod() {
   
            return method;
        }

        @Override
        public Class[] getParameterTypes() {
   
            return method.getParameterTypes();
        }

        @Override
        public String[] getParameterNames() {
   
            if (parameterNames == null) {
   
                this.parameterNames = parameterNameDiscoverer.getParameterNames(method);
            }
            return this.parameterNames;
        }

        @Override
        public Class[] getExceptionTypes() {
   
            return method.getExceptionTypes();
        }

        @Override
        public String toShortString() {
   
            return "";
        }

        @Override
        public String toLongString() {
   
            return "";
        }

        @Override
        public String getName() {
   
            return method.getName();
        }

        @Override
        public int getModifiers() {
   
            return method.getModifiers();
        }

        @Override
        public Class getDeclaringType() {
   
            return method.getDeclaringClass();
        }

        @Override
        public String getDeclaringTypeName() {
   
            return getDeclaringType().getTypeName();
        }
    }
}

整个类没有什么出彩的地方，实际上调用都是由 ProxyMethodInvocation 提供。解决完Joinpoint参数适配问题，接下来的问题就是怎么获取到这个参数？直接new吗？如果同一个目标方法，多个通知，每个通知都new一个吗？想到这里，就算是 A君也察觉出来不妥之处，同一个目标方法，无论有多少个通知，他们的Joinpoint应该是一样的，这就涉及到共享变量了。A君想起了之前的 ThreadLocal，这不正好可以解决共享变量的问题了吗？共享变量问题解决了，但是要放哪里才能保证每个通知都能获得到？问题还真是一个接着一个呢。A君不经一阵挠头，想要整个调用链都能获取的到，只能放在最开始的地方，也就是链表头部，并且优先级最高，只有这样才能保证后续的节点能访问的到。那问题就简单，A君定一个拦截器，让他的优先级最高，ExposeInvocationInterceptor 代码如下：

import com.hqd.ch03.v19.aopalliance.intercept.MethodInterceptor;
import com.hqd.ch03.v19.aopalliance.intercept.MethodInvocation;
import com.hqd.ch03.v19.core.Ordered;
import com.hqd.ch03.v19.thread.NamedThreadLocal;

/**
 * 默认拦截器
 * 优先级最高
 */
public class ExposeInvocationInterceptor implements MethodInterceptor, Ordered {
   
    public static final