深入分析 Spring AOP 的实现原理

 2022-09-01
原文地址:https://blog.51cto.com/u_15651175/5558758

202209012340464521.png

Spring AOP概述

本节我们先对Spring AOP有一个整体的认识,后面我会用3节对一些细节性的内容进行介绍

AOP这种设计理念常见的概念如下 (建议仔细看一下,因为我发现有很多博文把这几个概念解释的很乱,其实很简单)

202209012340482432.png

AOP的主要应用场景如下

202209012340494493.png

Spring AOP的实现主要经历了2代

第一代:spring1.x版本,自己实现了AOP的功能
第二代:spring2.x版本,Spring集成了AspectJ的实现

Spring AOP一代

当我们要基于现成的实现增加横切逻辑时,首先需要找到哪些地方增强,我们就用Pointcut来进行筛选吧

先写一个Service方便后面的演示

    public interface EchoService {
    
        String echo(String message);
    }
    public class DefaultEchoService implements EchoService {
    
        @Override
        public String echo(String message) {
            return message;
        }
    }

Pointcut

Pointcut接口定义如下

    public interface Pointcut {
    
      // 通过类过滤
      ClassFilter getClassFilter();
    
      // 通过方法过滤
      MethodMatcher getMethodMatcher();
    
      Pointcut TRUE = TruePointcut.INSTANCE;
    
    }

当我们想筛选出EchoService的echo方法时,就可以定义如下的Pointcut

    public class EchoPointcut implements Pointcut {
    
        @Override
        public ClassFilter getClassFilter() {
            return new ClassFilter() {
                @Override
                public boolean matches(Class<?> clazz) {
                    return EchoService.class.isAssignableFrom(clazz);
                }
            };
        }
    
        @Override
        public MethodMatcher getMethodMatcher() {
            return new MethodMatcher() {
                @Override
                public boolean matches(Method method, Class<?> targetClass) {
                    return "echo".equals(method.getName()) &&
                            method.getParameterTypes().length == 1 &&
                            Objects.equals(String.class, method.getParameterTypes()[0]);
                }
    
                @Override
                public boolean isRuntime() {
                    return false;
                }
    
                @Override
                public boolean matches(Method method, Class<?> targetClass, Object... args) {
                    return false;
                }
            };
        }
    }

看起来还是很麻烦的,因此Spring内置了很多实现,一般情况下我们用内置的实现即可,不用自己定义,上面的筛选过程就可以改为如下

    // 方法名为 echo 会被拦截
    NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
    pointcut.setMappedName("echo");

Spring提供的部分Pointcut实现如下

202209012340507634.png

Jointpoint

通过Pointcut筛选出来的要增加横切逻辑的地方就是Jointpoint。 在AOP理念中,很多地方可以增加横切逻辑,如方法执行,字段设置等。但是 Spring只支持方法执行这一种Joinpoint ,因为这种类型的Jointpoint基本上已经满足80%的场景了

Joinpoint类型中 方法调用优于方法执行

202209012340519865.png

因为Spring中只支持方法执行这一种Joinpoint,所以我们可以从Joinpoint实现类中获取增强的方法信息

202209012340531326.png

Advice

当筛选出Jointpoint时,我们就需要在这些Jointpoint上增加横切逻辑,这些横切逻辑被称为Advice

202209012340542047.png

在Spring中实现横切逻辑的方式有两类

  1. 实现Advice接口
  2. 实现IntroductionInfo接口

实现Advice接口的方式我们最常用,后面会详细分析。实现IntroductionInfo接口的方式基本不会用,这里演示一下具体的用法,方便理解整个AOP API的设计理念

IntroductionInfo主要是通过给目标类实现特定接口来增加新功能

    public interface SayName {
    
        String getName();
    }
    public class DefaultSayName implements SayName {
    
        @Override
        public String getName() {
            return "I am service";
        }
    }
    public static void main(String[] args) {
        SayName sayName = new DefaultSayName();
        EchoService echoService = new DefaultEchoService();
        // IntroductionInfo接口的内置实现
        DelegatingIntroductionInterceptor interceptor =
                new DelegatingIntroductionInterceptor(sayName);
        Advisor advisor = new DefaultIntroductionAdvisor(interceptor, SayName.class);
        ProxyFactory proxyFactory = new ProxyFactory(echoService);
        proxyFactory.addAdvisor(advisor);
        // hello world
        EchoService proxyService = (EchoService) proxyFactory.getProxy();
        System.out.println(proxyService.echo("hello world"));
        // I am service
        SayName proxySayName = (SayName) proxyFactory.getProxy();
        System.out.println(proxySayName.getName());
    }

