您的位置：首页 > 编程语言 > Java开发

spring---面向切面(AOP @Pointcut 表达式篇)

2022-02-08 15:46 465 查看 

AOP
（面向切面编程），可以说是
OOP
（面向对象编程）的补充和完善。
OOP
引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。

当我们需要为分散的对象引入公共行为的时候，

OOP
则显得无能为力。也就是说，
OOP
允许你定义从上到下的关系，但并不适合定义从左到右的关系。

例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。

这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

而

AOP
技术则恰恰相反，它利用一种称为横切技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为
Aspect
，即切面。

所谓切面，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。

AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息，然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

AOP的基本概念

  1. Aspect
    （切面）：Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的
    Advice。

  2. Joint point
    （连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它joint point。

  3. Pointcut
    （切点）：表示一组 joint point，这些 joint point
    或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。

  4. Advice
    （增强）：Advice 定义了在 
    Pointcut
    里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。

  5. Target
    （目标对象）：织入 
    Advice
    的目标对象.。

  6. Weaving（织入）：将 

    Aspect
    和其他对象连接起来, 并创建
    Adviced object
    的过程

通知方法:

  1. 前置通知:在我们执行目标方法之前运行(

    @Before
    )

  2. 后置通知:在我们目标方法运行结束之后 ,不管有没有异常(

    @After
    )

  3. 返回通知:在我们的目标方法正常返回值后运行(

    @AfterReturning
    )

  4. 异常通知:在我们的目标方法出现异常后运行(

    @AfterThrowing
    )

  5. 环绕通知:动态代理, 需要手动执行joinPoint.procced()(其实就是执行我们的目标方法执行之前相当于前置通知,执行之后就相当于我们后置通知(

    @Around
    )

AOP代码示范

下面以一个AOP日志功能的例子进行代码的演示，具体的代码如下所示：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

/**
* @Description:切面日志类
* @author: 张重虎
* @Date: 2022/2/8 14:58
* @Copyright: Xi'an Dian Tong Software Co., Ltd. All Rights Reserved.
* @Version 1.0
*/
@Aspect
public class LogAspect {
@Pointcut("execution(* com.example.zhangchonghu.demo.controller.aop.Calculator .*(..))")
public void pointCut(){};

/**
* 前置通知:在我们执行目标方法之前运行(@Before)
*/
@Before("pointCut()")
public void logStart(){
System.out.println("除法运行....参数列表是:{}");
}

/**
* 后置通知:在我们目标方法运行结束之后 ,不管有没有异常(@After)
*/
@After("pointCut()")
public void logEnd(){
System.out.println("除法结束......");
}

/**
* 返回通知:在我们的目标方法正常返回值后运行(@AfterReturning)
*/
@AfterReturning("pointCut()")
public void logReturn(){
System.out.println("除法正常返回......运行结果是:{}");
}

/**
* 异常通知:在我们的目标方法出现异常后运行(@AfterThrowing)
*/
@AfterThrowing("pointCut()")
public void logException(){
System.out.println("异常通知");
}

/**
* 环绕通知:动态代理, 需要手动执行joinPoint.procced()(其实就是执行我们的目标方法执行之前相当于前置通知,执行之后就相当于我们后置通知(@Around)
* @param proceedingJoinPoint 切点
* @return
* @throws Throwable
*/
@Around("pointCut()")
public Object logAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
System.out.println("执行目标方法之前");
//调用方法
Object obj = proceedingJoinPoint.proceed();
System.out.println("@Arount:执行目标方法之后...");
return obj;
}
}

@Pointcut("execution(* com.savage.aop.Calculator .*(..))")
，括号中各个pattern分别表示：

  • 第一个*表示返回值匹配，可以为*表示任何返回值, 全路径的类名等

  • com.savage.aop表示类路径匹配

  • 第二个*表示方法名匹配，可以指定方法名 或者*代表所有, set* 代表以set开头的所有方法

  • (..)表示参数匹配：可以指定具体的参数类型，多个参数间用“,”隔开，各个参数也可以用""来表示匹配任意类型的参数，".."表示零个或多个任意参数。如(String)表示匹配一个String参数的方法；(,String)表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型。异常类型匹配（throws-pattern?）

目标方法：

 

/**
* @Description: 切面目标
* @author: 张重虎
* @Date: 2022/2/8 15:04
* @Copyright: Xi'an Dian Tong Software Co., Ltd. All Rights Reserved.
* @Version 1.0
*/
public class Calculator {
public int div(int i, int j){
System.out.println("--------");
return i/j;
}
}

 

配置类：

 

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
* @Description: 切面配置类
* @author: 张重虎
* @Date: 2022/2/8 15:05
* @Copyright: Xi'an Dian Tong Software Co., Ltd. All Rights Reserved.
* @Version 1.0
*/
@Configuration
@EnableAspectJAutoProxy
public class MyAspectConfig {
@Bean
public Calculator calculator(){
return new Calculator();
}

@Bean
public LogAspect logAspects(){
return new LogAspect ();
}
}

 

测试类：

 

import com.example.zhangchonghu.demo.controller.aop.Calculator;
import com.example.zhangchonghu.demo.controller.aop.MyAspectConfig;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
* @Description:
* @author: 张重虎
* @Date: 2022/2/8 15:05
* @Copyright: Xi'an Dian Tong Software Co., Ltd. All Rights Reserved.
* @Version 1.0
*/
public class TestLogAop {
@Test
public void test(){
AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MyAspectConfig.class);
Calculator c = app.getBean(Calculator.class);
int result = c.div(4, 3);
System.out.println(result);
app.close();
}
}

 

运行结果：

 

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航