2w字搞懂Spring AOP的前世今生(四)

发布于 2022-6-2 16:38
浏览
0收藏

 

@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接口

2w字搞懂Spring AOP的前世今生(四)-开源基础软件社区

这个代码主要做了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
--
开启事务
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
--
开启事务
method2 executed

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

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

2w字搞懂Spring AOP的前世今生(四)-开源基础软件社区

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

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

切点表达式

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

2w字搞懂Spring AOP的前世今生(四)-开源基础软件社区因为AspectJ提供的表达式在我们工作中经常被使用,结合Demo演示一下具体的用法

2w字搞懂Spring AOP的前世今生(四)-开源基础软件社区

「execution」

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

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

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

2w字搞懂Spring AOP的前世今生(四)-开源基础软件社区

放几个官方的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。两者不会同时执行哈

2w字搞懂Spring AOP的前世今生(四)-开源基础软件社区

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

2w字搞懂Spring AOP的前世今生(四)-开源基础软件社区

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

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

 

文章转自公众号:Java识堂

分类
标签
已于2022-6-2 16:38:22修改
收藏
回复
举报
回复
添加资源
添加资源将有机会获得更多曝光,你也可以直接关联已上传资源 去关联
    相关推荐