可能你对这个例子中的Advisor和ProxyFactory比较陌生,不知道起了啥作用,不着急,我们后面会详细分析这2个类的作用

实现Advice接口的方式,应该是Spring AOP一代中最常见的使用方式了

对HashMap的put方法增加执行前的横切逻辑 , 打印放入HashMap的key和value的值

    public static void main(String[] args) {
        JdkRegexpMethodPointcut pointcut = new JdkRegexpMethodPointcut();
        pointcut.setPattern(".*put.*");
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor();
        advisor.setPointcut(pointcut);
        advisor.setAdvice(new MethodBeforeAdvice() {
            @Override
            public void before(Method method, Object[] args, Object target) throws Throwable {
                System.out.printf("当前存放的key为 %s,值为 %s", args[0], args[1]);
            }
        });
    
        ProxyFactory proxyFactory = new ProxyFactory(new HashMap());
        proxyFactory.addAdvisor(advisor);
        Map<String, String> proxyMap = (Map<String, String>) proxyFactory.getProxy();
        // 当前存放的key为 a,值为 a
        proxyMap.put("a", "a");
    }

Advisor

前面我们说过在AOP设计理念中,我们用Aspect来声明切面,每个Aspect可以包含多个Pointcut和Advice。

在Spring AOP一代中,Aspect对应的实现为Advisor 。即Advisor是Pointcut和Advice的容器,但是一个Advisor只能包含一个Pointcut和Advice

202209012340552168.png

因为Advice的实现方式有两类,因此对应的Advisor也可以分为两类

织入

在Spring中将Advice织入到Jointpoint的过程是通过动态代理来实现的 。当然织入的方式有很多种,不仅仅只有动态代理这一种实现

202209012340562069.png

Spring用了jdk动态代理和cglib来实现动态代理。生成代理对象用了工厂模式。从api中就可以很清晰的看出来

2022090123405743210.png

jdk动态代理

    public class CostInvocationHandler implements InvocationHandler {
    
        private Object target;
    
        public CostInvocationHandler(Object target) {
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            long startTime = System.currentTimeMillis();
            Object result = method.invoke(target, args);
            long cost = System.currentTimeMillis() - startTime;
            System.out.println("cost " + cost);
            return result;
        }
    }
    public static void main(String[] args) {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        Object proxy = Proxy.newProxyInstance(classLoader,
                new Class[]{EchoService.class},
                new CostInvocationHandler(new DefaultEchoService()));
        EchoService echoService = (EchoService) proxy;
        // cost 0
        // hello world
        System.out.println(echoService.echo("hello world"));
    }

cglib

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(DefaultEchoService.class);
        enhancer.setInterfaces(new Class[] {EchoService.class});
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object source, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                long startTime = System.currentTimeMillis();
                Object result = methodProxy.invokeSuper(source, args);
                long cost = System.currentTimeMillis() - startTime;
                System.out.println("cost " + cost);
                return result;
            }
        });
        EchoService echoService = (EchoService) enhancer.create();
        // cost 29
        // hello world
        System.out.println(echoService.echo("hello world"));
    }

Spring AOP的自动动态代理

上面我们一直通过API的形式来演示,我们当然也可以把这些对象放入Spring容器,让Spring来管理,并且对Spring容器中的Bean生成代理对象

上面的Demo可以改为如下形式,变化基本不大

手动配置

    public class CostMethodInterceptor implements MethodInterceptor {
    
        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
            long startTime = System.currentTimeMillis();
            Object result = invocation.proceed();
            long cost = System.currentTimeMillis() - startTime;
            System.out.println("cost " + cost);
            return result;
        }
    }
    public class ProxyConfig {
    
        // 创建代理对象
        @Bean
        public EchoService echoService() {
            return new DefaultEchoService();
        }
    
        // 创建advice
        @Bean
        public CostMethodInterceptor costInterceptor() {
            return new CostMethodInterceptor();
        }
    
        // 使用pointcut和advice创建advisor
        @Bean
        public Advisor advisor() {
            NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor();
            advisor.setMappedName("echo");
            advisor.setAdvice(costInterceptor());
            return advisor;
        }
    
        // 创建代理对象
        @Bean("echoProxy")
        public ProxyFactoryBean proxyFactoryBean(EchoService echoService) {
            ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
            proxyFactoryBean.setTarget(echoService);
            proxyFactoryBean.setInterceptorNames("advisor");
            return proxyFactoryBean;
        }
    }
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProxyConfig.class);
        // 获取代理对象
        EchoService echoService = (EchoService) context.getBean("echoProxy");
        // cost 0
        // hello world
        System.out.println(echoService.echo("hello world"));
    }

