AOP(面向切面编程)全称Aspect Oriented Programminge

        AOP就是把系统中重复的代码抽取出来，单独开发，在系统需要时，使用动态代理技术，在不修改源码的基础上，将单独开发的功能通知织入(应用)到系统中的过程，完成完整的代码逻辑

        优点:减少重复代码、提高开发效率、提高维护性

AOP相关术语:

        1. Joinnoint(连接点):连接点是指那些被拦截到的点。这些点指的是方法，spring只支持方法类型的连接点。指切面在系统中要应用的位置,spring 中能够使用切面的位置为方法，所以连接指方法连接点指要调用某个方法时拦截到对这个方法的调用，做一些其他事情然后再执行目标方法拦截到的方法就是连接点。

        2. Pointcut(切入点):指我们要对那些Joinpoint进行拦截的定义,spring中使用切入点表达式定义(切入点表达式)简单理解，切入点是对连接点的描述，它将多个连接点进行概括的定义。

        3. Advice(通知):指拦截到joinpoint之后所要做的事情就是通知

         通知:前置通知、后置通知、异常通知、最终通知、环绕通知

        4. Target(目标对象):代理的目标对象

        5. Weaving(织入):将通知应用到切入点的过程

        6.Proxy(代理) :代理对象 

        7. Aspect(切面) :切入点和通知的总称

         简单说AOP是，在系统执行某个方法时，在执行这个方法前或方法后去执行另一段程序(另一段程序就是AOP中的通知)，而拦截这个方法的定义可以称为切入点

        

SprinaAOP.的使用步骤(基于注解):
        1.引入spring依赖包和aop.植入依赖包 Aspect Weaver包或者spring-aspects包:

         2．创建切面类
        3．将切面类交个spring进行管理,使用@Component注解
        4．将切面类设置为一个切面,使用@Aspect注解
        5．编写切入点poincut，使用切入点表达式定义连接点(方法)。
        Execution(表达式)
        表达式写法:访问修饰符返回类型包名.包名.类名.方法名(参数列表)//指定那些方法做为切入点(拦截那些方法)

使用具体方法方式:@PointCut（ execution(* com.xxx.service.UserService.addUser(..))）

了解更多Execution表达式Introduction to Pointcut Expressions in Spring | Baeldung

        6.编写相关通知

        7.切面源码

       

            在看切面源码前，我们需要提前把所需的环境先准备好，这里看一下我的结构：

        

这块我直接用service包下的UserService接口的addUser()和它的实现类UserServiceImpl来进行体现上述Advice(通知).

先看UserService接口

package com.xxx.service;public interface UserService {public String addUser(int id,String name);public void delUser();
}

UserServiceImpl

package com.xxx.service.impl;import com.xxx.service.UserService;
import org.springframework.stereotype.Service;@Service
public class UserServiceImpl implements UserService {@Overridepublic String addUser(int id,String name) {System.out.println("UserServiceImpl--------addUser");return "你好:"+name;}@Overridepublic void delUser() {System.out.println("UserServiceImpl--------delUser");}
}

下面我们来看最主要的aspects包下的UserAspects类，该类就是对上述addUser()方法进行前置通知、后置通知、异常通知、最终通知、环绕通知。

首先咱们先看前置通知：

在前置通知前首先我们执行一下程序，结果如下：

然后我们加上前置通知代码后，再看结果：

package com.xxx.aspects;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;@Aspect       //切面注解
@Component    //交给Spring进行控制翻转
@EnableAspectJAutoProxy  //开启spring的切面自动代理功能
public class UserAspects {@Pointcut("execution(* com.xxx.service.UserService.addUser(..))")public void pointCuts() {}/*前置通知*/@Before("pointCuts()")public void beforeAdvice(){System.out.println("前置被通知执行");}
}

 再加上前置通知后，结果如下：

下面我们来看后置通知，通过上述的前置通知，我们可以推断出后置通知应该就是addUser()执行后进行通知的，下面我们来看看是不是这样的。首先和之前一样，加上后置通知的代码：

package com.xxx.aspects;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;@Aspect       //切面注解
@Component    //交给Spring进行控制翻转
@EnableAspectJAutoProxy  //开启spring的切面自动代理功能
public class UserAspects {@Pointcut("execution(* com.xxx.service.UserService.addUser(..))")public void pointCuts() {}/*前置通知*/@Before("pointCuts()")public void beforeAdvice(){System.out.println("前置被通知执行");}/*后置通知*/@AfterReturning("pointCuts()")public void AfterAdvice(){System.out.println("后置被通知执行");}
}

加上后置通知后，运行结果如下：

下面我们来看异常通知，字面意思就是，在程序出现异常的时候就会出现该通知，下面我们就看相关的代码:

package com.xxx.aspects;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;@Aspect       //切面注解
@Component    //交给Spring进行控制翻转
@EnableAspectJAutoProxy  //开启spring的切面自动代理功能
public class UserAspects {@Pointcut("execution(* com.xxx.service.UserService.addUser(..))")public void pointCuts() {}/*前置通知*/@Before("pointCuts()")public void beforeAdvice(){System.out.println("前置被通知执行");}/*后置通知*/@AfterReturning("pointCuts()")public void AfterAdvice(){System.out.println("后置被通知执行");}/*异常通知*/@AfterThrowing("pointCuts()")public void throwAdvice(){System.out.println("异常通知执行");}
}

由于异常通知是在程序出现异常的时候才会执行该通知，那么咱们就给addUser()中来个异常

下面我们来看运行结果：

这儿需要注意的是异常通知和后置通知只能执行其中一个，通知的执行过程类似于下面这种：

下面的最终通知就不写了，它前面所述的其它通知类似，环绕通知就是一个可以做它们4个做的事情，下面直接把源码给出来看一下就行了：

        

package com.xxx.aspects;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;@Aspect       //切面注解
@Component    //交给Spring进行控制翻转
@EnableAspectJAutoProxy  //开启spring的切面自动代理功能
public class UserAspects {@Pointcut("execution(* com.xxx.service.UserService.addUser(..))")public void pointCuts() {}/*前置通知*/@Before("pointCuts()")public void beforeAdvice(){System.out.println("前置被通知执行");}/*后置通知*/@AfterReturning("pointCuts()")public void AfterAdvice(){System.out.println("后置被通知执行");}/*异常通知*/@AfterThrowing("pointCuts()")public void throwAdvice(){System.out.println("异常通知执行");}/*最终通知*/@After("pointCuts()")public void finallyAdvice(){System.out.println("最终通知执行");}/*环绕通知就是可以把上面四个通知都可以实现* */@Around("pointCuts()")public String aroundAdvice(ProceedingJoinPoint proceedingJoinPoint){try {System.out.println("环绕通知----前置被通知执行");String proceeds = (String) proceedingJoinPoint.proceed();return proceeds;} catch (Throwable e) {e.printStackTrace();}return null;}}