Spring AOP的理解和使用

---

---

一、Spring AOP是什么？

AOP称为面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率；
Spring AOP就是基于动态代理的，如果要代理的对象，实现了某个接口，那么Spring AOP会使用JDK Proxy，去创建代理对象，而对于没有实现接口的对象，就无法使用JDK Proxy去进行代理了，这时候Spring AOP会使用Cglib，生成一个被代理对象的子类，来作为代理；

二、Spring AOP举例说明？

1：概念的了解：

直接上一个简单的描述图：

1. Joinpoint（连接点）：平常正常业务中的方法或则异常。
2. Pointcut（切点）：如何表达连接点的一个公式，可以看作是一个切点下有多个连接点。
3. Advice（通知）：通知正常业务中，需要切入的逻辑。
   3.1.Before Advice： 在方法(连接点)前切入
   3.2 After Advice： 在方法(连接点)后切入，抛出异常时也会切入
   3.3 After Returning Advice： 在方法(连接点)返回后切入，抛出异常则不会切入
   3.4 After Throwing Advice： 在方法(连接点)抛出异常时切入
   3.5 Around Advice： 在方法(连接点)执行前后切入，可以中断或忽略原有流程的执行
4. Aspect（切面）：整个切入逻辑的抽象

2：相关注解说明：

@Target()
注解的作用目标：用来作用注解，可以说是注解的注解
参数ElementType,枚举类型：
ElementType.TYPE：接口、类、枚举、注解
ElementType.FIELD：字段、枚举的常量
ElementType.METHOD：方法
ElementType.PARAMETER：方法参数
ElementType.CONSTRUCTOR：构造函数
ElementType.LOCAL_VARIABLE：局部变量
ElementType.ANNOTATION_TYPE：注解
ElementType.PACKAGE：包
e.g:@Target({ ElementType.PARAMETER, ElementType.METHOD })
@Retention()
注解的保留位置：用来作用注解，可以说是注解的注解
参数RetentionPolicy,枚举类型：
RetentionPolicy.SOURCE 这种类型的Annotations只在源代码级别保留,编译时就会被忽略,在class字节码文件中不包含。
RetentionPolicy.CLASS:这种类型的Annotations编译时被保留,默认的保留策略,在class文件中存在,但JVM将会忽略,运行时无法获得。
RetentionPolicy.RUNTIME:这种类型的Annotations将被JVM保留,所以他们能在运行时被JVM或其他使用反射机制的代码所读取和使用。
e.g：@Retention(RetentionPolicy.RUNTIME)
@Documented
说明该注解将被包含在javadoc中
@interface
e.g:@interface Annotation{ } 定义一个注解 @Annotation，一个注解是一个类
@Aspect
作用是把当前类标识为一个切面供容器读取，定义切面类

@Component
作用是把当前类标识为一个bean，把普通pojo实例化到spring容器中，相当于配置文件中的

@Pointcut("@annotation(com.ruoyi.common.annotation.Log)")
定义切点：即我们上面说的切点表达式定义的地方
@Pointcut 参数表达式定义如下：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern)

throws-pattern?)
举例：execution(* com.a.b.impl…*.*(…))

符号	含义
execution（）	表达式的主体
第一个”*“符号	表示返回值的类型任意；
com.a.b.impl	AOP所切的服务的包名，即，我们的业务部分
包名后面的”..“	表示当前包及子包
第二个”*“	表示类名，*即所有类。此处可以自定义，下文有举例
.*(…)	表示任何方法名，括号表示参数，两个点表示任何参数类型

3：例子：

下面我将引用若依框架的日志注解给大家看看：

1. 自定义一个日志类的注解：

