1通过注解的方式实现

  1.  <dependency>
  2.       <groupId>org.springframework.boot</groupId>
  3.       <artifactId>spring-boot-starter-aop</artifactId>
  4. </dependency>

1.1定义注解

  1. /**
  2.  * 自定义操作日志注解
  3.  * @author wu
  4.  */
  5. @Target(ElementType.METHOD) //注解放置的目标位置,METHOD是可注解在方法级别上
  6. @Retention(RetentionPolicy.RUNTIME) //注解在哪个阶段执行
  7. @Documented
  8. public @interface LogAction {
  9.     String operModul() default ""; // 操作模块
  10.     String operType() default "";  // 操作类型
  11.     String operDesc() default "";  // 操作说明
  12. }

1.2创建切面类记录操作日志

  1. /**
  2.  * 切面处理类，操作日志异常日志记录处理
  3.  *
  4.  * @author wu
  5.  * @date 2019/03/21
  6.  */
  7. @Aspect // 表示这是一个切面
  8. @Component
  9. public class OperLogAspect {
  11.     /**
  12.      * 操作版本号
  13.      * <p>
  14.      * 项目启动时从命令行传入，例如：java -jar xxx.war --version=201902
  15.      * </p>
  16.      */
  17.     @Value("${version}")
  18.     private String operVer;
  20.     @Autowired
  21.     private OperationLogService operationLogService;
  23.     @Autowired
  24.     private ExceptionLogService exceptionLogService;
  26.     /**
  27.      * 设置操作日志切入点 记录操作日志 在注解的位置切入代码 此处可以直接写注解的名称
  28.      */
  29.     @Pointcut("@annotation(com.hyd.zcar.cms.common.utils.annotation.LogAction)")
  30.     public void operLogPoinCut() {
  31.     }
  33.     /**
  34.      * 设置操作异常切入点记录异常日志 扫描所有controller包下操作 通过扫描的方式
  35.      */
  36.     @Pointcut("execution(* com.hyd.zcar.cms.controller..*.*(..))") 
  37.     public void operExceptionLogPoinCut() {
  38.     }
  39.     @Before(value = "operLogPoinCut()") // 通过注解的方式
  40.     public void saveOperLog(JoinPoint joinPoint) {
  41.         Signature signature = joinPoint.getSignature();
  42.         System.out.println(signature);
  43.         List<Object> list = Arrays.asList(joinPoint.getArgs()); // 获取到的参数
  44.         System.out.println(list);
  45.     }
  47.     // 也可以不写operLogPoinCut 方法，直接这样写也可以
  49.     @Before(value = "@annotation(LogAction)")
  50.     public void saveOperLog(JoinPoint joinPoint) {
  51.         Signature signature = joinPoint.getSignature();
  52.         System.out.println(signature);
  53.         List<Object> list = Arrays.asList(joinPoint.getArgs());
  54.         System.out.println(list);
  55.     }
  57.     ==================几种Aop的方式==============
  59.          /**
  60.      * 前置通知
  61.      *
  62.      * @param joinPoint 包含了目标方法的关键信息
  63.      * @Before 注解标识这是一个前置通知，既在目标方法执行之前执行，注解中免去要填入切点
  64.      */
  65.     @Before(value = "@annotation(LogAction)")
  66.     public void before(JoinPoint joinPoint) {
  68.         Signature signature = joinPoint.getSignature();
  69.         String name = signature.getName();
  70.         System.out.println(name + "方法开始执行了。。。");
  72.     }
  75.     /**
  76.      * 后置通知
  77.      *
  78.      * @param joinPoint 包含了目标方法的关键信息
  79.      * @After 注解标识这是一个后置通知，既在目标方法执行之后执行，注解中免去要填入切点
  80.      */
  81.     @After(value = "@annotation(LogAction)")
  82.     public void after(JoinPoint joinPoint) {
  84.         Signature signature = joinPoint.getSignature();
  85.         String name = signature.getName();
  86.         System.out.println(name + "方法执行结束了。。。");
  88.     }
  91.     /**
  92.      * 返回通知
  93.      *
  94.      * @param joinPoint 包含了目标方法的关键信息
  95.      * @AfterReturning 注解标识这是一个返回通知，既有目标方法有返回值的时候才会触发，
  96.      * 该注解中returning属性标识目标方法返回值的变量名，这个需要和参数一一对应，
  97.      * 注意，目标方法的返回值类型和这里方法的返回值参数可以为object
  98.      */
  99.     @AfterReturning(value = "@annotation(LogAction)", returning = "r")
  100.     public void afterReturning(JoinPoint joinPoint, Object r) {
  102.         Signature signature = joinPoint.getSignature();
  103.         String name = signature.getName();
  104.         System.out.println(name + "方法返回" + r);
  106.     }
  109.     /**
  110.      * 异常通知
  111.      *
  112.      * @param joinPoint 包含了目标方法的关键信息
  113.      * @param e         目标方法所抛出的异常，注意，这个参数必须是目标方法所抛出的异常，
  114.      *                  或者所抛出异常的异常父类，只有这样，才会捕获，如果想拦截所有，
  115.      *                  参数类型声明为Exception
  116.      * @AfterThrowing 注解标识这是一个异常通知，改方法会繁华一个异常e，
  117.      */
  118.     @AfterThrowing(value = "@annotation(LogAction)", throwing = "e")
  119.     public void afterThrowing(JoinPoint joinPoint, Exception e) {
  121.         Signature signature = joinPoint.getSignature();
  122.         String name = signature.getName();
  123.         System.out.println(name + "方法返回" + e);
  124.     }
  126.     /**
  127.      * 环绕通知
  128.      * <p>
  129.      * 环绕通知是集大成这，可以用环绕通知实现上面的四个通知，这个方法的核心有点类似于在这里通过反射这些方法
  130.      *
  131.      * @param pjp 包含了目标方法的关键信息
  132.      * @Around 注解标识这是一个环绕通知
  133.      */
  134.     @Around(value = "@annotation(LogAction)")
  135.     public Object Around(ProceedingJoinPoint pjp) {
  136.         Object proceed = null;
  137.         try {
  138.             System.out.println("环绕通知里面的【前置通知】。。。");
  139.             //这个相当于method.invoke方法，我们可以在这个方法的前后分别添加日志，就相当于前置通知和后置通知
  140.             proceed = pjp.proceed();   //这里相当于执行目标方法 如果不写目标方法就不会执行
  141.             // proceed是目标方法的返回值        
  142. System.out.println("环绕通知里面的【后置通知】...");
  144.         } catch (Throwable throwable) {
  146.             System.out.println("这里是执行环绕通知里面的【异常通知】。。。");
  147.             throwable.printStackTrace();
  148.         }
  149.         finally {
  150.                 System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
  151.             }
  153.         return proceed;
  154.     }
  160. }

