spring aop详解

1.前言

spring aop是一个面向切面的编程，在自己第一遍学习的时候，感觉aop没有什么作用，但是真实接触下来，感觉spring aop还是很有用途的，感觉自己之前的想法太年轻了。

2.概念

Spring 提供了两种AOP 的实现：基于注解式配置和基于XML配置，我这里主要就是介绍一下，基于注解式配置。

2.1 AOP 即 Aspect Oriented Program 面向切面编程

首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。

• 所谓的核心业务，工作中做的最多的就是增删改查，增删改查都叫核心业务。

• 所谓的周边功能，比如性能统计，日志记录，事务管理等等

周边功能在 Spring 的面向切面编程AOP思想里，即被定义为切面

在面向切面编程AOP的思想里面，核心业务功能和切面功能分别独立进行开发，然后把切面功能和核心业务功能 "编织" 在一起，这就叫AOP

2.2 AOP 的目的

AOP能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

2.3 AOP 当中的概念：

• 切面 （Aspect）可以理解成，就是一个特殊的类（包含的都是增强核心业务的代码），切面 = 切入点 + 通知，通俗点就是：在什么时机，什么地方，做什么增强！

• 连接点（join point）通俗理解就是整个系统的所有方法都可以称为连接点

• 切入点（Pointcut） 就是被选中的连接点，可以通过execution来确定选中的连接点有哪些

• 通知（Advice）在方法执行的什么实际（when:方法前/方法后/方法前后）做什么（what:增强的功能），就是切面这个类中的代码块

• 织入（Weaving） 把切面加入到对象，并创建出代理对象的过程。（由 Spring 来完成）

2.4 Spring Aop中的通知类型：

• 前置通知(Before Advice): 在目标方法被调用前调用通知功能；相关的类org.springframework.aop.MethodBeforeAdvice

• 后置通知(After Advice): 在目标方法被调用之后调用通知功能；相关的类org.springframework.aop.AfterReturningAdvice

• 返回通知(After-returning): 在目标方法成功执行之后调用通知功能；

• 异常通知(After-throwing): 在目标方法抛出异常之后调用通知功能；相关的类org.springframework.aop.ThrowsAdvice

• 环绕通知(Around): 把整个目标方法包裹起来，在被调用前和调用之后分别调用通知功能相关的类org.aopalliance.intercept.MethodInterceptor

2.5 spring Aop实现的基础

spring aop实现是通过动态代理的方式实现的，动态代理避免了静态代理需要定义冗余的代理类，实现类，动态代理分为两种，第一种就是jdk 动态代理，第二种就是cglib 动态代理，aop 实现同时采用两种代理模式。

两种动态代理的区别：

jdk动态代理模式 ：采用反射的方式，只能对实现接口的类生成代理，具有加载速度快，执行效率低的特点。

cglib动态代理模式：采用的asm，通过字节码形式实现，是针对类实现代理，具有加载速度慢，执行效率高的特点。

2.6 基于AspectJ实现基础上需要连接的几个内置注解

execution函数用于匹配方法执行的连接点，语法为：

execution(方法修饰符(可选) 返回类型 方法名(参数) 异常模式(可选))

参数部分允许使用通配符：

* 匹配任意字符，但只能匹配一个元素

.. 匹配任意字符，可以匹配任意多个元素（零到若干个都可以），必须和*联合使用

"execution(public * com.qli.controller.TestController.*(..))"

@Pointcut(value = "@annotation(com.qli.config.RequestLog)")任何方法使用RequestLog注解都会触发该切面，进入切点

3.实现

具体的案例，在spring boot中实现spring aop，包含的内容有通过aop实现自定义注解，听起来就很高大上，其实懂了之后，感觉就那样，不过在新入门的程序员面前还是可以装起来的，还有就是多个切面的时候的执行顺序

3.1导入依赖

 <!--引入父依赖
         当前工程 继承 父类工程  spring-boot-starter-parent pom
    -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/>
    </parent>
​
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
​
​
    <dependencies>
​
    <!-- web相关依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
​
    </dependency>
​
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
​
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
    </dependencies>

3.2创建切面

