Spring AOP用法详解

什么是AOP

AOP(Aspect-Oriented Programming,面向方面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合。当我们需 要为分散的对象引入公共行为的时候,OOP则显得无能为力。也就是说,OOP允许你定义从上到下的关系,但并不适合定义从左到右的关系。例如日志功能。报告代码往往分散在各个级别,不与该对象的基本功能有关,其他类型的代码也同样适用,例如安全、不寻常的处理和持续的透明度。这种 散布在各处的无关的代码被称为横切(cross-cutting)代码,在OOP设计中,它导致了大量代码的重复,而不利于各个模块的重用。

而AOP技术则恰恰相反,它使用一种称为横切的技术来分解封装的对象,并将影响多个类的常见行为封装到一个可重用模块中,并将其名为 “Aspect”,即方面。所谓“方面”,简单地说,就是将那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,它易于减少系统的重复代码,降低模块之间的耦合度,有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系,如果对象是中空圆柱体,则它封装对象的属性和行为。因此,面向方面的编程就像一个锋利的边缘,将这些空心圆柱体切割开来获得它们的内部信息。而切割表面就是所谓的“面”。然后,它恢复了切割表面没有留下任何痕迹与熟练的手。

AOP的术语

1.Join point(连接点)
Spring 官方文档的描述:

程序执行过程中的点,如方法的执行或异常的处理。在Spring AOP中,连接点总是表示方法执行。

2.Pointcut(切入点)

切入点是与连接点匹配的表达式,用于确定是否需要执行通知。Pointcut使用与连接点匹配的不同种类的表达式,Spring框架使用AspectJ切入点表达式语言

3.Advice(增强/通知)

通知指的是在拦截Joinpoint之后要做什么。通知分为事前通知、事后通知、异常通知、最终通知和环绕通知。

4.Aspect(切面)

Aspect切面表示Pointcut(切入点)和Advice(增强/通知)的结合

Spring AOP用法

示例代码:

/**
 * 设置登录用户名
 */
public class CurrentUserHolder {

    private static final ThreadLocal<String> holder = new ThreadLocal<>();

    public static String get() {
        return holder.get();
    }
    public static void set(String user) {
        holder.set(user);
    }
}
/**
 * 校验用户权限
 */
@Service("authService")
public class AuthServiceImpl implements AuthService {

    @Override
    public void checkAccess() {
        String user = CurrentUserHolder.get();

        if(!"admin".equals(user)) {
            throw new RuntimeException("该用户无此权限!");
        }
    }
}
/**
 * 业务逻辑类
 */
@Service("productService")
public class ProductServiceImpl implements ProductService {

    @Autowired
    private AuthService authService;

    @Override
    public Long deleteProductById(Long id) {
        System.out.println("删除商品id为" + id + "的商品成功!");
        return id;
    }

    @Override
    public void deleteProductByName(String name) {
        System.out.println("删除商品名称为" + name + "的商品成功!");
    }

    @Override
    public void selectProduct(Long id) {
        if("100".equals(id.toString())) {
            System.out.println("查询商品成功!");
        } else {
            System.out.println("查询商品失败!");
            throw new RuntimeException("该商品不存在!");
        }
    }
}

1.使用within表达式匹配包类型

2.使用this、target、bean表达式匹配对象类型

//匹配AOP对象的目标对象为指定类型的方法,即ProductServiceImpl的aop代理对象的方法
@Pointcut("this(com.aop.service.impl.ProductServiceImpl)")
public void matchThis() {}

//匹配实现ProductService接口的目标对象
@Pointcut("target(com.aop.service.ProductService)")
public void matchTarget() {}

//匹配所有以Service结尾的bean里面的方法
@Pointcut("bean(*Service)")
public void matchBean() {}

3.使用args表达式匹配参数

//匹配第一个参数为Long类型的方法
@Pointcut("args(Long, ..) ")
public void matchArgs() {}

4.使用@annotation、@within、@target、@args匹配注解

5.使用execution表达式

执行表达式是我们开发过程中最常用的表达式。它的语法如下:


execution表达式
modifier-pattern:用于匹配访问修饰符,如public、private等。
ret-type-pattern:用于匹配返回值类型,不省略
declaring-type-pattern:用于匹配包类型
modifier-pattern(param-pattern):在匹配类中使用的方法不能被省略
throws-pattern:用于匹配抛出异常的方法

代码示例:

@Component
@Aspect
public class SecurityAspect {

    @Autowired
    private AuthService authService;

    //匹配com.aop.service.impl.ProductServiceImpl类下的方法名以delete开头、参数类型为Long的public方法
    @Pointcut("execution(public * com.aop.service.impl.ProductServiceImpl.delete*(Long))")
    public void matchCondition() {}

    //使用matchCondition这个切入点进行增强
    @Before("matchCondition()")
    public void before() {
        System.out.println("before 前置通知......");
        authService.checkAccess();
    }
}

单元测试:

运行结果(只有deleteProductById方法拦截成功):

查询商品成功!
删除商品名称为衣服的商品成功!
before 前置通知......

java.lang.RuntimeException: 该用户无此权限!

    at com.aop.service.impl.AuthServiceImpl.checkAccess(AuthServiceImpl.java:15)
    at com.aop.security.SecurityAspect.before(SecurityAspect.java:50)

可以在多个表达式之间使用连接符匹配多个条件, 如使用||表示“或”,使用 &&表示“且”

//匹配com.aop.service.impl.ProductServiceImpl类下方法名以select或delete开头的所有方法
@Pointcut("execution(* com.aop.service.impl.ProductServiceImpl.select*(..)) || " +
            "execution(* com.aop.service.impl.ProductServiceImpl.delete*(..))")
public void matchCondition() {}

//使用matchCondition这个切入点进行增强
@Before("matchCondition()")
public void before() {
   System.out.println("before 前置通知......");
   authService.checkAccess();
}

单元测试:

运行结果(所有方法均拦截成功):

before 前置通知......
查询商品成功!
before 前置通知......
删除商品名称为衣服的商品成功!
before 前置通知......
删除商品id为100的商品成功!

6.Advice注解

Advice注解一共有5种,分别是:

①. @Before前置通知

前置通知在切入点运行前执行,不会影响切入点的逻辑

②. @After后置通知

在切入点的正常操作之后执行后通知。如果切入点引发异常,则在引发异常之前执行该异常。

③. @AfterThrowing异常通知
异常通知在切入点抛出异常前执行,如果切入点正常运行(未抛出异常),则不执行

④. @AfterReturning返回通知

返回通知在入口点正确运行之后执行,如果入口点抛出异常,则不执行。

⑤. @Around环绕通知

圆周通知是最强大的通知,您可以在执行入口点之前和之后自定义一些操作。环绕通知负责决定是继续处理连接点(调用ProceedingJoinPoint的.方法)还是中断执行

示例代码:

    //匹配com.aop.service.impl.ProductServiceImpl类下面的所有方法
    @Pointcut("execution(* com.aop.service.impl.ProductServiceImpl.*(..))")
    public void matchAll() {}

    @Around("matchAll()")
    public Object around(ProceedingJoinPoint joinPoint) {
        Object result = null;
        authService.checkAccess();
        System.out.println("befor 在切入点执行前运行");

        try{
            result = joinPoint.proceed(joinPoint.getArgs());//获取参数
            System.out.println("after 在切入点执行后运行,result = " + result);
        } catch (Throwable e) {
            System.out.println("after 在切入点执行后抛出exception运行");
            e.printStackTrace();
        } finally {
            System.out.println("finally......");
        }

       return result;
    }

单元测试:

    @Test
    public void contextLoads() {
        CurrentUserHolder.set("admin");

        productService.deleteProductById(100L);
        productService.selectProduct(10L);
    }

运行结果:

在执行ProceedingJoinPoint对象的.方法之前,它等同于事前通知;在执行.方法之后,它等同于运行切入点(并且可以获得参数);在执行该方法之后,它等同于事后通知;如果通过运行切入点引发异常catch中的内容等效于AfterThrowing异常通知;不管切入点是否引发异常,final中的内容等效于AfterThrowing异常通知。通常,它将被执行。

没有更多推荐了,返回首页

私密
私密原因:
请选择设置私密原因
  • 广告
  • 抄袭
  • 版权
  • 政治
  • 色情
  • 无意义
  • 其他
其他原因:
120
出错啦
系统繁忙,请稍后再试