spring（五）：AOP

AOP（Aspect Oriented Programming）

面向切面编程，是一种编程范式，提供从另一个角度来考虑程序结构从而完善面向对象编程(OOP)。

在进行OOP开发时，都是基于对组件（比如类）进行开发，然后对组件进行组合，OOP最大问题就是无法解耦组件进行开发。

AOP为开发者提供一种进行横切关注点（比如日志关注点横切了支付关注点）分离并织入的机制，把横切关注点分离，然后通过某种技术织入到系统中，从而无耦合的完成了我们的功能。

横切关注点可能包含很多，比如非业务的：日志、事务处理、缓存、性能统计、权限控制等；还可能是业务的：如某个业务组件横切于多个模块。

基本概念

连接点（Jointpoint）：表示需要在程序中插入横切关注点的扩展点，连接点可能是类初始化、方法执行、方法调用、字段调用或处理异常等，Spring只支持方法执行连接点；“在哪里干”；
切入点（Pointcut）：选择一组相关连接点的模式，即可以认为连接点的集合，Spring默认使用AspectJ语法；“在哪里干的集合”；[ <aop:aspectj-autoproxy/> 开启spring对@Aspectj的支持]
通知（Advice）：在连接点上执行的行为；“干什么”；
引入/内部类型声明（inter-type declaration）：为已有的类添加额外新的字段或方法，Spring允许引入新的接口（必须对应一个实现）到所有被代理对象（目标对象）；“干什么（引入什么）”；
切面（Aspect）：横切关注点的模块化，比如日志组件。可以认为是通知、引入和切入点的组合，在Spring中可以使用Schema和@AspectJ方式进行组织实现；“在哪干和干什么集合”；
目标对象（Target Object）：需要被织入横切关注点的对象，被代理对象；“对谁干”；
织入（Weaving）：织入是一个过程，是将切面应用到目标对象从而创建出AOP代理对象的过程，织入可以在编译期、类装载期、运行期进行。
- 编译时织入，生成完整功能的Java字节码，需特殊编译器（AspectJ）
- 类加载时织入，AspectJ、AspectWerkz
- 运行时织入，动态代理。@EnableAspectJAutoProxy。[Spring采用运行时]
AOP代理（AOP Proxy）：AOP框架使用代理模式创建的对象，从而实现在连接点处插入通知，就是通过代理来对目标对象应用切面。

What-@Aspect

Where-@Pointcut

When-@Advice(@Before、@After、@AfterReturning、@AfterThrowing、@Around)

在Spring中通过代理模式实现AOP，并通过拦截器模式以环绕连接点的拦截器链织入通知（即应用切面）

通知类型

前置通知（Before Advice）:在切入点选择的连接点处的方法之前执行的通知，该通知不影响正常程序执行流程（除非该通知抛出异常，该异常将中断当前方法链的执行而返回）。
后置通知（After Advice）:在切入点选择的连接点处的方法之后执行的通知，包括如下类型的后置通知：
- 后置返回通知（After returning Advice）:在切入点选择的连接点处的方法正常执行完毕时执行的通知，必须是连接点处的方法没抛出任何异常正常返回时才调用后置通知。
- 后置异常通知（After throwing Advice）: 在切入点选择的连接点处的方法抛出异常返回时执行的通知，必须是连接点处的方法抛出任何异常返回时才调用异常通知。
- 后置最终通知（After finally Advice）: 在切入点选择的连接点处的方法返回时执行的通知，不管抛没抛出异常都执行，类似于Java中的finally块。
环绕通知（Around Advices）：环绕着在切入点选择的连接点处的方法所执行的通知，环绕通知可以在方法调用之前和之后自定义任何行为，并且可以决定是否执行连接点处的方法、替换返回值、抛出异常等等。

通知顺序

Spring中可以通过在切面实现类上实现org.springframework.core.Ordered接口或使用Order注解来指定切面优先级。在多个切面中，Ordered.getValue()方法返回值（或者注解值）较小值的那个切面拥有较高优先级。

@Order(2)

动态代理

如果目标对象实现了接口，默认使用JDK，可以强制用CGLIB；否则，采用CGLIB。

JDK动态代理

只能为接口创建动态代理实例，而不能针对类。

使用java.lang.reflect.Proxy动态代理实现，通过调用目标类的getClass().getInterfaces()方法获取目标对象的接口信息，并生成一个实现了代理接口的动态代理class，然后通过反射技术获得该class的构造函数，并利用构造函数生成实例，在调用具体方法前调用InvocationHandler处理。

在Proxy这个类当中首先实例化一个对象ProxyClassFactory,然后在get方法中调用了apply方法,完成对代理类的创建：

generateProxyClass通过反射收集字段和属性然后生成字节
defineClass0 jvm内部完成对上述字节的load

CGLIB动态代理

主要是对指定的类生成一个子类，覆盖其中的方法。（不能通知final方法）

利用asm开源包，采用字节码技术，为一个类创建子类，在子类中采用方法拦截（MethodInterceptor @override intercept()），拦截所有父类方法的调用，顺势织入横切逻辑。