package com.qli.config;
​
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
​
import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
​
@Aspect
@Component
@Order(2)
public class LogAspect {
    @Pointcut("execution(public * com.qli.controller.TestController.*(..))")
    public void webLog(){}
​
    @Before("webLog()")
    public void deBefore(JoinPoint joinPoint) throws Throwable {
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        // 记录下请求内容
        System.out.println("URL : " + request.getRequestURL().toString());
        System.out.println("HTTP_METHOD : " + request.getMethod());
        System.out.println("IP : " + request.getRemoteAddr());
        System.out.println("CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        System.out.println("ARGS : " + Arrays.toString(joinPoint.getArgs()));
​
    }
​
    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable {
        // 处理完请求，返回内容
        System.out.println("方法的返回值 : " + ret);
    }
​
    //后置异常通知
    @AfterThrowing("webLog()")
    public void throwss(JoinPoint jp){
        System.out.println("方法异常时执行.....");
    }
​
    //后置最终通知,final增强，不管是抛出异常或者正常退出都会执行
    @After("webLog()")
    public void after(JoinPoint jp){
        System.out.println("方法最后执行.....");
    }
​
    //环绕通知,环绕增强，相当于MethodInterceptor
    @Around("webLog()")
    public Object arround(ProceedingJoinPoint pjp) {
        System.out.println("方法环绕start.....");
        try {
            Object o =  pjp.proceed();
            System.out.println("方法环绕proceed，结果是 :" + o);
            return o;
        } catch (Throwable e) {
            e.printStackTrace();
            return null;
        }
    }
}

3.3 创建控制类

package com.qli.controller;
import com.qli.config.RequestLog;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
​
@RestController
public class TestController {
​
    @RequestMapping("/requestLog")
    public String requestLog(){
        return "first controller";
    }
}

执行结果：

方法环绕start.....
URL : http://localhost:8088/requestLog
HTTP_METHOD : GET
IP : 0:0:0:0:0:0:0:1
CLASS_METHOD : com.qli.controller.TestController.requestLog
ARGS : []
方法环绕proceed，结果是 :first controller
方法最后执行.....
方法的返回值 : first controller

上边是创建一个切面通过 @Pointcut("execution(public * com.qli.controller.TestController.*(..))")注解来限制切入点是controller包下TestController控制类下所有的方法都是切入点，那么congtroller包下其他控制类的方法就是连接点。

3.4创建自定义注解

3.4.1自定义注解之前需要了解的概念

• @Target注解，是专门用来限定某个自定义注解能够被应用在哪些Java元素上面的。它使用一个枚举类型定义如下：

  public enum ElementType {
      /** 类，接口（包括注解类型）或枚举的声明 */
      TYPE,
  ​
      /** 属性的声明 */
      FIELD,
  ​
      /** 方法的声明 */
      METHOD,
  ​
      /** 方法形式参数声明 */
      PARAMETER,
  ​
      /** 构造方法的声明 */
      CONSTRUCTOR,
  ​
      /** 局部变量声明 */
      LOCAL_VARIABLE,
  ​
      /** 注解类型声明 */
      ANNOTATION_TYPE,
  ​
      /** 包的声明 */
      PACKAGE
  }

• @Retention注解，翻译为持久力、保持力。即用来修饰自定义注解的生命力。

  public enum RetentionPolicy {
      /**
       * Annotations are to be discarded by the compiler.
       * （注解将被编译器忽略掉）
       */
      SOURCE,
  ​
      /**
       * Annotations are to be recorded in the class file by the compiler
       * but need not be retained by the VM at run time.  This is the default
       * behavior.
       * （注解将被编译器记录在class文件中，但在运行时不会被虚拟机保留，这是一个默认的行为）
       */
      CLASS,
  ​
      /**
       * Annotations are to be recorded in the class file by the compiler and
       * retained by the VM at run time, so they may be read reflectively.
       * （注解将被编译器记录在class文件中，而且在运行时会被虚拟机保留，因此它们能通过反射被读取到）
       * @see java.lang.reflect.AnnotatedElement
       */
      RUNTIME
  }

• @Documented注解，是被用来指定自定义注解是否能随着被定义的java文件生成到JavaDoc文档当中。

3.5 实现

3.5.1 创建自定义注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface RequestLog {
    String desc() default "无信息";
}

3.5.2 创建自定义注解时候后将会触发的切面

package com.qli.config;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
@Order(1)
public class RequestAspect {
    @Pointcut(value = "@annotation(com.qli.config.RequestLog)")
    public void access() {

    }

    @Before("access()")
    public void deBefore(JoinPoint joinPoint) throws Throwable {
        System.out.println("second before");
    }

    @Around("@annotation(requestLog)")
    public Object around(ProceedingJoinPoint pjp, RequestLog requestLog) {
        //获取注解里的值
        System.out.println("second around:" + requestLog.desc());
        try {
            return pjp.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            return null;
        }
    }
}

3.5.3 在控制层添加

@RequestLog(desc = "second")
    @RequestMapping("/second")
    public Object second(){
        return "second controller";
    }

执行结果

second around:second
second before

如果将两个切面的切入点都包含有second这个方法的时候，浏览器访问http://localhost:8088/second的执行结果如下

second around:second
second before
方法环绕start.....
URL : http://localhost:8088/second
HTTP_METHOD : GET
IP : 0:0:0:0:0:0:0:1
CLASS_METHOD : com.qli.controller.TestController.second
ARGS : []
方法环绕proceed，结果是 :second controller
方法最后执行.....
方法的返回值 : second controller

执行顺序：

spring aop就是一个同心圆，要执行的方法为圆心，最外层的order最小。从最外层按照AOP1、AOP2的顺序依次执行doAround方法，doBefore方法。然后执行method方法，最后按照AOP2、AOP1的顺序依次执行doAfter、doAfterReturn方法。也就是说对多个AOP来说，先before的，一定后after。