Springboot 自定義注解+AOP實現參數不能為空

一：自定義注解類

package com.wing.my.cloud.system.modular.system.util.annotation;

import java.lang.annotation.*;

@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CheckNullParams {
    String[] params();
}

二：AOP

package com.wing.my.cloud.system.modular.system.util.aspect;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.wing.my.cloud.kernel.model.exception.ServiceException;
import com.wing.my.cloud.system.modular.system.util.annotation.CheckNullParams;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.*;

/**
 * 校驗參數不能為空
 * ProceedingJoinPoint只能用在環繞通知上。
 */
@Slf4j
@Aspect
@Component
public class CheckNullParamsAspect {

    private static String dateFormat = "yyyy-MM-dd HH:mm:ss";

    @Pointcut("@annotation(com.wing.my.cloud.system.modular.system.util.annotation.CheckNullParams)")
    public void paramNotNull(){}

    @Around("paramNotNull()")
    public Object  doAround(ProceedingJoinPoint joinPoint) throws Throwable{
        log.info("進入到環繞通知中");
        // 1、記錄方法開始執行的時間
        long start = System.currentTimeMillis();

        // 2、打印請求參數
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        String target = joinPoint.getSignature().getDeclaringTypeName();              // 全路徑類名
        String classNm = target.substring(target.lastIndexOf(".") + 1, target.length()); // 類名截取
        String method = joinPoint.getSignature().getName();                          // 獲取方法名
        Map<String, String> params = getAllRequestParam(request);                    // 獲取請求參數
        log.info("{}.{} 接收參數: {}", classNm, method, JSON.toJSONString(params));

        CheckNullParams check = ((MethodSignature) joinPoint.getSignature()).getMethod().getAnnotation(CheckNullParams.class); // 獲取注解
        String[] requiredFields = check.params();                                   // 獲取注解參數
        // 3、必填參數非空校驗
        Map<String,Object> result = validParams(params, requiredFields);
        if ((Boolean) result.get("boolean")) {

            Object object = joinPoint.proceed();        // 必填參數非空校驗通過，執行方法，獲取執行結果
            // 4、打印應答數據和方法耗時
            long time = System.currentTimeMillis() - start;
            log.info("{}.{} 應答數據: {}; 耗時 {} ms", classNm, method, JSONObject.toJSONStringWithDateFormat(object,
                    dateFormat, SerializerFeature.WriteMapNullValue), time);
            return object;
        } else {
            // 必填參數非空校驗未通過，拋出異常，由GlobalExceptionHandler捕獲全局異常，返回調用方“參數缺失”
            throw new ServiceException(500, "參數【" + result.get("param") + "】缺失或格式錯誤");

        }

    }

    /**
     * 校驗傳入參數params（非null）中是否必含requiredFields（非null）中的各個屬性，且屬性值非空
     *
     * @param params         傳入參數
     * @param requiredFields 設置的非空屬性數組
     * @return 校驗通過返回true，否則返回false
     */
    private Map<String,Object> validParams(Map<String, String> params, String[] requiredFields) {
        Map<String, Object> map = new HashMap<>(2);
        if (requiredFields.length == 0) {
            // 無必送參數，直接返回true
            map.put("boolean", true);
            return map;
        } else {
            for (String field : requiredFields) {
                if (StringUtils.isEmpty(params.get(field))) {
                    map.put("boolean", false);
                    map.put("param", field);
                    return map;
                }
            }
            map.put("boolean", true);
            return map;
        }
    }

    /**
     * 獲取請求參數
     */
    public static Map<String, String> getAllRequestParam(HttpServletRequest request) {
        Map<String, String> res = new HashMap<>();
        Enumeration<?> temp = request.getParameterNames();
        if (null != temp) {
            while (temp.hasMoreElements()) {
                String en = (String) temp.nextElement();
                String value = request.getParameter(en);
                res.put(en, value);
                // 在報文上送時，如果字段的值為空，則不上送<下面的處理為在獲取所有參數數據時，判斷若值為空，則刪除這個字段>
                if (StringUtils.isEmpty(res.get(en))) {
                    res.remove(en);
                }
            }
        }
        return res;
    }

}

三：實現

@ApiImplicitParams({
            @ApiImplicitParam(name = "channelParam", value = "閑錢保渠道維護表實體類", dataType = "ChannelParam", paramType = "query", example = "xxx"),
    })
    @ResponseBody
    @ApiResource(name = "測試接口", path = "/test1")
    @CheckNullParams(params = {"custId","inpName"})  //參數不能為空
    public ResponseData test1( InsurancePolicyParam insurancePolicyParam) {
        testUserService.testExceptionAop(insurancePolicyParam);
        return ResponseData.success();
    }

參數 custId，inpName為InsurancePolicyParam實體類的屬性。

AOP各種通知

前置通知

方法執行前開始執行

@Before("declareJointPointExpression()")
    public void beforeMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();

        System.out.println("這是切面開始打印出來的--->The method " + methodName + " begins with " + Arrays.asList(args));
    }

 

//后置通知
//方法執行后開始執行
@After("declareJointPointExpression()")
public void afterMethod(JoinPoint joinPoint) {
String methodName = joinPoint.getSignature().getName();
System.out.println("這是切面結束打印出來的--->The method " + methodName + " ends");
}

 

帶返回值的后置通知

方法正常執行后執行

@AfterReturning(value = "declareJointPointExpression()",
            returning = "result")
    public void afterReturningMethod(JoinPoint joinPoint,Object result) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " ends with " + result);
    }

 

異常通知

代碼執行中出現異常后執行

 @AfterThrowing(value = "exceptionLog()",throwing = "e")
    public void afterThrowing(JoinPoint point, Exception e) throws Throwable {
        String target = point.getSignature().getDeclaringTypeName();              // 全路徑類名
        String classNm = target.substring(target.lastIndexOf(".") + 1, target.length()); // 類名截取
        String method = point.getSignature().getName();                          // 獲取方法名
        log.error("{}.{} 【異常信息】: {}", classNm, method, e.getMessage());
    }

 

先執行前置通知，然后代碼，然后異常通知，然后后置通知。