Java教程

AOP详解

本文主要是介绍AOP详解,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

目录

  • AOP:面向切面编程,AOP是一种编程思想,和语言无关。
  • 拦截器和AOP之间的关系?
  • 什么是AOP
  • 使用场景及作用
  • JDK实现
  • JDK和CGLIB实现的区别
  • Spring AOP中的实现
  • SpringAOP的AspectJ支持
  • AOP术语
    • 切点表达式说明
    • 切点表达式示例
    • 通知(Advice)
    • 织入(Weaving)
  • SpringAOP的实现举例:
    • 第一步:引入依赖
    • 第二步:定义切面
    • 第三步:添加通知

AOP:面向切面编程,AOP是一种编程思想,和语言无关。

拦截器和AOP之间的关系?

拦截器的拦截粒度比较粗,而SpringAOP拦截粒度更细

什么是AOP

AOP称为面向切面编程,在系统开发中主要用来解决一些系统层面上的问题,比如:日志,权限,事务等等。
AOP利用一种称为“横切”的技术,将那些影响了多个类的公共行为封装到一个可重用模块,并将其命名为"Aspect",即切面。
使用“横切”技术,AOP把软件系统分为两个部分:核心关注点横切关注点。业务处理的主要流程是核心关注点,与之关系不大的部分是横切关注点。
横切关注点的一个特点是,他们经常发生在核心关注点的多处,而各处基本相似,比如权限认证,日志,事务。AOP的作用在于分离系统中的各种关注点,将核心关注点和横切关注点分离开来。

使用场景及作用

对以上统一业务来说,常见的切面业务如:

  1. 响应统一的数据格式
  2. 统一异常处理
  3. 统一日志记录,如跟踪用户访问信息
  4. 用户统一会话管理,权限管理
  5. 方法执行时间计算
  6. 事务管理
  7. 其他

对于使用AOP技术来说,解决的最大问题就是对横切业务的统一管理:

  1. 横切代码的高度复用,和业务代码互相独立,满足代码设计上的高内聚低耦合
  2. 系统更好的扩展性,可维护性

我们学习Spring框架中的AOP,主要基于两种方式:JDK及CGLIB的方式。这两种方式的代理目标都是被代理类中的方法,在运行期,动态的织入字节码生成代理类。

JDK实现

JDK实现时,先通过实现InvocationHandler接口创建方法调用处理器,再通过Proxy来创建代理类。

JDK和CGLIB实现的区别

  1. JDK实现,要求被代理类必须实现接口,之后是通过InvocationHandler及Proxy,在运行时动态的在内存中生成了代理类对象,该代理对象是通过实现同样的接口实现(类似静态代理接口实现的方式),只是该代理类是在运行期时,动态的织入统一的业务逻辑字节码来完成。
  2. CGLIB实现,被代理类可以不实现接口,是通过继承被代理类,在运行时动态的生成代理类对象。

Spring AOP大部分可以通过CGLIB来实现动态代理,当一个类是final class 的时候就必须使用JDK Porxy来实现动态代理了,因为final class无法被继承。

Spring AOP中的实现

一个类的重要组成部分有两个:

  1. 属性
  2. 方法

SpringAOP只能实现方法拦截,不能实现属性拦截。但是对于AOP来说,AOP是既可以实现属性拦截又可以实现方法拦截的。
SpringAOP支持JDK和CGLIB的方式实现动态代理。默认情况下,实现了接口的类,使用AOP会基于JDK生成代理类,没有实现接口的类,会基于CGLIB生成代理类。

SpringAOP的AspectJ支持

SpringAOP只提供了AspectJ的注解语法支持没有真实使用AspectJ的编译器,在运行时还是基于单纯的AOP。也就是说,加入spring-aspects依赖包,只是可以使用AspectJ的语法,运行时还是基于spring-aop依赖包的动态代理实现。

AOP术语

和大多数技术一样,AOP已经形成了自己的术语。描述切面的常用术语有:通知(Advice),切点(Pointcut)连接点(Joinpoint)
切面(Aspect):由切点和通知组成,它既包含了横切逻辑的定义,也包括了连接点的定义。
连接点:连接点是在应用执行过程中能够插入切面(Aspect)的一个点。
切点:切点是指通知(Advice)所要织入(Weaving)的具体位置。(切点一定是连接点,连接点不一定是切点,只有程序执行的连接点才是切点)
打个比方:环形高速公路的所有出入口就叫做连接点。而某个我需要进,出的入口,出口才叫切点。

切点表达式说明

@AspectJ支持三种通配符
在这里插入图片描述
:匹配任意字符,只匹配一个元素(包,类,方法,方法参数)
在这里插入图片描述
:匹配任意字符,可以匹配多个元素,在表示类时,必须和*联合使用
在这里插入图片描述
:表示按照类型匹配指定类的所有类,必须跟在类名后面,如com.cad.car+,表示匹配该类的所有子类·包括本身
切点表达式由切点函数组成,其中execution()是最常用的切点函数,用来匹配方法。

