Spring AOP(1) --基于注解方式配置

1、spring-aop.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.2.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

    <!--扫描aop包下面的注解-->
    <context:component-scan base-package="com.spring.aop"/>

    <!--使Aspect注解生效，自动为匹配的类生成代理对象-->
    <aop:aspectj-autoproxy/>
</beans>

2、LoggingAspect.java

package com.spring.aop.aspect;

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

import java.util.Arrays;
import java.util.List;

/**
 * @author liangd
 * date 2020-11-16 17:40
 * code 把这个类声明为一个切面
 * 1、加入到IOC容器中
 * 2、声明为一个切面
 */
@Order(2)
@Aspect
@Component
public class LoggingAspect {
    /**
     * 声明切入点表达式，重用代码
     * 使用@PointCut来声明表达式
     * 后面其它通知直接应该该方法
     */
    @Pointcut("execution(* com.spring.aop.aspect.MathCalculator.*(..))")
    public void declareJoinPointExpress(){}

    /**
     * 前置通知:在执行方法前执行
     * execution：执行需要需要加入切面的方法
     * execution(public int com.spring.aop.aspect.MathCalculator.add(int ,int)) 此路径只对add方法有效
     * execution(* com.spring.aop.aspect.MathCalculator.*(int ,int)) 表示将该类下的任意修饰符、任意返回值和
     * 带(int,int)参数的方法加入到切面中
     */
//    @Before("execution(public int com.spring.aop.aspect.MathCalculator.*(int ,int))")
    @Before("declareJoinPointExpress()")
    public void beforeMethod(JoinPoint joinPoint) {
        //获取切入点方法名
        String methodName = joinPoint.getSignature().getName();
        //获取切入点方法参数
        List<Object> args = Arrays.asList(joinPoint.getArgs());

        System.out.println("The method " + methodName + " begins with " + args);
    }

    /**
     * 后置通知：在目标方法之后执行（无论是否发生异常），执行的通知
     * 不能访问目标方法执行的结果
     */
//    @After("execution(* com.spring.aop.aspect.MathCalculator.*(int,int))")
    @After("declareJoinPointExpress()")
    public void afterMethod(JoinPoint joinPoint) {
        //获取切入点方法名
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " ends with");
    }

    /**
     * 返回通知:可以访问目标方法执行的结果
     *
     * @param joinPoint 切入点
     * @param result    返回结果
     */
    @AfterReturning(value = "declareJoinPointExpress()",
            returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result) {

        String methodName = joinPoint.getSignature().getName();

        System.out.println("The method " + methodName + " returning with " + result);
    }

    /**
     * 异常通知：在方法抛出异常的时候执行
     */
    @AfterThrowing(value = "declareJoinPointExpress()",
            throwing = "e")
    public void afterThrowing(JoinPoint joinPoint, Exception e) {
        String methodName = joinPoint.getSignature().getName();

        System.out.println("The method " + methodName + " occurs throwing with " + e);
    }

    /**
     * 环绕通知：相当于动态代理的全过程（功能最强大，但并不代表经常使用）
     * <p>
     * 环绕通知需要ProceedingJoinPoint 参数，参数的类型可以决定是否执行目标方法
     * 环绕通知必须有返回值，且返回值为目标方法的返回值
     *
     * @param pjp 参数类型
     * @return object
     */
  /*  @Around(value = "execution(* com.spring.aop.aspect.MathCalculator.*(..))")
    public Object aroundMethod(ProceedingJoinPoint pjp) {

        Object result = null;
        String methodName = pjp.getSignature().getName();

        try {
            //前置通知
            System.out.println("The method (around) " + methodName + " begins with " + Arrays.asList(pjp.getArgs()));
            result = pjp.proceed();
            //返回通知
            System.out.println("The method (around) " + methodName + " returning with " + result);
        } catch (Throwable throwable) {
            //异常通知
            System.out.println("The method (around) " + methodName + " occurs throwing with " + throwable);
        }
        //后置通知
        System.out.println("The method (around) " + methodName + " ends with");
        return result;
    }*/
}