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());
    }

先执行前置通知，然后代码，然后异常通知，然后后置通知。