drhrht

SpringAOP学习--SpringAOP简介及原理

前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。
Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。
前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。

JDK动态代理回顾

上一篇简单介绍了JDK动态代理如何使用，我们就以此展开SpringAOP原理，和我们自己手写JDK动态代理有何不同！

JDK动态代理使用需要定义一个代理实例的调用拦截处理器InvocationHandler，反射执行目标方法，之前前后可以加入一些额外的代码实现增强。

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

实现类
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // before do something;
    Object result = method.invoke(word, args);
    // after do something;
    return result;
}

然后和原对象一起可以生成一个代理对象。

Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, invocationHandler)

然后就可以用代理对象替换原对象，执行原对象操作实现代理切面处理。

这里其实还有些点没有细化：

如果当前类有三个方法，只需要对其中一个进行切面，那么我们就需要在invoke方法中对方法判断，不是目标方法就不需要增强而是直接反射执行。
一个类需要进行多次切面，如何有效组织多个切面。

SpringAOP介绍

为了标准化AOP，Spring引入了一套AOP顶级API-- AOP联盟，用来定义和使用AOP。
底层根据配置生成JDK或CGLIB动态代理对象。

AOP联盟

AOP联盟，一群热爱技术的人觉得AOP思想不错，于是打算促进和标准化AOP，定制了一套标准，推动AOP和JAVA发展。
那么AOP联盟的标准是什么呢？
spring-aop jar包中有个目录org.aopalliance，其中存在几个接口，即是AOP联盟提供的AOP标准API。

SpringAOP核心概念

上述中已经出现的关键词有Advice(顶级的通知类/拦截器)、MethodInvocation(方法连接点)、MethodInterceptor(方法拦截器)
SpringAOP在此基础上又增加了几个类，丰富了AOP定义及使用概念，包括

Advisor：包含通知(拦截器)，Spring内部使用的AOP顶级接口，还需要包含一个aop适用判断的过滤器，考虑到通用性，过滤规则由其子接口定义，例如IntroductionAdvisor和PointcutAdvisor，过滤器用于判断bean是否需要被代理

Pointcut: 切点，属于过滤器的一种实现，匹配过滤哪些类哪些方法需要被切面处理，包含一个ClassFilter和一个MethodMatcher，使用PointcutAdvisor定义时需要

ClassFilter：限制切入点或引入点与给定目标类集的匹配的筛选器，属于过滤器的一种实现。过滤筛选合适的类，有些类不需要被处理

MethodMatcher：方法匹配器，定义方法匹配规则，属于过滤器的一种实现，哪些方法需要使用AOP

SpringAOP实现的大致思路：
1.配置获取Advisor (顾问)：拦截器+AOP匹配过滤器，生成Advisor
2.生成代理：根据Advisor生成代理对象，会生成JdkDynamicAopProxy或CglibAopProxy
3.执行代理：代理类执行代理时，从Advisor取出拦截器，生成MethodInvocation(连接点)并执行代理过程

SpringAOP与AOP联盟关系

配置Advisor

这一步对SpringAOP使用者很关键，决定了我们如何定义配置Advisor，即SpringAOP和Aspectj，实际使用配置AOP方式有多种，还区分xml和注解，最终转化处理时我认为只分为这两种。其中Aspectj方式配置AOP应该是最常见应用最广泛的用法了。

前面提到Aspectj是一种静态代理，而SpringAOP是动态代理。但Aspectj的一套定义AOP的API非常好，直观易用。所以Spring引入了Aspectj，但只使用部分注解用来定义配置AOP，在获取Advisor阶段用来生成Advisor，与后面的代理生成和代理增强执行无关！

这两种方式有什么不同呢？

1.直接配置Advisor
实现Advisor接口，定义拦截器和拦截规则(切点)
2.间接配置Advisor
使用Aspectj jar包提供的注解定义AOP配置，由Spring解析配置生成Advisor

下面以一个DEMO看看分别如何配置，为了方便展示，直接使用SpringBoot项目配置，暂时忽略复杂的细节只关注核心配置。
示例全部采用注解方式，不使用XML配置方式

直接配置Advisor

最少需要定义三个类，一个Advisor的实现类，一个Advice实现类（拦截器），一个aop适配过滤器(这里使用的Advisor为派生的PointcutAdvisor ，需要定义PointCut切点)。可以增加一个注解用于AOP埋点，需要给bean哪个方法进行切面，则方法上加上该注解。
Advisor：MyAdvisor，返回一个Advice，
Advice：MyInterceptAdvice，拦截器，invoke方法中可以添加切面逻辑代码
PointCut: MyPointCut，切点，匹配过滤出需要切面的类及方法，查找方法头注解了MyAnnotation的方法。
埋点注解：MyAnnotation

MyAdvisor.java

@Component
public class MyAdvisor implements PointcutAdvisor {

    @Override
    public Advice getAdvice() {
        return new MyInterceptAdvice();
    }

    @Override
    public boolean isPerInstance() {
        return false;
    }

    @Override
    public Pointcut getPointcut() {
        return new MyPointCut();
    }
}

MyInterceptAdvice.java

public class MyInterceptAdvice implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("go go go MyAdvisor process!!!");
        return invocation.proceed();
    }
}

MyPointCut.java

public class MyPointCut implements Pointcut {

    @Override
    public ClassFilter getClassFilter() {
        return new MyClassFilter();
    }

    @Override
    public MethodMatcher getMethodMatcher() {
        return new MyMethodMatcher();
    }

    private class MyMethodMatcher implements MethodMatcher {
        @Override
        public boolean matches(Method method, Class targetClass) {
            Annotation[] annoArray = method.getDeclaredAnnotations();
            if (annoArray == null || annoArray.length == 0) {
                return false;
            }

            for (Annotation annotation : annoArray) {
                if (annotation.annotationType() == MyAnnotation.class) {
                    return true;
                }
            }
            return false;
        }

        @Override
        public boolean isRuntime() {
            return false;
        }

        @Override
        public boolean matches(Method method, Class targetClass, Object... args) {
            return false;
        }
    }

    private class MyClassFilter implements ClassFilter {

        @Override
        public boolean matches(Class clazz) {
            return AnnotationUtils.isCandidateClass(clazz, MyAnnotation.class);
        }
    }
}

需要切面的Service类

@Component
public class TestService {

    @MyAnnotation
    public void test() {
        System.out.println("test!");
    }
}

再定义一个测试类

@Component
public class RunTest {

    @Autowired
    private TestService testService;

    @PostConstruct
    public void test() {
        testService.test();
    }
}

运行结果：

可以看到除了执行test内容，还执行到了拦截器中的代码，说明这种方式配置AOP生效了。

使用Aspectj间接配置Advisor

一个类就可以了，定义切点和增强方法

@Aspect
@Component
public class AopConfig {

    @Pointcut("execution(* cn.nec.aop.cnnecaop.service.*.*(..))")
    public void pointCut() {}
    public static void main(String[] args) {
        List aa = Collections.singletonList("aa");
        System.out.println(aa.size());

    }

    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoin) {
        System.out.println("go go go MyAspectJ process!!!");
        Object obj = null;
        try {
            obj = joinPoin.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }

        return obj;
    }
}

运行结果：

SpringAOP原理

上面介绍了SpringAOP并简单展示了如何使用，下面来看看SpringAOP原理，内部是如何实现的！

AOP入口

SpringAOP是对bean的一种扩展，是后处理器的一种处理。Spring bean在执行初始化方法前后，会使用所有BeanPostProcessor对bean进行特殊处理。Aop代理即是一种对bean特殊处理。

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction