《深入浅出Spring》SpringAOP 详解AspectJ

猿一一

已于 2022-08-29 22:28:12 修改

阅读量552

点赞数

分类专栏： Spring 文章标签： spring java 后端

于 2022-07-22 00:42:32 首次发布

本文链接：https://blog.csdn.net/ysj_2021/article/details/125923151

版权

AspectJ是什么?

AspectJ是一个面向切面的框架，是目前最好用，最方便的AOP框架，和spring中的aop可以集成在一起使用，通过Aspectj提供的一些功能实现aop代理变得非常方便。

AspectJ使用步骤

1.创建一个类，使用@Aspect标注
2.@Aspect标注的类中，通过@Pointcut定义切入点
3.@Aspect标注的类中，通过AspectJ提供的一些通知相关的注解定义通知
4.使用AspectJProxyFactory结合@Ascpect标注的类，来生成代理对象

栗子：

public class Service1 {
   
    public void m1() {
   
        System.out.println("我是 m1 方法");
    }
    public void m2() {
   
        System.out.println(10 / 0);
        System.out.println("我是 m2 方法");
    }
}

通过AspectJ来对Service1进行增强，来2个通知，一个前置通知，一个异常通知，这2个通知需要对Service1中的所有方法生效，实现如下：

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
//@1：这个类需要使用@Aspect进行标注
@Aspect
public class Aspect1 {
   
    //@2：定义了一个切入点，可以匹配Service1中所有方法
    @Pointcut("execution(* Service1.*(..))")
    public void pointcut1() {
   
    }
    //@3：定义了一个前置通知，这个通知对刚刚上面我们定义的切入点中的所有方法有效
    @Before(value = "pointcut1()")
    public void before(JoinPoint joinPoint) {
   
        //输出连接点的信息
        System.out.println("前置通知，" + joinPoint);
    }
    //@4：定义了一个异常通知，这个通知对刚刚上面我们定义的切入点中的所有方法有效
    @AfterThrowing(value = "pointcut1()", throwing = "e")
    public void afterThrowing(JoinPoint joinPoint, Exception e) {
   
        //发生异常之后输出异常信息
        System.out.println(joinPoint + ",发生异常：" + e.getMessage());
    }
}

@1：类上使用@Aspect标注

@2：通过@Pointcut注解标注在方法上面，用来定义切入点

@3：使用@Before标注在方法上面，定义了一个前置通知，通过value引用了上面已经定义的切入点，表示这个通知会对Service1中的所有方法生效，在通知中可以通过这个类名.方法名()引用@Pointcut定义的切入点，表示这个通知对这些切入点有效，若@Before和@Pointcut在一个类的时候，直接通过方法名()引用当前类中定义的切入点

@4：这个使用@AfterThrowing定义了一个异常通知，也是对通过value引用了上面已经定义的切入点，表示这个通知会对Service1中的所有方法生效，若Service1中的方法抛出了Exception类型的异常，都会回调afterThrowing方法。

public void test1() {
   
        try {
   
            //对应目标对象
            Service1 target = new Service1();
            //创建AspectJProxyFactory对象
            AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
            //设置被代理的目标对象
            proxyFactory.setTarget(target);
            //设置标注了@Aspect注解的类
            proxyFactory.addAspect(Aspect1.class);
            //生成代理对象
            Service1 proxy = proxyFactory.getProxy();
            //使用代理对象
            proxy.m1();
            proxy.m2();
        } catch (Exception e) {
   
        }
    }
}

运行输出

前置通知，execution(void Service1.m1()) 我是
m1 方法前置通知，execution(void
Service1.m2()) execution(void
Service1.m2()),发生异常：/ by zero

AspectJProxyFactory原理

@Aspect标注的类上，这个类中，可以通过通过@Pointcut来定义切入点，可以通过@Before、@Around、@After、@AfterRunning、@AfterThrowing标注在方法上来定义通知，定义好了之后，将@Aspect标注的这个类交给AspectJProxyFactory来解析生成Advisor链，进而结合目标对象一起来生成代理对象，大家可以去看一下源码，比较简单，这里就不多解释了。

本文的重点在@Aspect标注的类上，@Aspect中有2个关键点比较重要

