3 - AOP

1. 快速入门

1.1 基本说明

AOP(aspect oriented programming) ,面向切面编程

切面类中声明通知方法:

  • 前置通知:@Before
  • 返回通知:@AfterReturning
  • 异常通知:@AfterThrowing
  • 后置通知:@After
  • 环绕通知:@Around

1.2 快速入门 

参考视频:B站 三更草堂视频

1.3 细节说明

1)切面类方法命名

  • showBeginLog()
  • showSuccessEndLog()
  • showExceptionLog()
  • showFinallyEndLog()

2)切入表达式更多的配置

使用模糊配置

@Before(value="execution(* com.hspedu.aop.proxy.SmartDog.*(..))")

这个就表示这个切面方法作用与  com.hspedu.aop.proxy.SmartDog 类的函数

3)所有访问权限

@Before(value="execution(* *.*(..))")
  1. 第一个 * 表示 任意方法权限及任意返回值
  2. 第二个 * 表示 任意路径
  3. 第三个 * 表示 任意方法
  4. (..) 表示任意数量,任意类型的参数

所有包的下所有有类的所方法,都会被执行该前置通知方法

4)使用基于注解的AOP需要在配置文件里开启

 

5)开启了基于注解的后获取对象

这个时候去获取 ioc 容器里的对象的话,在底层被转换为 代理对象

我们获取注入的对象, 也可以通过 id 来获取, 但是也要转成接口类型


2. AOP-切入表达式

2.1 具体使用

1)作用

通过表达式的方式来定位一个或多个具体的切入点

2)语法细节

格式: execution([权限修饰符] [返回值类型] [简单类名/全类名] [方法名] ([参数列表]))

若目标类、接口 与切面类在同一个包下,可以省略包名

2.2 注意事项和细节

1)表达式指向类

切入表达式也可以指向类的方法, 这时切入表达式会对该类/对象生效

2)表达式指向接口

切入表达式也可以指向接口的方法, 这时切入表达式会对实现了接口的类/对象生效

3)表达式指向没有实现接口的类

切入表达式也可以对没有实现接口的类,进行切入

@Component
class Car {
    public void run() {
        System.out.println("car run");
    }
}

切面类:

@Before(value = "execution(public void com.hspedu.spring.aop.aspectj.Car.run())")
    public static void showBeginLog3(JoinPoint joinPoint) {
        //获取方法签名
        Signature signature = joinPoint.getSignature();
        System.out.println("方法执行前--方法名--" + signature.getName());
    }

测试:

@Test
    public void carTestProxy() {
        //得到spring容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans08.xml");
        Car car = ioc.getBean(Car.class);
        System.out.println(car.getClass());
        car.run();

    }

不一样的时,这此取出来的 car 对象的运行类型:

    class com.hspedu.spring.aop.aspectj.Car$$EnhancerBySpringCGLIB$$8e9f1fa7

这个时候 就是 Spring 的 CGlib 方案:取出的时 Car 对象的子类

参考:jdk的Proxy与spring的CGlib


3. 切入方法细节

3.1 AOP-JoinPoint 

常用方法一览

  • joinPoint.getSignature().getName(); 获取目标方法名
  • joinPoint.getSignature().getDeclaringType().getSimpleName(); 获取目标方法所属类的简单类名
  • joinPoint.getSignature().getDeclaringTypeName();  获取目标方法所属类的类名
  • joinPoint.getSignature().getModifiers(); /获取目标方法声明类型(public、private、protected)
  • Object[] args = joinPoint.getArgs();  获取传入目标方法的参数,返回一个数组
  • joinPoint.getTarget();   获取被代理的对象
  • joinPoint.getThis();    获取代理对象自己

3.2 返回通知获知结果

如何在返回通知方法获取返回结果?