可以看到我们对每个生成的代理对象都要配置对应的ProxyFactoryBean,然后从容器中获取代理对象来使用 。当代理对象很少时还能应付,当代理对象很多时,那还不得累到吐血。有没有什么简单的办法呢?

Spring肯定也想到了这个问题,所以他提供了如下一个类DefaultAdvisorAutoProxyCreator来实现自动代理,我们将这个类放入Spring容器即可,如下所示

自动配置

    public class AutoProxyConfig {
    
        // 创建代理对象
        @Bean
        public EchoService echoService() {
            return new DefaultEchoService();
        }
    
        // 创建advice
        @Bean
        public CostMethodInterceptor costInterceptor() {
            return new CostMethodInterceptor();
        }
    
        // 使用pointcut和advice创建advisor
        @Bean
        public Advisor advisor() {
            NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor();
            advisor.setMappedName("echo");
            advisor.setAdvice(costInterceptor());
            return advisor;
        }
    
        @Bean
        public DefaultAdvisorAutoProxyCreator autoProxyCreator() {
            return new DefaultAdvisorAutoProxyCreator();
        }
    }
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AutoProxyConfig.class);
        EchoService echoService = context.getBean(EchoService.class);
        // cost 0
        // hello world
        System.out.println(echoService.echo("hello world"));
    }

从容器中获取的对象直接就是被代理后的对象,非常方便。 Spring AOP提供了很多类来实现自动代理,但他们有一个共同的父类AbstractAutoProxyCreator,看来自动代理的秘密就在这个AbstractAutoProxyCreator类中

2022090123405847011.png

Spring AOP自动动态代理的实现方式

如果让你实现对象的自动代理,你会怎么做呢?

当然是通过BeanPostProcessor来干预Bean的声明周期,聪明!Spring就是这么干的,来验证一下我们的想法

2022090123405961712.png

看这个类的继承关系,基本上就验证了我们的想法了。我们只要看看他重写了BeanPostProcessor的哪些方法即可?

AbstractAutoProxyCreator重写了如下2个重要的方法

postProcessBeforeInstantiation(Bean实例化前阶段执行)

getEarlyBeanReference(Bean实例化后阶段执行)

postProcessAfterInitialization(Bean初始化后阶段执行)

2022090123410076013.png

我这里先简单总结一下,后续会对这3个阶段进行详细的分析

所以当面试官问你Spring AOP和IOC是如何结合在一起的时候,你是不是知道该如何回答了?

把这3个阶段干的事答出来不就行了

Spring AOP二代(集成了AspectJ)

当Spring 2.0发布以后,Spring AOP增加了新的使用方式,Spring AOP集成了AspectJ。我们最常用的就是这个版本的Spring AOP

主要有如下变化

  1. 可以用POJO来定义Aspect和Adivce,并提供了一系列相应的注解,如@Aspect和@Around等。而不用像1.x版本中实现相应的接口
  2. 支持aspectj中的pointcut的表达方式,我们都深有体会哈

2022090123410182114.png

演示一下2.0版本中aop的使用方式

定义切面

    @Aspect
    public class AspectDefine {
    
        @Pointcut("execution(* com.javashitang.proxy.EchoService.echo(..))")
        public void pointcutName() {}
    
        @Around("pointcutName()")
        public Object calCost(ProceedingJoinPoint joinPoint) throws Throwable {
            long startTime = System.currentTimeMillis();
            Object result = joinPoint.proceed();
            long cost = System.currentTimeMillis() - startTime;
            System.out.println("cost " + cost);
            return result;
        }
    
        @Before("pointcutName()")
        public void beforeMethod() {
            System.out.println("beforeMethod");
        }
    }

增加配置,注入实现类

    @EnableAspectJAutoProxy
    public class AspectJConfig {
    
        @Bean
        public EchoService echoService() {
            return new DefaultEchoService();
        }
    }
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(AspectJConfig.class, AspectDefine.class);
        EchoService echoService = context.getBean(EchoService.class);
        // beforeMethod
        // cost 0
        // hello world
        System.out.println(echoService.echo("hello world"));
        context.close();
    }

虽然spring2.0之后spring aop集成了AspectJ,但实际上只是拿AspectJ的“皮大衣“用了一下,因为底层的实现和织入方式还是1.x原先的实现体系

@EnableAspectJAutoProxy有啥用?

当我们想使用2.0版本的aop时,必须在配置类上加上@EnableAspectJAutoProxy注解,那么这个注解有啥作用呢?

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Import(AspectJAutoProxyRegistrar.class)
    public @interface EnableAspectJAutoProxy {
    
      boolean proxyTargetClass() default false;
    
      boolean exposeProxy() default false;
    
    }