会产生两次构造器调用，第一次是目标类的构造器调用，第二次是CGLIB生成的代理类的构造器调用。

设计分析

1 为目标对象建立AopProxy代理对象

在依赖注入时，实例化bean后都会调用getObjectForBeanInstance方法，这里就是处理FactoryBean的入口。

通过配置和调用ProxyFactoryBean来完成代理对象的创建。

配置通知器advisor、proxyFactoryBean（目标对象target、interceptorNames拦截器数组、目标对象接口数组）

// ProxyFactoryBean

	@Nullable

    public Object getObject() throws BeansException {

        // 对通知器链进行初始化

        // 通知器链封装了一系列的拦截器（需要从配置中读取）

        // 然后为代理对象的生成做准备

        this.initializeAdvisorChain();

        // 区分两种类型的Bean

        if (this.isSingleton()) {

            return this.getSingletonInstance();

        } else {

            ...

            return this.newPrototypeInstance();

        }

    }

    private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {

        // 通知器链未初始化（初始化工作发生在应用第一次通过ProxyFactoryBean获取代理对象的时候）

        if (!this.advisorChainInitialized) {

            if (!ObjectUtils.isEmpty(this.interceptorNames)) {

                ...

                String[] var1 = this.interceptorNames;

                int var2 = var1.length;

                for(int var3 = 0; var3 < var2; ++var3) {

                    String name = var1[var3];

                    ...

                    if (name.endsWith("*")) {

                        ...

                    } else {

                        Object advice;

                        if (!this.singleton && !this.beanFactory.isSingleton(name)) {

                            // Prototype类型

                            advice = new ProxyFactoryBean.PrototypePlaceholderAdvisor(name);

                        } else {

                            // singleton类型：通过getBean获取通知器

                            advice = this.beanFactory.getBean(name);

                        }

						// 将通知器加入拦截器链中

                        this.addAdvisorOnChainCreation(advice, name);

                    }

                }

            }

            this.advisorChainInitialized = true;

        }

    }

    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();

                ...

                // 设置代理对象调用接口

                this.setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));

            }

            super.setFrozen(this.freezeProxy);

            // createAopProxy：生成aop代理对象 ★调用父类的createAopProxy()

            // getProxy：<<AopProxy>>接口的两种实现--JdkDynamicAopProxy、CglibAopProxy

            this.singletonInstance = this.getProxy(this.createAopProxy());

        }

        return this.singletonInstance;

    }

    private synchronized Object newPrototypeInstance() {

        ...

        ProxyCreatorSupport copy = new ProxyCreatorSupport(this.getAopProxyFactory());

        TargetSource targetSource = this.freshTargetSource();

        copy.copyConfigurationFrom(this, targetSource, this.freshAdvisorChain());

        if (this.autodetectInterfaces && this.getProxiedInterfaces().length == 0 && !this.isProxyTargetClass()) {

            // 和上面一模一样的套路啊。。。

            Class<?> targetClass = targetSource.getTargetClass();

            if (targetClass != null) {

                copy.setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));

            }

        }

        ...

        // 然后通过<<AopProxy>>接口的两种实现--JdkDynamicAopProxy、CglibAopProxy获取代理对象

        return this.getProxy(copy.createAopProxy());

    }

// ProxyCreatorSupport

    protected final synchronized AopProxy createAopProxy() {

        if (!this.active) {

            this.activate();

        }

        // createAopProxy：<<AopProxyFactory>>接口的方法

        return this.getAopProxyFactory().createAopProxy(this);

    }

// 具体实现：DefaultAopProxyFactory

    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {

        // 如果目标对象是接口类，使用jdk

        if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {

            return new JdkDynamicAopProxy(config);

        } else {

            Class<?> targetClass = config.getTargetClass();

            if (targetClass == null) {

                ...

            } else {

                // ObjenesisCglibAopProxy extends CglibAopProxy

                return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));

            }

        }

        // new的过程都是先从AdvisedSupport对象中取得配置的目标对象进行检查

    }

// JdkDynamicAopProxy

    public Object getProxy(@Nullable ClassLoader classLoader) {

        ...

        // 首先从advised对象中获取代理对象的代理接口配置

        Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);

        this.findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);

        // 然后调用Proxy的newProxyInstance方法得到Proxy代理对象

        // 需要三个参数：类加载器、代理接口、回调方法所在对象

        // 回调方法用的是InvokeHandler的invoke回调入口

        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);

    }