**
* returning = "res", Object res 名称保持一致
* @param joinPoint
* @param res 调用 getSum() 返回的结果
*/
@AfterReturning(value="execution(public float com.hspedu.spring.aop.joinpoint.SmartDog.getSum(float, float))",returning = "res")
public void showSuccessEndLog(JoinPoint joinPoint, Object res) {
    System.out.println("返回通知" + "--结果是--" + res );
}

3.3 AOP-异常通知中获取异常

@AfterThrowing(value="execution(public float
com.hspedu.spring.aop.joinpoint.SmartDog.getSum(float, float))",throwing = "throwable")
public void showExceptionLog(JoinPoint joinPoint, Throwable throwable) {
    System.out.println("异常通知 -- 异常信息--" + throwable);
}

3.4 环绕通知(了解)

环绕通知可以完成其它四个通知要做的事情

@Aspect //表示这个类是一个切面类
@Component //需要加入到 IOC 容器
public class SmartAnimalAspect {
    //=====环绕通知 start=====
    //@Around(value = "execution(* *.*(..))")
    @Around(value="execution(public float
    com.hspedu.spring.aop.joinpoint.SmartDog.getSum(float, float))")
    public Object doAround(ProceedingJoinPoint joinPoint) {
        Object result = null;
        String methodName = joinPoint.getSignature().getName();
        try {
            //1.相当于前置通知完成的事情
            Object[] args = joinPoint.getArgs();
            List argList = Arrays.asList(args);
            System.out.println("AOP 环绕通知--" + methodName + "开始了--参数有:
                " + argList);
            //在环绕通知中一定要调用 joinPoint.proceed()来执行目标方法
            result = joinPoint.proceed();
            //2.相当于返回通知完成的事情
            System.out.println("AOP 环绕通知" + methodName + "结束了--结果是:"
                + result);
        } catch (Throwable throwable) {
            //3.相当于异常通知完成的事情
            System.out.println("AOP 环绕通知" + methodName + "抛异常--异常对象:" + 
                throwable);
        } finally {
            //4.相当于最终通知完成的事情
            System.out.println("AOP 后置通知" + methodName + "最终结束...");
        }
    return result;
} 
  

环绕通知和动态代理完成的事情相似

3.5  切入点表达式重用

为了统一管理切入点表达式,可以使用切入点表达式重用技术

在切面类上添加:

//=====AOP-切入点表达式重用 start ======
/*
* 这样定义的一个切入点表达式,就可以在其它地方直接使用
*/
@Pointcut(value="execution(public float
com.hspedu.spring.aop.joinpoint.SmartDog.getSum(float, float))")
public void myPointCut() {
}

这样其他切面方法就可以简写:

@Before(value = "myPointCut()")
public void showBeginLog(JoinPoint joinPoint) { //前置方法
    Signature signature = joinPoint.getSignature();
    //得到方法名.
    String method_name = signature.getName();
    //得到参数
    Object[] args = joinPoint.getArgs();
    System.out.println("前置通知" + "--调用的方法是 " + method_name + "--参数是
        --" + Arrays.asList(args));
}

3.6 AOP-切面优先级问题

如果同一个方法,有多个切面在同一个切入点切入,那么执行的优先级如何控制?

@order(value=n) 

通过设定 order 的value 值来控制, n 值越小,优先级越高

@Aspect //表示这个类是一个切面类
@Order(value = 2)
@Component //需要加入 IOC 容器
public class SmartAnimalAspect2 {
    /**
     内部是切面方法
    */
}

/****************************/

@Aspect //表示这个类是一个切面类
@Order(value = 1)
@Component //需要加入 IOC 容器
public class SmartAnimalAspect {
    /**
     内部是切面方法
    */
}

输出的信息顺序,类似 Filter 的过滤链式调用机制

3 - AOP_第1张图片


3.  基于 XML 配置 AOP

前面是通过注解来配置 aop 的,在 spring 中,我们也可以通过 xml 的方式来配置 AOP

1)准备对象

去掉切面方法的所有注解

2)配置 xml








    
    
    
    
        
        
        
        
        
        
    

你可能感兴趣的:(Spring5,学习笔记,java,开发语言)