@Target({ ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log
{
    /**
     * 模块 
     */
    public String title() default "";

    /**
     * 功能
     */
    public BusinessType businessType() default BusinessType.OTHER;

    /**
     * 操作人类别
     */
    public OperatorType operatorType() default OperatorType.MANAGE;

    /**
     * 是否保存请求的参数
     */
    public boolean isSaveRequestData() default true;
}

2. 定义一个切面：

@Component
public class LogAspect
{
    private static final Logger log = LoggerFactory.getLogger(LogAspect.class);

    /** 排除敏感属性字段 */
    public static final String[] EXCLUDE_PROPERTIES = { "password", "oldPassword", "newPassword", "confirmPassword" };

    // 配置织入点
    @Pointcut("@annotation(com.ruoyi.common.annotation.Log)")
    public void logPointCut()
    {
    }

    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "logPointCut()", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, Object jsonResult)
    {
        handleLog(joinPoint, null, jsonResult);
    }

    /**
     * 拦截异常操作
     * 
     * @param joinPoint 切点
     * @param e 异常
     */
    @AfterThrowing(value = "logPointCut()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Exception e)
    {
        handleLog(joinPoint, e, null);
    }

    protected void handleLog(final JoinPoint joinPoint, final Exception e, Object jsonResult)
    {
        try
        {
            // 获得注解
            Log controllerLog = getAnnotationLog(joinPoint);
            if (controllerLog == null)
            {
                return;
            }

            // 获取当前的用户
            SysUser currentUser = ShiroUtils.getSysUser();

            // *========数据库日志=========*//
            SysOperLog operLog = new SysOperLog();
            operLog.setStatus(BusinessStatus.SUCCESS.ordinal());
            // 请求的地址
            String ip = ShiroUtils.getIp();
            operLog.setOperIp(ip);
            // 返回参数
            operLog.setJsonResult(StringUtils.substring(JSON.marshal(jsonResult), 0, 2000));

            operLog.setOperUrl(ServletUtils.getRequest().getRequestURI());
            if (currentUser != null)
            {
                operLog.setOperName(currentUser.getLoginName());
                if (StringUtils.isNotNull(currentUser.getDept())
                        && StringUtils.isNotEmpty(currentUser.getDept().getDeptName()))
                {
                    operLog.setDeptName(currentUser.getDept().getDeptName());
                }
            }

            if (e != null)
            {
                operLog.setStatus(BusinessStatus.FAIL.ordinal());
                operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000));
            }
            // 设置方法名称
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = joinPoint.getSignature().getName();
            operLog.setMethod(className + "." + methodName + "()");
            // 设置请求方式
            operLog.setRequestMethod(ServletUtils.getRequest().getMethod());
            // 处理设置注解上的参数
            getControllerMethodDescription(controllerLog, operLog);
            // 保存数据库
            AsyncManager.me().execute(AsyncFactory.recordOper(operLog));
        }
        catch (Exception exp)
        {
            // 记录本地异常日志
            log.error("==前置通知异常==");
            log.error("异常信息:{}", exp.getMessage());
            exp.printStackTrace();
        }
    }

    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     * 
     * @param log 日志
     * @param operLog 操作日志
     * @throws Exception
     */
    public void getControllerMethodDescription(Log log, SysOperLog operLog) throws Exception
    {
        // 设置action动作
        operLog.setBusinessType(log.businessType().ordinal());
        // 设置标题
        operLog.setTitle(log.title());
        // 设置操作人类别
        operLog.setOperatorType(log.operatorType().ordinal());
        // 是否需要保存request，参数和值
        if (log.isSaveRequestData())
        {
            // 获取参数的信息，传入到数据库中。
            setRequestValue(operLog);
        }
    }

    /**
     * 获取请求的参数，放到log中
     * 
     * @param operLog 操作日志
     * @throws Exception 异常
     */
    private void setRequestValue(SysOperLog operLog) throws Exception
    {
        Map<String, String[]> map = ServletUtils.getRequest().getParameterMap();
        if (StringUtils.isNotEmpty(map))
        {
            PropertyPreFilters.MySimplePropertyPreFilter excludefilter = new PropertyPreFilters().addFilter();
            excludefilter.addExcludes(EXCLUDE_PROPERTIES);
            String params = JSONObject.toJSONString(map, excludefilter);
            operLog.setOperParam(StringUtils.substring(params, 0, 2000));
        }
    }

    /**
     * 是否存在注解，如果存在就获取
     */
    private Log getAnnotationLog(JoinPoint joinPoint) throws Exception
    {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();

        if (method != null)
        {
            return method.getAnnotation(Log.class);
        }
        return null;
    }
}

3. 在业务中注入Log注解使用：

    @Log(title = "参数管理", businessType = BusinessType.DELETE)
    public AjaxResult remove(String ids)
    {
        return toAjax(configService.deleteConfigByIds(ids));
    }

总结

对于springAOP的使用大概就是如此，但是这只是AOP的冰山一角，更多使用的细节就要靠大家去实践了，这里主要就是如何使用自定义注解去了解AOP相关的知识，关键就是对概念的了解，理清关系，使用起来就得心应手了