简单介绍：

AOP：Aspect Oriented Programming (面向切面编程、面向方面编程)，其实就是面向特定方法编程。

场景：

比如现在有一个需求，我要统计每一个业务方法的耗时时长，

我们只需在业务方法的前面获取一个开始时间，在方法的后面再获取一个结束时间，然后将两时间相减就能得出耗时时长。

这样做当然没问题，但是在一个项目中，业务方法是很多的，如果每次都这样操作，那工作量是非常大的，我们需要换一种方式实现。

我们就可以用到springAop技术

核心：在不惊动原始代码的基础上增强功能。

我们需要统计业务方法的耗时，可以创建一个模板方法，将记录耗时时长的公共的代码放入模板方法。

                                     

原始方法就是业务方法，面向这种特定方法的编程就是面向切面编程。

这个模板方法中定义的逻辑就是创建出来的代理对象方法的逻辑。

实现：

动态代理是面向切面编程最主流的实现。而SpringAOP是Spring框架的高级技术，旨在管理bean对象的过程中，主要通过底层的动态代理机制，对特定的方法进行编程。

编写AOP程序：

针对特定方法根据业务需要进行编程

我们需要创建一个切面类，在类中定义模板方法，并把类交给spring管理

@Component
@Aspect //当前类为切面类
@Slf4j
public class TimeAspect {

    @Around("execution(* com.itheima.service.*.*(..))") 
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        //记录方法执行开始时间
        long begin = System.currentTimeMillis();

        //执行原始方法
        Object result = pjp.proceed();

        //记录方法执行结束时间
        long end = System.currentTimeMillis();

        //计算方法执行耗时
        log.info(pjp.getSignature()+"执行耗时: {}毫秒",end-begin);

        return result;
    }
}

pjp.proceed() 执行原始方法，原始方法可能有返回值，所以最后要把返回值retrun。通过pjp.getSignature() 可以获取原始方法的名称，这样就可以具体知道是哪个方法耗时的时间。

在@Around注解中有个excution表达式，表示对哪些方法进行增强，* com.itheima.service.*.*(..)，

* 表示方法的返回值  ，后面的是包名，在任意接口的任意方法上执行。(..)表示方法的形参也是任意的。

---

AOP核心概念：

①连接点：JointPoint ，可以被AOP控制的方法（暗含方法执行时的相关信息）。

②通知：Advice，指那些重复的逻辑，也就是共性功能（最终体现为一个方法）。

③切入点：PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用。

④切面：Aspect，描述通知与切入点的对应关系（通知+切入点）

⑤目标对象：Target，通知所应用的对象

AOP执行流程：

定义好切入点表达式后，在程序运行时，SpringAOP会自动地基于动态代理技术为目标对象生成一个对应的代理对象，也就是上图的DeptServiceProxy对象， 在对象中已经做了对业务方法的增强。此时，再进行service注入的时候，spring就不会注入原始的目标对象，而是注入生成出来的代理对象，此代理对象已经对业务方法做了增强的处理。

---

AOP进阶：

Spring中AOP的通知类型：

• @Around：环绕通知，此注解标注的通知方法在目标方法前、后都被执行

• @Before：前置通知，此注解标注的通知方法在目标方法前被执行

• @After ：后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行

• @AfterReturning ： 返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行

• @AfterThrowing ： 异常后通知，此注解标注的通知方法发生异常后执行

注意：

① ：@Around环绕通知需要自己调用ProceedingJoinPoint.proceed() 来让原始方法执行，其它通知不需要考虑目标方法执行。

②：@Aound环绕通知方法的返回值，必须指定为Object，来接收原始方法的返回值。

五种通知类型代码演示：

@Slf4j
@Component
@Aspect
public class MyAspect1 {

    //切入点方法（公共的切入点表达式）
    @Pointcut("execution(* com.itheima.service.*.*(..))")
    private void pt(){

    }

    //前置通知（引用切入点）
    @Before("pt()")
    public void before(JoinPoint joinPoint){
        log.info("before ...");

    }

    //环绕通知
    @Around("pt()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        log.info("around before ...");

        //调用目标对象的原始方法执行
        Object result = proceedingJoinPoint.proceed();
        //原始方法在执行时：发生异常
        //后续代码不在执行

        log.info("around after ...");
        return result;
    }

    //后置通知
    @After("pt()")
    public void after(JoinPoint joinPoint){
        log.info("after ...");
    }