2.通过配置实现更加灵活

  1. 1.概述
  2.     问题:
  3.         当我们配置了环绕通知之后,切入点方法没有执行,而通知方法执行了
  4.     分析:
  5.         通过对比动态代理的环绕通知代码,发现动态代理的环绕通知有明确的切入点方法调用.而我们的没有
  6.     解决:
  7.         Spring框架为我们提供了一个接口,proceedingJoinPoint.该接口有一个方法proceed()此方法就相当于明确调用切入点方法.
  8.         该接口可以作为环绕通知的方法参数,在程序执行时,Spring框架会为我们提供该接口的实现类供我们使用
  10.     Spring中的环绕通知:
  11.     它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式
  13. 2. 使用
  14.     2.1 基于注解:
  15.         @Aspect
  16.         public class AnnotationAudienceAround{
  18.             //使用@Pointcut注解声明切入点表达式
  19.             @Pointcut("execution(* com.qin.util.*.*(..))")
  20.             public void pt1(){}
  22.             @Around("pt1()")
  23.             public Object aroundPringLog(ProceedingJoinPoint pjp){
  24.             Object rtValue = null;
  25.             try{
  26.                 Object[] args = pjp.getArgs();//得到方法执行所需的参数
  28.                 System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");
  30.                 rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）
  32.                 System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");
  34.                 return rtValue;
  35.             }catch (Throwable t){
  36.                 System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
  37.                 throw new RuntimeException(t);
  38.             }finally {
  39.                 System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
  40.             }
  41.             }
  42.         }
  44.     2.2 基于XML配置文件:
  45.         1. 通知类.
  46.         //去掉了所有的注解
  47.         public class XmlAudienceAround{
  49.             public Object aroundPringLog(ProceedingJoinPoint pjp){
  50.             Object rtValue = null;
  51.             try{
  52.                 Object[] args = pjp.getArgs();//得到方法执行所需的参数
  54.                 System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");
  56.                 rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）
  58.                 System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");
  60.                 return rtValue;
  61.             }catch (Throwable t){
  62.                 System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
  63.                 throw new RuntimeException(t);
  64.             }finally {
  65.                 System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
  66.             }
  67.             }
  68.         }
  70.         2. 在xml文件中配置
  71.             <!--声明bean-->
  72.             <bean name="xmlAudienceAround" class="com.qin.util.XmlAudienceAround"/>
  73.             <!--配置切面及通知-->
  74.             <aop:config>
  75.             <aop:aspect ref="xmlAudienceAround">
  76.                 <aop:pointcut id="pt1" expression="execution(* com.qin.util.*.*(..))"/>
  77.                 <aop:around method="aroundPringLog" pointcut-ref="pt1"/> 对于切面调用的什么方法
  78.             </aop:aspect>
  79.             </aop:config>
  81.                 3.在main方法中加载配置文件
  83.                  ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("配置文件地址");
  84. 下面还有一句，不太清楚

3.在接口方法上使用