@Pointcut：标注在方法上，用来定义切入点，有11种用法，本文主要讲解这11种用法。
@Aspect类中定义通知：可以通过@Before、@Around、@After、@AfterRunning、@AfterThrowing标注在方法上来定义通知，

@Pointcut的12种用法

作用
用来标注在方法上来定义切入点。

定义
格式：@ 注解(value=“表达标签 (表达式格式)”)

如：

@Pointcut("execution(* .Service1.*(..))")

表达式标签（10种）

execution：用于匹配方法执行的连接点
within：用于匹配指定类型内的方法执行
this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口的类型匹配
target：用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口的类型匹配
args：用于匹配当前执行的方法传入的参数为指定类型的执行方法
-@within：用于匹配所以持有指定注解类型内的方法
@target：用于匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解
@args：用于匹配当前执行的方法传入的参数持有指定注解的执行
@annotation：用于匹配当前执行方法持有指定注解的方法
bean：Spring AOP扩展的，AspectJ没有对于指示符，用于匹配特定名称的Bean对象的执行方法

1、execution

使用execution(方法表达式)匹配方法执行。

execution格式

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

其中带 ?号的 modifiers-pattern?，declaring-type-pattern?，throws-pattern?是可选项
ret-type-pattern,name-pattern, parameters-pattern是必选项
modifier-pattern? 修饰符匹配，如public 表示匹配公有方法
ret-type-pattern 返回值匹配，* 表示任何返回值，全路径的类名等
declaring-type-pattern? 类路径匹配
-name-pattern 方法名匹配，代表所有，set，代表以set开头的所有方法
(param-pattern) 参数匹配，指定方法参数(声明的类型)，(…)代表所有参数，(*,String)代表第一个参数为任何值,第二个为String类型，(…,String)代表最后一个参数是String类型
throws-pattern? 异常类型匹配

举例说明

表达式	描述
public .(…)	任何公共方法的执行
* com.javacode…IPointcutService.*()	com.javacode包及所有子包下IPointcutService接口中的任何无参方法
* com.javacode…IPointcutService.*()	com.javacode包及所有子包下IPointcutService接口中的任何无参方法
* com.javacode….(…)	com.javacode包及所有子包下任何类的任何方法
* com.javacode…IPointcutService.()	com.javacode包及所有子包下IPointcutService接口的任何只有一个参数方法
* com.javacode…IPointcutService+.*()	com.javacode包及所有子包下IPointcutService接口及子类型的的任何无参方法
* Service1.*(String)	匹配Service1中只有1个参数的且参数类型是String的方法
* Service1.(,String)	匹配Service1中只有2个参数的且第二个参数类型是String的方法
* Service1.*(…,String)	匹配Service1中最后1个参数类型是String的方法

类型匹配语法
很多地方会按照类型的匹配，先来说一下类型匹配的语法。

首先让我们来了解下AspectJ类型匹配的通配符：

*：匹配任何数量字符
…：匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数（0个或者多个参数）
+：匹配指定类型及其子类型；仅能作为后缀放在类型模式后边

表达式	说明
java.lang.String	匹配String类型
java.*.String	匹配java包下的任何一级子包下的String类型，如匹配java.lang.String，但不匹配java.lang.ss.String
java…*	匹配java包及任何子包下的任何类型，如匹配java.lang.String、java.lang.annotation.Annotation
java.lang.*ing	匹配任何java.lang包下的以ing结尾的类型
java.lang.Number+	匹配java.lang包下的任何Number类型及其子类型，如匹配java.lang.Number，也匹配java.lang.Integer、java.math.BigInteger

2、within

用法
within(类型表达式)：目标对象target的类型是否和within中指定的类型匹配

表达式	描述
within(com.javacode…*)	com.javacode包及子包下的任何方法执行
within(com.javacode…IPointcutService+)	com.javacode包或所有子包下IPointcutService类型及子类型的任何方法
within(com.javacode.Service1)	匹配类com.javacode.Service1中定义的所有方法，不包含其子类中的方法

匹配原则

target.getClass().equals(within表达式中指定的类型)

栗子：

@Pointcut("within(C1+)") 匹配C1类型
@Pointcut("within(C2)") 匹配C2类型

3、this

