快速入门Springboot+AOP实现切面处理请求Demo

什么是Aop：

-面向切面编程，将影响多个公共类的行为封装成一个单独的可重复使用的模块，简单的说就是将与业务无关但是为业务模块所公共使用的逻辑封装起来，减少重复代码的创建，更便于维护。

Aop的使用场景：

-权限校验

-日志处理

-事务

等。。

Aop相关有哪些注解：

@Aspect: 切面类定义，作用于类上

@Pointcut：定义一个切点，后面跟随一个表达式，自定义注解等（可以理解为切面的作用域），下面的操作都是围绕切点来进一步处理的。

@Around：环绕通知，作用于通知前与通知后（如计算接口消耗时间）

@Before: 前置通知，在方法执行之前执行，织入相关代码

@After: 后置通知，在方法执行之后执行，织入相关代码

@AfterReturning: 返回通知，在方法返回结果之后执行（一般用于对返回值做进一步处理）

@AfterThrowing：异常通知，在方法抛出异常后逻辑处理

Aop的快速简单使用步骤：

1. 定义一个切面类 在类上加上@Aspect注解

2. 定义一个切点（围绕切点处理）

3. 使用通知点：如@Before，@After等（在切点的过程中做处理）

4. 定义一个类（在切点定义的作用范围内）

Pom文件的依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>

<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.5</version>
</dependency>
------AopLogAspect切面类----
package com.aop.demo;
import com.google.gson.Gson;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
//步骤1
@Aspect
@Component
public class AopLogAspect {
private final static Logger logger = LoggerFactory.getLogger(AopLogAspect.class);

//步骤2
    @Pointcut("execution(public * com.aop.demo.controller..*.*(..))")
public void userLog(){
    }
//步骤3
    @Before("userLog()")
public void doBefore(JoinPoint joinPoint){
        ServletRequestAttributes attributes = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
logger.info("---------strart------");
logger.info("URL   :{}",request.getRequestURL().toString());
logger.info("Class Mestoh  :{}", joinPoint.getSignature().getDeclaringTypeName());
logger.info("request Args  :{}", new Gson().toJson(joinPoint.getArgs()));
    }
//步骤4
    @After("userLog()")
public void doAfter() {
logger.info("---------end------");
    }
}
---------测试的TestAopController----------
package com.aop.demo.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

//步骤5
@RestController
public class TestAopController {
private final static Logger logger = LoggerFactory.getLogger(TestAopController.class);
@GetMapping("/user")
public String testGet(@RequestParam("username") String username, @RequestParam("password") String passwrod){
logger.info("I`m COME IN...");
return "Success";
    }
}

测试结果：

Aop相关注解执行顺序：

@Around-@Before-@After-程序无异常-@AfterReturning，有异常就走@AfterThorwing

Aop检验不通过，如何让程序无法进入核心代码：

@Before：只有在程序出异常的时候才会阻止程序进入核心代码，正常情况下无法阻止当前线程进入连接点

@Around：在连接点前后都能执行，该注解的方法入参ProceedingJoinPoint类中封装了proceed（）方法，当检验不通过时，则不调用此方法，就不会进入连接点。检验通过则调用此方法，就可以让当前线程从aop方法转入到连接点的核心代码处。