可以看到很重要的一句

    @Import(AspectJAutoProxyRegistrar.class)

通过@Import注入bean, 通过@Import注解注入Bean的方式有如下三种

  1. 基于Configuration Class
  2. 基于ImportSelector接口
  3. 基于ImportBeanDefinitionRegistrar接口

2022090123410324215.png

这个代码主要做了2个事情

  1. 往容器中注入AnnotationAwareAspectJAutoProxyCreator
  2. 当@EnableAspectJAutoProxy注解中的proxyTargetClass或者exposeProxy属性为true的时候,将AnnotationAwareAspectJAutoProxyCreator中的proxyTargetClass或者exposeProxy属性改为true

proxyTargetClass和exposeProxy保存在AnnotationAwareAspectJAutoProxyCreator类的父类ProxyConfig中,这个类存了一些配置,用来控制代理对象的生成过程

proxyTargetClass:true使用CGLIB基于类创建代理;false使用java接口创建代理
exposeProxy:true将代理对象保存在AopContext中,否则不保存

第一个属性比较容易理解,那么第二个属性有啥作用呢?演示一下

    @Service
    public class SaveSevice {
    
        public void method1() {
            System.out.println("method1 executed");
            method2();
        }
    
        public void method2() {
            System.out.println("method2 executed");
        }
    }
    @Aspect
    public class AspectDefine {
    
        @Pointcut("execution(* com.javashitang.invalid.SaveSevice.method2(..))")
        public void pointcutName() {}
    
        @Around("pointcutName()")
        public Object calCost(ProceedingJoinPoint joinPoint) throws Throwable {
            System.out.println("开启事务");
            return joinPoint.proceed();
        }
    }
    @EnableAspectJAutoProxy
    public class InvalidDemo {
    
        public static void main(String[] args) {
            AnnotationConfigApplicationContext context =
                    new AnnotationConfigApplicationContext(SaveSevice.class,
                            AspectDefine.class, InvalidDemo.class);
            SaveSevice saveSevice = context.getBean(SaveSevice.class);
            saveSevice.method1();
            System.out.println("--");
            saveSevice.method2();
        }
    }

结果为

    method1 executed
    method2 executed
    --

可以看到通过method1调用method2时,aop没有生效。直接调用method2时,aop才会生效。事务方法自调用失效就是因为这个原因,因为调用的不是代理对象的方法

解决方法有很多种,例如重新从ApplicationContext中取一下代理对象,然后调用代理对象的方法。另一种就是通过AopContext获取代理对象,实现原理就是当方法调用时会将代理对象放到ThreadLocal中

    @Service
    public class SaveSevice {
    
        public void method1() {
            System.out.println("method1 executed");
            ((SaveSevice) AopContext.currentProxy()).method2();
        }
    
        public void method2() {
            System.out.println("method2 executed");
        }
    }

将exposeProxy属性改为true

    @EnableAspectJAutoProxy(exposeProxy = true)
    method1 executed
    开启事务
    method2 executed
    --

可以看到aop成功生效。 当你使用@Transactional注解,分布式事务框架时一定要注意子调用这个问题,不然很容易造成事务失效

我们接着聊,往容器中注入AnnotationAwareAspectJAutoProxyCreator,那么这个类有啥作用呢?

2022090123410457616.png

看这继承关系是不是和我们上面分析的DefaultAdvisorAutoProxyCreator类很相似,这不就是为了开启自动代理吗?

忘了自动代理的实现过程了?回头看看

切点表达式

Spring AOP用AspectJExpressionPointcut桥接了Aspect的筛选能力 。其实Aspect有很多种类型的切点表达式,但是Spring AOP只支持如下10种,因为Aspect支持很多种类型的JoinPoint,但是Spring AOP只支持方法执行这一种JoinPoint,所以其余的表达式就没有必要了。

2022090123410564317.png

因为AspectJ提供的表达式在我们工作中经常被使用,结合Demo演示一下具体的用法

表达式类型 解释
表达式类型 解释
execution 匹配方法表达式,首选方式
within 限定类型
this 代理对象是指定类型,所有方法都会被拦截
target 目标对象是指定类型,所有方法都会被拦截
args 匹配方法中的参数
@target 目标对象有指定的注解,所有方法都会被拦截
@args 方法参数所属类型上有指定注解
@within 调用对象上有指定的注解,所有方法都会被拦截
@annotation 有指定注解的方法

execution

匹配方法表达式,首选方式

    execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern)
                    throws-pattern?)