用法
this(类型全限定名)：通过aop创建的代理对象的类型是否和this中指定的类型匹配；注意判断的目标是代理对象；this中使用的表达式必须是类型全限定名，不支持通配符。

匹配原则

如:this(x)，则代理对象proxy满足下面条件时会匹配
x.getClass().isAssignableFrom(proxy.getClass());

栗子：


//匹配proxy是Service3类型的所有方法
    @Pointcut("this(Service3)")

4、target

用法
target(类型全限定名)：判断目标对象的类型是否和指定的类型匹配；注意判断的是目标对象的类型；表达式必须是类型全限定名，不支持通配符。

匹配原则
如:target(x)，则目标对象target满足下面条件时会匹配
x.getClass().isAssignableFrom(target.getClass());

栗子：

//目标类型必须是Service3类型的
    @Pointcut("target(Service3)")
    public void pc() {
   
    }

within、this、target对比

表达式标签	判断的对象	判断规则(x：指表达式中指定的类型)
within	target对象	target.getClass().equals(表达式中指定的类型)
this	proxy对象	x.getClass().isAssignableFrom(proxy.getClass());
target	target对象	x.getClass().isAssignableFrom(target.getClass());

5、args

用法

args(参数类型列表)匹配当前执行的方法传入的参数是否为args中指定的类型；注意是匹配传入的参数类型，不是匹配方法签名的参数类型；参数类型列表中的参数必须是类型全限定名，不支持通配符；args属于动态切入点，也就是执行方法的时候进行判断的，这种切入点开销非常大，非特殊情况最好不要使用。

举例说明

表达式	描述
args(String)	匹配只有一个参数且传入的参数类型是String类型的方法
args(*,String)	匹配只有2个参数的且第2个参数类型是String的方法
args(…,String)	匹配最后1个参数类型是String的方法

栗子：

//匹配只有1个参数其类型是String类型的
    @Pointcut("args(String)")

args会在调用的过程中对参数实际的类型进行匹配，比较耗时，慎用。

6、@within

用法

@within(注解类型)：匹配指定的注解内定义的方法。

匹配规则
调用目标方法的时候，通过java中Method.getDeclaringClass()获取当前的方法是哪个类中定义的，然后会看这个类上是否有指定的注解。
被调用的目标方法Method对象.getDeclaringClass().getAnnotation(within中指定的注解类型) != null

栗子：

/**
     * 定义目标方法的类上有Ann9注解
     */
    @Pointcut("@within(Ann9)")
    public void pc() {
   
    }

目标对象上有@within中指定的注解，这种情况时，目标对象的所有方法都会被拦截。
定义注解时未使用@Inherited，说明子类无法继承父类上的注解，子类重写父类方法不会拦截父类方法
在注解的定义上面加上@Inherited，此时子类可以继承父类的注解，子类重写父类方法，会拦截子类和父类的方法

7、@target

用法
@target(注解类型)：判断目标对象target类型上是否有指定的注解；@target中注解类型也必须是全限定类型名。

匹配规则
target.class.getAnnotation(指定的注解类型) != null
2种情况可以匹配

注解直接标注在目标类上
注解标注在父类上，但是注解必须是可以继承的，即定义注解的时候，需要使用@Inherited标注

注解直接标注在目标类上，这种情况目标类会被匹配到。

//@1：目标类上有@Ann1注解
    @Pointcut("@target(Ann1)")
    public void pc() {
   
    }

注解标注在父类上，注解上没有@Inherited，这种情况下，目标类无法匹配到

 /**
     * 匹配目标类上有Ann7注解
     */
    @Pointcut("@target(Ann7)")
    public void pc() {
   
    }

8、@args

用法
@args(注解类型)：方法参数所属的类上有指定的注解；注意不是参数上有指定的注解，而是参数类型的类上有指定的注解。

案例1

@Pointcut(“@args(Ann8)”)：匹配方法只有一个参数，并且参数所属的类上有Ann8注解

可以匹配下面的代码，m1方法的第一个参数类型是Car类型，Car类型上有注解Ann8

@Ann8
class Car {
   
}
public void m1(Car car) {
   
    System.out

最低0.47元/天解锁文章

猿一一

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
《深入浅出Spring》SpringAOP 详解AspectJ

Spring AOP AspectJ
复制链接

扫一扫

专栏目录