Spring Aop切面使用 深入浅出

@top[]

1.背景

1.在实际开发的过程中，我们会发现一些通用性的代码开发实际上是存在着大量的重复性的工作的：
  比如方法的入参和出参的日志捕获打印，实际上我们是不需要每个方法都去写一次的；
2.还有一些对于整体系统规范化的要求等，可能需要统一管理，比如监控调用,SQL的打印处理等等，
  需要统一处理
3.这里我们交给AOP，也就是“面向切面编程”的问题；   
4.下面我们先通过几个demo了解一下Spring AOP在实际应用中扮演的角色和解决的问题 

2.先上案例code

2.1.Pom.xml关于jar包版本的引入

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <!--因为demo-spring-boot-aop 属于其中的一个模块，我们引入其parent，其本质上就是定义了sprigboot的 parent的版本-->
  <parent>
    <artifactId>demo-spring-cloud</artifactId>
    <groupId>com.gaoxinfu.demo.spring.cloud</groupId>
    <version>1.0-SNAPSHOT</version>
  </parent>

  <groupId>com.gaoxinfu.demo.spring.cloud</groupId>
  <artifactId>demo-spring-cloud-aop</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>demo-spring-cloud-aop</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>

    <!--Spring Boot web开发(controller) 必须要引入的工程-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!--lombok 主要是对象的编译帮助提供一些get set以及构造方法，还有日志的提供-->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
    </dependency>

    <!--因为我们这里演示的aop 面向切面编程，所以这个也必须引入-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

  </dependencies>

  <build>
    <plugins>
      <!--这个主要是springboot 运行的插件-->
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

2.2.创建DAO与DAO的实现

2.2.1.UserDAO

package com.gaoxinfu.demo.spring.cloud.aop.dao;

public interface UserDao {
    public int addUser();

    public String updateUser();

    public void deleteUser();

    public void findUser();

    public void findById();
}

2.2.2.UserDAOImpl

package com.gaoxinfu.demo.spring.cloud.aop.dao.impl;

import com.gaoxinfu.demo.spring.cloud.aop.dao.UserDao;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Repository;


@Slf4j
@Repository
public class UserDaoImpl implements UserDao {

    @Override
    public int addUser() {
        log.info("add User ");
        return 0;
    }

    @Override
    public String updateUser() {
        log.info("update User ");
        return "我是Update结果";
    }

    @Override
    public void deleteUser() {
        log.info("delete User ");
    }

    @Override
    public void findUser() {
        log.info("find User");
        throw new RuntimeException("模拟异常");
    }

    @Override
    public void findById() {
        log.info("find User By Id ");
    }
}

1.上面我们定义了5个不同的方法，主要是为了后面验证不同的AOP应用；

2.3.创建Controller

package com.gaoxinfu.demo.spring.cloud.aop.controller;

import com.gaoxinfu.demo.spring.cloud.aop.dao.UserDao;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Description:
 * @Author: gaoxinfu
 * @Date: 2021-04-07 06:43
 */
@RestController
@Slf4j
@RequestMapping("/user")
public class UserController {

    @Autowired
    UserDao userDao;

    @GetMapping(value = "/add")
    public String addUser(){
        userDao.addUser();
        return "新增用户";
    }

    @GetMapping(value = "/update")
    public String updateUser(){
        userDao.updateUser();
        return "更新用户";
    }

    @GetMapping(value = "/delete")
    public String deleteUser(){
        userDao.deleteUser();
        return "删除用户";
    }

    @GetMapping(value = "/find")
    public String findUser(){
        userDao.findUser();
        return "发现用户";
    }

    @GetMapping(value = "/findById")
    public String findById(){
        userDao.findById();
        return "发现用户";
    }

}

2.4.定义我们的切面拦截类:UserAspect

package com.gaoxinfu.demo.spring.cloud.aop.aspect;


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author gaoxinfu
 */
@Aspect
@Component
public class UserAspect {

    /**
     * 前置通知:就是在执行方法 之前去进行操作；
     */
    @Before("execution(* com.gaoxinfu.demo.spring.cloud.aop.dao.UserDao.addUser(..))")
    public void before(){
        System.out.println("前置通知....");
    }

    /**
     * 后置通知：这里就是在走到return执行语句的时候，我们进行一些操作
     * returnVal,切点方法执行后的返回值
     */
    @AfterReturning(value="execution(* com.gaoxinfu.demo.spring.cloud.aop.dao.UserDao.updateUser(..))",returning = "returnVal")
    public void AfterReturning(Object returnVal){
        System.out.println("后置通知...."+returnVal);
    }


    /**
     * 环绕通知
     * @param joinPoint 可用于执行切点的类
     * @return
     * @throws Throwable
     */
    @Around("execution(* com.gaoxinfu.demo.spring.cloud.aop.dao.UserDao.deleteUser(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知前....");
        Object obj= (Object) joinPoint.proceed();
        System.out.println("环绕通知后....");
        return obj;
    }

    /**
     * 抛出通知
     * @param e
     */
    @AfterThrowing(value="execution(* com.gaoxinfu.demo.spring.cloud.aop.dao.UserDao.findUser(..))",throwing = "e")
    public void afterThrowable(Throwable e){
        System.out.println("出现异常:msg="+e.getMessage());
    }

    /**
     * 无论什么情况下都会执行的方法,这个其实就是finally执行的代码块
     */
    @After(value="execution(* com.gaoxinfu.demo.spring.cloud.aop.dao.UserDao.findById(..))")
    public void after(){
        System.out.println("最终通知....");
    }
}

1.UserAspect：首先通过@Aspect进行标记为切面拦截的类
2.UserAspect:期次我们需要通过@Component进行注解成Bean的形式，能够被扫描到Spring 容器之中

3.测试验收解析

3.1.前置通知

3.1.1.概念理解

1.简单理解：就是调用方法之前的通知，们这里可以走一些调用方法之前的操作记录 (或者认为调用之前的准备工作)，
  比如：打印调用方法的入参，记录调用方法的开始时间，重新组装入参等等一系列的操作，
  当然我们这里的模拟全部使用日志代替实际的通用性操作；

3.1.2.代码解析

1.调用地址：
  http://localhost:8081/user/add    
2.UserController.addUser-->UserDAO.addUser--->会被UserAspect拦截
  这里的拦截实际上是一个代理，怎么讲，可以认为UserDAO已经被UserAspect进行代理
  当然代理的加载是在项目启动运行的时候的加载的；  

3.1.3.标志：@Before

1.@Before 意味：UserAspect.before方法为被代理对象的前置调用；
2.execution：这里定义了被执行的范围(execute:执行)

3.1.4.执行结果

http://localhost:8081/user/add

1.先执行了UserAspect.before方法中；后执行了UserDAOImpl.addUser方法

3.2.后置通知

3.2.1.概念理解

3.2.2.代码解析

3.2.3.标志：@AfterReturning

3.2.4.执行结果

3.3.环绕通知

3.2.1.概念理解

3.2.2.代码解析

3.2.3.标志：@Around

3.2.4.执行结果

3.4.异常通知

3.2.4.执行结果

3.3.异常通知

3.2.1.概念理解

3.2.2.代码解析

3.2.3.标志：@AfterThrowing

3.2.4.执行结果

3.5.最终通知

3.2.4.执行结果

3.3.环绕通知

3.2.1.概念理解

3.2.2.代码解析

3.2.3.标志：@After

3.2.4.执行结果

4.代码demo地址

https://gitee.com/gaoxinfu_admin/demo-spring-cloud/tree/master/demo-spring-cloud-aop

5.SpringAop的注解解释

5.1.