切点表达式示例

execution(com.cad.demo.User.(…)):匹配User类里的所有方法
execution(com.cad.demo.User+.(…)):匹配该类的子类包括该类的所有方法
execution(com.cad..(…)):匹配com.cad包下的所有类的所有方法
execution(com.cad….
(…)):匹配com.cad包下,子孙包下所有类的所有方法
execution(*addUser(String,int)):匹配addUser方法,且第一个参数类型是String,第二个参数类型是int
通知(Advice):切面也是有目标(它必须完成的工作)的,在AOP术语中,切面的工作被称之为通知。

通知(Advice)

通知(Advice):切面也是有目标(它必须完成的工作)的,在AOP术语中,切面的工作被称之为通知。
通知:定义了切面是什么,何时使用,其描述了切面切面要完成的工作,还解决何时执行这个工作的问题。
Spring切面类中,可以在方法上使用以下注解,会设置方法为通知方法,在满足条件后会通知本方法进行调用。

  • 前置通知
    使用@Before:通知方法会在目标方法调用之前执行

  • 后置通知
    使用@After:通知方法会在目标方法返回或者抛出异常后调用

  • 返回之后通知
    使用@AfterReturing:通知方法会在目标方法返回后调用

  • 抛异常后通知
    使用@AfterThrowing:通知方法会在目标方法抛出异常后调用

  • 环绕通知
    使用@Around:通知包裹了被通知的方法,在被通知的方法通知之前和调用之后执行自定义的行为

许多AOP框架,包括Spring AOP,会将Advice模拟为一个拦截器(Interceptor),并且在JoinPoint上维护多个Advice,进行层层拦截。如之前我们在SpringMVC中学习的@ControllerAdvice就是。

织入(Weaving)

织入是把切面应用到目标对象并创建新的代理对象的过程,切面在指定的连接点被织入到目标对象中。

SpringAOP的实现举例:

第一步:引入依赖

在这里插入图片描述

第二步:定义切面

在这里插入图片描述

第三步:添加通知

在这里插入图片描述

  1. 首先创建一个controller用于测试
@RestController
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/login")
    public int login(String username,String password){
        System.out.println("执行了login方法");
        return 0;
    }
    @RequestMapping("/register")
    public int register(String username,String password){
        System.out.println("执行了register方法");
        return 1;
    }
}
  1. 再创建一个UserPointCut类
@Aspect//这个注解表示当前的类是一个切面
@Component//保证Spring启动之后,能够将当前的类加载到框架当中,加载到框架当中才能去用
public class UserPointCut {
    //1.定义切面的规则,使用注解定义规则
    @Pointcut("execution(* com.example.demo.controller.*Controller.*(..))")//表示对所有的Controller下的所有方法都会进行拦截
    public void pointcut(){

    }
    //2.添加通知
    @Before("pointcut()")//把切面的方法名写进去
    public void doBefore(){
        System.out.println("执行了前置通知");
    }
    @After("pointcut()")//把切面的方法名写进去
    public void doAfter(){
        System.out.println("执行了后置通知");
    }
    @AfterReturning("pointcut()")//把切面的方法名写进去
    public void doReturing(){
        System.out.println("执行了返回之后通知的方法");
    }
    @AfterThrowing("pointcut()")//把切面的方法名写进去
    public void doThrowing(){
        System.out.println("执行了抛出异常之后通知的方法");
    }
    @Around("pointcut()")//把切面的方法名写进去,环绕通知
    public Object doAround(ProceedingJoinPoint joinPoint){
        System.out.println("进入了环绕通知:方法执行之前");
        Object result = null;
        try {
            result = joinPoint.proceed();//表示执行被代理的方法,当调用了这个方法才有“执行了register”方法
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("执行了环绕通知:执行了方法调用之后");
        return 0;
    }
}
  1. 执行结果:
    输入url
    在这里插入图片描述
    浏览器中的得到返回值:1
    idea控制台得到:
    在这里插入图片描述

可以看出这些先后执行顺序。
如果Around通知变成这样:

@Around("pointcut()")//把切面的方法名写进去,环绕通知
    public Object doAround(ProceedingJoinPoint joinPoint){
        System.out.println("进入了环绕通知:方法执行之前");
        Object result = null;
        try {
            //result = joinPoint.proceed();//表示执行被代理的方法,当调用了这个方法才有“执行了register”方法
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("执行了环绕通知:执行了方法调用之后");
        return 0;
    }

再次输入url:
在这里插入图片描述
浏览器得到:0
idea控制台会得到:
在这里插入图片描述

这篇关于AOP详解的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!