拦截Performance类的perform方法的切点表达式如下

2022090123410736318.png

放几个官方的Demo

    // The execution of any public method:
    execution(public * *(..))
    
    // The execution of any method with a name that begins with set
    execution(* set*(..))
    
    // The execution of any method defined by the AccountService interface
    execution(* com.xyz.service.AccountService.*(..))
    
    // The execution of any method defined in the service package:
    execution(* com.xyz.service.*.*(..))

within
限定类型

    // 拦截service包中任意类的任意方法
    within(com.xyz.service.*)
    
    // 拦截service包及子包中任意类的任意方法
    within(com.xyz.service..*)

this

代理对象是指定类型,所有方法都会被拦截

举个例子说明一下

    @Configuration
    @EnableAspectJAutoProxy
    public class ThisDemo {
    
        public static void main(String[] args) {
            AnnotationConfigApplicationContext context =
                    new AnnotationConfigApplicationContext(ThisDemo.class, AspectDefine.class);
            Name name = context.getBean(Name.class);
            name.getName();
            System.out.println(name instanceof Student);
        }
    
    
        @Aspect
        public class AspectDefine {
            @Before("this(com.javashitang.aspectjPointcut.thisDemo.ThisDemo.Student)")
            public void before() {
                System.out.println("before");
            }
        }
    
        @Bean
        public Student student() {
            return new Student();
        }
    
        public class Student implements Name {
    
            @Override
            public String getName() {
                return null;
            }
        }
    
        public interface Name {
            String getName();
        }
    }

输出为

    false

有接口时会使用jdk动态代理,因此代理对象为Proxy,不会拦截

当设置为jdk动态代理为,代理对象为Student,正常拦截

将注解改为如下形式
@EnableAspectJAutoProxy(proxyTargetClass = true)

输出为

    before
    true

target
目标对象是指定类型,所有方法都会被拦截

    // 目标对象为AccountService类型的会被代理
    target(com.xyz.service.AccountService)

this 和 target 的不同点
this作用于代理对象,target作用于目标对象

args
匹配方法中的参数

    // 匹配只有一个参数,且类型为com.ms.aop.args.demo1.UserModel
    @Pointcut("args(com.ms.aop.args.demo1.UserModel)")
    
    // 匹配多个参数
    args(type1,type2,typeN)
    
    // 匹配第一个参数类型为com.ms.aop.args.demo1.UserModel的所有方法, .. 表示任意个参数
    @Pointcut("args(com.ms.aop.args.demo1.UserModel,..)")

@target
目标对象有指定的注解,所有方法都会被拦截

    // 目标对象中包含com.ms.aop.jtarget.Annotation1注解,调用该目标对象的任意方法都会被拦截
    @target(com.ms.aop.jtarget.Annotation1)

@args
方法参数所属类型上有指定注解

    // 匹配1个参数,且第1个参数所属的类中有Anno1注解
    @args(com.ms.aop.jargs.demo1.Anno1)
    // 匹配多个参数,且多个参数所属的类型上都有指定的注解
    @args(com.ms.aop.jargs.demo1.Anno1,com.ms.aop.jargs.demo1.Anno2)
    // 匹配多个参数,且第一个参数所属的类中有Anno1注解
    @args(com.ms.aop.jargs.demo2.Anno1,…)

@within

调用对象上有指定的注解,所有方法都会被拦截

    // 声明有com.ms.aop.jwithin.Annotation1注解的类中的所有方法都会被拦截
    @within(com.ms.aop.jwithin.Annotation1)

@target 和 @within 的不同点
@target关注的是被调用的对象,@within关注的是调用的对象

@annotation
有指定注解的方法

    // 被调用方法上有Annotation1注解
    @annotation(com.ms.aop.jannotation.demo2.Annotation1)

Adivce之间的顺序关系

一个方法被一个aspect类拦截时的执行顺序如下

@Around->@Before->方法执行->@Around->@After->@AfterReturning/@AfterThrowing

当方法正常结束时,执行@AfterReturning。方法异常结束时,执行@AfterThrowing。

2022090123410860819.png

一个方法被多个aspect类拦截时的执行顺序如下

2022090123410962120.png

图中After,AfterReturning,AfterThrowing还是依次执行哈,放到一块是图片好看一点

多个aspect的执行顺序可以通过@Order注解或者实现Oreder接口来控制

Adivce的顺序一定要梳理清楚,不然有时候产生的很多魔幻行为你都不知道怎么发生的

参考博客

[1]https://zhuanlan.zhihu.com/p/104520344
[5]https://www.jianshu.com/p/ef3dc73bc3b1