spring aop 原理

• Advisor
• Advice
• PointcutAdvisor
• IntroductionAdvisor
• Pointcut
• ClassFilter
• MethodInterceptor
• internalAutoProxyCreator
• ProxyCreator

如果你理解了上面的类，那么aop 也就理解了

一个Advisor 【接口】 有1个Advice

Advice是什么

MethodInterceptor继承与Advice（advice 空接口） ，相当与一个 InvocationHandler ,都有一个 invoke 方法 ，包含一个代理方法 ，且执行代理

PointcutAdvisor，IntroductionAdvisor 继承与 Advisor ，

使用不同的逻辑 用于 匹配 类或方法是否能用于代理 ，必须继承
pointcutadvisor 的 getPointcut() 方法 ，返回一些 匹配器

MethodInterceptor

继承于 Advice ，提供advice 执行代理的方法 invoke 【advice 空接口】

internalAutoProxyCreator

BeanPostProcessor , 用于获取 Advisor
1、不同的internalAutoProxyCreator 获取方式不同 ，如 事务 【如果没有定义AspectJ，有使用aop的】，
2、所有的internalAutoProxyCreator 先从容器获取Advisor
3、Aop 可以 遍历@AspectJ 接口的类 ，并解析成 Advisor

ProxyCreator

用于创建Proxy ，spring 有一个ProxyFactory ，所有代理的实现逻辑

aop代理方法 调用

advice 按照顺序 ，递归调用 ，invoke 方法 ，记住是递归，所谓 before 和after ，无非就是排序后 ，在调用 下一个 【最后一个调用方法】advice 的方法 前后 执行的逻辑，
比如：
before 在 递归前 执行 ，after 在递归后执行，所以 并不需要 纠结于顺序，
通过 实现Advisor 和 Advice ，可以自己实现自定义代理

简单案例

@Component
public class MyAdvice implements MethodInterceptor {
  //执行代理逻辑
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("前置代理");
       Object o=  methodInvocation.proceed();
        System.out.println("后置代理");
        return o;
    }
}

@Component
public class MyAdvisor implements PointcutAdvisor {
    @Autowired
    Advice myAdvice;
    @Override
    // 用于 匹配 具体的类 或方法
    public Pointcut getPointcut() {
        return  new Pointcut() {
            @Override
            public ClassFilter getClassFilter() {
                return new ClassFilter() {
                    @Override
                    public boolean matches(Class aClass) {
                        if(aClass.getSimpleName().equals("UserImp"))
                        return true;
                        return false;
                    }
                };
            }

            @Override
            public MethodMatcher getMethodMatcher() {
                return new MethodMatcher() {
                    @Override
                    public boolean matches(Method method, Class aClass) {
                        if(aClass.getSimpleName().equals("UserImp"))
                            return true;
                        return false;
                    }

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

                    @Override
                    public boolean matches(Method method, Class aClass, Object[] objects) {
                        if(aClass.getSimpleName().equals("UserImp"))
                            return true;
                        return false;
                    }
                };
            }
        };
    }

    @Override
    public Advice getAdvice() {
        return this.myAdvice;
    }

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

前置代理
pointcut
后置代理