// CglibAopProxy

    public Object getProxy(@Nullable ClassLoader classLoader) {

        ...

        try {

            // 从advised对象中获取配置的target对象

            Class<?> rootClass = this.advised.getTargetClass();

            ...

            Class<?> proxySuperClass = rootClass;

            int x;

            if (ClassUtils.isCglibProxyClass(rootClass)) {

                proxySuperClass = rootClass.getSuperclass();

                Class<?>[] additionalInterfaces = rootClass.getInterfaces();

                Class[] var5 = additionalInterfaces;

                int var6 = additionalInterfaces.length;

                for(x = 0; x < var6; ++x) {

                    Class<?> additionalInterface = var5[x];

                    this.advised.addInterface(additionalInterface);

                }

            }

			// 验证代理对象的接口设置

            this.validateClassIfNecessary(proxySuperClass, classLoader);

            // 创建并配置cglib的enhancer

            Enhancer enhancer = this.createEnhancer();

            if (classLoader != null) {

                enhancer.setClassLoader(classLoader);

                if (classLoader instanceof SmartClassLoader && ((SmartClassLoader)classLoader).isClassReloadable(proxySuperClass)) {

                    enhancer.setUseCache(false);

                }

            }

            // 设置enhancer的代理接口、回调方法等

            enhancer.setSuperclass(proxySuperClass);

            enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));

            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);

            enhancer.setStrategy(new CglibAopProxy.ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));

            Callback[] callbacks = this.getCallbacks(rootClass);

            Class<?>[] types = new Class[callbacks.length];

            for(x = 0; x < types.length; ++x) {

                types[x] = callbacks[x].getClass();

            }

            enhancer.setCallbackFilter(new CglibAopProxy.ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));

            enhancer.setCallbackTypes(types);

            // 通过enhancer生成代理对象 ★

            // 注意这里有回调

            return this.createProxyClassAndInstance(enhancer, callbacks);

        }...

    }

	// 这里是回调方法，通过设置DynamicAdvisedInterceptor拦截器完成AOP功能

    private Callback[] getCallbacks(Class<?> rootClass) throws Exception {

        ...

        Callback aopInterceptor = new CglibAopProxy.DynamicAdvisedInterceptor(this.advised);

        ...

        return callbacks;

    }

2 启动代理对象的拦截器来完成各种横切面的织入

在第一步的过程中，拦截器已经配置到代理对象中，它是通过回调方法起作用。

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;

        Boolean var8;

        try {

            if (this.equalsDefined || !AopUtils.isEqualsMethod(method)) {

                ...

				// 得到目标对象

                target = targetSource.getTarget();

                Class<?> targetClass = target != null ? target.getClass() : null;

                // 这个方法对象注册了拦截器

                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

                // 没有设定拦截器链，直接调用target对象的方法

                if (chain.isEmpty()) {

                    Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);

                    // 对target对象的方法调用是通过反射机制，然后使用invoke调用方法反射对象

                    retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);

                } else {

                    // 拦截，通过ReflectiveMethodInvocation

                    MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);

                    // 沿着拦截器链继续前进

                    retVal = invocation.proceed();

                }

                ...

            }

            var8 = this.equals(args[0]);

        }...

        return var8;

    }

CglibAopProxy的DynamicAdvisedInterceptor的intercept拦截

        @Nullable

        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

            ...

            try {

                ...

                // 得到目标对象

                target = targetSource.getTarget();

                Class<?> targetClass = target != null ? target.getClass() : null;

                // 从advised取得配置好的AOP通知

                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

                Object retVal;

                // 若没有，则直接调用target对象的方法

                if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {

                    Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);

                    retVal = methodProxy.invoke(target, argsToUse);

                } else {

                    // 拦截，通过CglibMethodInvocation启动advice通知

                    // CglibMethodInvocation extends ReflectiveMethodInvocation

                    // 沿着拦截器链继续前进

                    retVal = (new CglibAopProxy.CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy)).proceed();

                }

                retVal = CglibAopProxy.processReturnType(proxy, target, method, retVal);

                var16 = retVal;

            }...

            return var16;

        }

综上，都是从advised取得拦截器链的。

拦截都是通过ReflectiveMethodInvocation的proceed方法实现的。

如何将拦截器链配置进advised的？

拦截器是ReflectiveMethodInvocation类中一个名为interceptorsAndDynamicMethodMatchers的List中的元素。

this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

advised的getInterceptorsAndDynamicInterceptionAdvice是由advisorChainFactory实现的，它的具体类型是DefaultAdvisorChainFactory。

DefaultAdvisorChainFactory通过AdvisorAdapterRegistry来适配ProxyFactoryBean中得到的通知器，注册拦截器。

在ProxyFactoryBean的getObject方法中对advisor进行初始化时，从配置中获取了通知器。（通过实现BeanFactoryAware接口，设置回调方法委托给IoC容器）

proceed方法

    @Nullable

    public Object proceed() throws Throwable {

        // 如果已经到拦截器链的末尾，直接调用目标对象的方法

        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {

            return this.invokeJoinpoint();

        } else {

            // 否则，得到下一个拦截器

            Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);

            // 通过拦截器进行matches判断是否适用于横切增强的场合

            if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {

                InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher)interceptorOrInterceptionAdvice;

                Class<?> targetClass = this.targetClass != null ? this.targetClass : this.method.getDeclaringClass();

                // 如果是，从拦截器得到通知器，并启动invoke方法

                // 否则，迭代调用proceed方法

                return dm.methodMatcher.matches(this.method, targetClass, this.arguments) ? dm.interceptor.invoke(this) : this.proceed();

            } else {

                return ((MethodInterceptor)interceptorOrInterceptionAdvice).invoke(this);

            }

        }

    }

advice通知是如何实现的？