    //返回后通知（程序在正常执行的情况下，会执行的后置通知）
    @AfterReturning("pt()")
    public void afterReturning(JoinPoint joinPoint){
        log.info("afterReturning ...");
    }

    //异常通知（程序在出现异常的情况下，执行的后置通知）
    @AfterThrowing("pt()")
    public void afterThrowing(JoinPoint joinPoint){
        log.info("afterThrowing ...");
    }
}

通知顺序：

默认按照切面类的类名字母排序：

• 目标方法前的通知方法：字母排名靠前的先执行

• 目标方法后的通知方法：字母排名靠前的后执行

一般我们通过@Order注解可以控制通知的执行顺序

@Slf4j
@Component
@Aspect
@Order(2)  //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect2 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }

    //后置通知 
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect2 -> after ...");
    }
}

切入点表达式：

作用：主要用来决定项目中的哪些方法需要加入通知。

它的常见形式有两种：

①execution(……)：

根据方法的签名来匹配

execution(访问修饰符?  返回值  包名.类名.?方法名(方法参数) throws 异常?)

其中带?的表示可以省略的部分

• 访问修饰符：可省略（比如: public、protected）

• 包名.类名： 可省略

• throws 异常：可省略（注意是方法上声明抛出的异常，不是实际抛出的异常）

示例：

@Before("execution(void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))")

②@annotation(……) ：

根据注解匹配

自定义注解：Log           一般我们记录操作日志需要用到  自定义注解 + 环绕通知

//自定义注解
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
    public String title() ;								// 模块名称
    public OperatorType operatorType() default OperatorType.MANAGE;	// 操作人类别
    public int businessType() ;     // 业务类型（0其它 1新增 2修改 3删除）
    public boolean isSaveRequestData() default true;   // 是否保存请求的参数
    public boolean isSaveResponseData() default true;  // 是否保存响应的参数
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Import(value = LogAspect.class)            // 通过Import注解导入日志切面类到Spring容器中
public @interface EnableLogAspect {  //这个注解可以添加到启动类上，程序启动时可以扫描到LogAspect这个切面类
}


@Aspect
@Component
@Slf4j
public class LogAspect {   //环绕通知切面类定义

    @Autowired
    private AsyncOperLogService asyncOperLogService;

    @Around("@annotation(sysLog)")
    public Object doAroundAdvice(ProceedingJoinPoint joinPoint, Log sysLog){
        // 构建前置参数
        SysOperLog sysOperLog = new SysOperLog() ;

        LogUtil.beforeHandleLog(sysLog, joinPoint, sysOperLog);  //封装日志信息
        Object proceed = null;
        try {
            proceed = joinPoint.proceed();              // 执行业务方法
            LogUtil.afterHandlLog(sysLog,proceed, sysOperLog, 0, null);   //封装日志信息
        } catch (Throwable e) {      // 代码执行进入到catch中，业务方法执行产生异常
            e.printStackTrace();
            LogUtil.afterHandlLog(sysLog,proceed, sysOperLog, 1, e.getMessage()); //封装日志信息
            throw new RuntimeException();
        }
        // 保存日志数据
        asyncOperLogService.saveSysOperLog(sysOperLog);
        return proceed ;
    }
}

连接点：

在Spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法名、方法参数等。

• 对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint类型

• 对于其他四种通知，获取连接点信息只能使用JoinPoint，它是ProceedingJoinPoint的父类型

@Slf4j
@Component
@Aspect
public class MyAspect7 {

    @Pointcut("@annotation(com.itheima.anno.MyLog)")
    private void pt(){}
   
    //前置通知
    @Before("pt()")
    public void before(JoinPoint joinPoint){
        log.info(joinPoint.getSignature().getName() + " MyAspect7 -> before ...");
    }
    
    //后置通知
    @Before("pt()")
    public void after(JoinPoint joinPoint){
        log.info(joinPoint.getSignature().getName() + " MyAspect7 -> after ...");
    }

    //环绕通知
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        //获取目标类名
        String name = pjp.getTarget().getClass().getName();
        log.info("目标类名：{}",name);

        //目标方法名
        String methodName = pjp.getSignature().getName();
        log.info("目标方法名：{}",methodName);

        //获取方法执行时需要的参数
        Object[] args = pjp.getArgs();
        log.info("目标方法参数：{}", Arrays.toString(args));

        //执行原始方法
        Object returnValue = pjp.proceed();

        return returnValue;
    }
}