需求：
1.自定义注解 ，用于标注需要进行校验的参数
2.AOP配合自定义注解使用
3.实现公共的返回参
4.实现全局异常捕获
所有的类
image.png

1.pom.xml依赖

  1.         <!--aop-->
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-aop</artifactId>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.aspectj</groupId>
  8.             <artifactId>aspectjweaver</artifactId>
  9.             <version>1.9.4</version>
  10.         </dependency>
  11.         <dependency>
  12.             <groupId>org.aspectj</groupId>
  13.             <artifactId>aspectjrt</artifactId>
  14.             <version>1.8.9</version>
  15.         </dependency>
  16.         <!--fastjson-->
  17.         <dependency>
  18.             <groupId>com.alibaba</groupId>
  19.             <artifactId>fastjson</artifactId>
  20.             <version>1.2.58</version>
  21.         </dependency>
  22.         <dependency>
  23.             <groupId>org.springframework.boot</groupId>
  24.             <artifactId>spring-boot-starter-web</artifactId>
  25.         </dependency>

2.新建自定义注解，ParamCheck.java ：

  2. import java.lang.annotation.ElementType;
  3. import java.lang.annotation.Retention;
  4. import java.lang.annotation.RetentionPolicy;
  5. import java.lang.annotation.Target;
  7. /**
  8.  * 自定义注解
  9.  * @author beyond
  10.  * @since 2021/4/11
  11.  */
  12. @Target(ElementType.PARAMETER) //  使用于参数
  13. @Retention(RetentionPolicy.RUNTIME)
  14. public @interface ParamCheck {
  16.   /**
  17.    * 是否非空,默认不能为空
  18.    *  要求参数不为空，默认开启,可以自己传
  19.    */
  20.   boolean notNull() default true;
  22.   /***
  23.    * 默认值
  24.    */
  25.   String defaultValue() default "";
  26. }

3.新建 参数校验的AOP实现类，ParamValidAop.java

  1. import org.aspectj.lang.JoinPoint;
  2. import org.aspectj.lang.ProceedingJoinPoint;
  3. import org.aspectj.lang.annotation.AfterReturning;
  4. import org.aspectj.lang.annotation.Around;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.aspectj.lang.annotation.Before;
  7. import org.aspectj.lang.annotation.Pointcut;
  8. import org.aspectj.lang.reflect.MethodSignature;
  9. import org.springframework.stereotype.Component;
  10. import org.springframework.util.StringUtils;
  12. import java.lang.annotation.Annotation;
  13. import java.lang.reflect.Method;
  15. /**
  16.  * 参数校验的AOP实现类
  17.  * @author beyond
  18.  * @since 2021/4/11
  19.  */
  20. @Component
  21. @Aspect
  22. public class ParamValidAop {
  24.   /**
  25.    * 定义有一个切入点，范围为web包下的类
  26.    */
  27.   @Pointcut("execution(public * com.beyond.demo.controller..*.*(..))")
  28.   public void checkParam() {
  29.   }
  31.   @Before("checkParam()")
  32.   public void doBefore(JoinPoint joinPoint) {
  33.   }
  35.   /**
  36.    * 检查参数是否为空
  37.    */
  38.   @Around("checkParam()")
  39.   public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
  41.     MethodSignature signature = ((MethodSignature) pjp.getSignature());
  42.     //得到拦截的方法
  43.     Method method = signature.getMethod();
  44.     //获取方法参数注解，返回二维数组是因为某些参数可能存在多个注解
  45.     Annotation[][] parameterAnnotations = method.getParameterAnnotations();
  46.     if (parameterAnnotations == null || parameterAnnotations.length == 0) {
  47.       return pjp.proceed();
  48.     }
  49.     //获取方法参数名
  50.     String[] paramNames = signature.getParameterNames();
  51.     //获取参数值
  52.     Object[] paranValues = pjp.getArgs();
  54.     //获取方法参数类型
  55.     Class<?>[] parameterTypes = method.getParameterTypes();
  56.     for (int i = 0; i < parameterAnnotations.length; i++) {
  57.       for (int j = 0; j < parameterAnnotations[i].length; j++) {
  58.         //如果该参数前面的注解不为空并且是ParamCheck的实例，并且notNull()=true,并且默认值为空，则进行非空校验
  59.         if (parameterAnnotations[i][j] != null && parameterAnnotations[i][j] instanceof ParamCheck && ((ParamCheck) parameterAnnotations[i][j]).notNull() && StringUtils.isEmpty(((ParamCheck)parameterAnnotations[i][j]).defaultValue())) {
  60.           paramIsNull(paramNames[i], paranValues[i], parameterTypes[i] == null ? null : parameterTypes[i].getName());
  61.           break;
  62.         }
  63.         //如果该参数前面的注解不为空并且是ParamCheck的实例，并且默认值不为空，并且参数值为空，则进行赋默认值
  64.         if(parameterAnnotations[i][j] != null && parameterAnnotations[i][j] instanceof ParamCheck && !StringUtils.isEmpty(((ParamCheck)parameterAnnotations[i][j]).defaultValue()) && (paranValues[i] == null || StringUtils.isEmpty(paranValues[i].toString()))){
  65.           paranValues[i] = putParam(((ParamCheck)parameterAnnotations[i][j]).defaultValue(), parameterTypes[i]);
  66.         }
  67.       }
  68.     }
  69.     return pjp.proceed(paranValues);
  71.   }
  73.   /**
  74.    * 在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理）
  75.    *
  76.    * @param joinPoint
  77.    */
  78.   @AfterReturning("checkParam()")
  79.   public void doAfterReturning(JoinPoint joinPoint) {
  80.   }
  82.   /**
  83.    * 参数非空校验，如果参数为空，则抛出ParamIsNullException异常
  84.    * @param paramName
  85.    * @param value
  86.    * @param parameterType
  87.    */
  88.   private void paramIsNull(String paramName, Object value, String parameterType) {
  89.     if (value == null || "".equals(value.toString().trim())) {
  90.       throw new ParamIsNullException(paramName, parameterType,"参数为空");
  91.     }
  92.   }
  94.   private Object putParam(Object value, Class<?> parameterType) {
  95.     return CastValueTypeUtil.parseValue(parameterType, value.toString());
  96.   }
  98. }

4.校验参数里面使用到的参数转换工具类，CastValueTypeUtil.java：

  1. import java.text.ParseException;
  2. import java.text.SimpleDateFormat;
  3. import java.util.Date;
  5. /**
  6.  * 转换object类型
  7.  * @author beyond
  8.  * @since 2021/4/11
  9.  */
  10. public class CastValueTypeUtil {
  12.   public static Object parseValue(Class<?> parameterTypes, String value) {
  14.     if(value==null || value.trim().length()==0){
  15.       return null;
  16.     }
  17.     value = value.trim();
  19.     if (Byte.class.equals(parameterTypes) || Byte.TYPE.equals(parameterTypes)) {
  20.       return parseByte(value);
  21.     } else if (Boolean.class.equals(parameterTypes) || Boolean.TYPE.equals(parameterTypes)) {
  22.       return parseBoolean(value);
  23.     }/* else if (Character.class.equals(fieldType) || Character.TYPE.equals(fieldType)) {
  24.              return value.toCharArray()[0];
  25.         }*/ else if (String.class.equals(parameterTypes)) {
  26.       return value;
  27.     } else if (Short.class.equals(parameterTypes) || Short.TYPE.equals(parameterTypes)) {
  28.       return parseShort(value);
  29.     } else if (Integer.class.equals(parameterTypes) || Integer.TYPE.equals(parameterTypes)) {
  30.       return parseInt(value);
  31.     } else if (Long.class.equals(parameterTypes) || Long.TYPE.equals(parameterTypes)) {
  32.       return parseLong(value);
  33.     } else if (Float.class.equals(parameterTypes) || Float.TYPE.equals(parameterTypes)) {
  34.       return parseFloat(value);
  35.     } else if (Double.class.equals(parameterTypes) || Double.TYPE.equals(parameterTypes)) {
  36.       return parseDouble(value);
  37.     } else if (Date.class.equals(parameterTypes)) {
  38.       return parseDate(value);
  39.     } else {
  40.       throw new RuntimeException("request illeagal type, type must be Integer not int Long not long etc, type=" + parameterTypes);
  41.     }
  42.   }
  44.   public static Byte parseByte(String value) {
  45.     try {
  46.       value = value.replaceAll("　", "");
  47.       return Byte.valueOf(value);
  48.     } catch(NumberFormatException e) {
  49.       throw new RuntimeException("parseByte but input illegal input=" + value, e);
  50.     }
  51.   }
  53.   public static Boolean parseBoolean(String value) {
  54.     value = value.replaceAll("　", "");
  55.     if (Boolean.TRUE.toString().equalsIgnoreCase(value)) {
  56.       return Boolean.TRUE;
  57.     } else if (Boolean.FALSE.toString().equalsIgnoreCase(value)) {
  58.       return Boolean.FALSE;
  59.     } else {
  60.       throw new RuntimeException("parseBoolean but input illegal input=" + value);
  61.     }
  62.   }
  64.   public static Integer parseInt(String value) {
  65.     try {
  66.       value = value.replaceAll("　", "");
  67.       return Integer.valueOf(value);
  68.     } catch(NumberFormatException e) {
  69.       throw new RuntimeException("parseInt but input illegal input=" + value, e);
  70.     }
  71.   }
  73.   public static Short parseShort(String value) {
  74.     try {
  75.       value = value.replaceAll("　", "");
  76.       return Short.valueOf(value);
  77.     } catch(NumberFormatException e) {
  78.       throw new RuntimeException("parseShort but input illegal input=" + value, e);
  79.     }
  80.   }
  82.   public static Long parseLong(String value) {
  83.     try {
  84.       value = value.replaceAll("　", "");
  85.       return Long.valueOf(value);
  86.     } catch(NumberFormatException e) {
  87.       throw new RuntimeException("parseLong but input illegal input=" + value, e);
  88.     }
  89.   }
  91.   public static Float parseFloat(String value) {
  92.     try {
  93.       value = value.replaceAll("　", "");
  94.       return Float.valueOf(value);
  95.     } catch(NumberFormatException e) {
  96.       throw new RuntimeException("parseFloat but input illegal input=" + value, e);
  97.     }
  98.   }
  100.   public static Double parseDouble(String value) {
  101.     try {
  102.       value = value.replaceAll("　", "");
  103.       return Double.valueOf(value);
  104.     } catch(NumberFormatException e) {
  105.       throw new RuntimeException("parseDouble but input illegal input=" + value, e);
  106.     }
  107.   }
  109.   public static Date parseDate(String value) {
  110.     try {
  111.       String datePattern = "yyyy-MM-dd HH:mm:ss";
  112.       SimpleDateFormat dateFormat = new SimpleDateFormat(datePattern);
  113.       return dateFormat.parse(value);
  114.     } catch(ParseException e) {
  115.       throw new RuntimeException("parseDate but input illegal input=" + value, e);
  116.     }
  117.   }
  119. }

5. 新建一个自定义异常，专门用于校验参数为空的时候抛出，ParamIsNullException.java：

  1. package com.beyond.demo.paramCheck;
  3. /**
  4.  * 自定义异常,用于校验参数为空的时候抛出
  5.  *
  6.  * @author beyond
  7.  * @since 2021/4/11
  8.  */
  9. public class ParamIsNullException extends RuntimeException {
  11.   private final String parameterName;
  12.   private final String parameterType;
  13.   private final String message;
  15.   public ParamIsNullException(String parameterName, String parameterType, String message) {
  16.     super();
  17.     this.parameterName = parameterName;
  18.     this.parameterType = parameterType;
  19.     this.message = message;
  20.   }
  22.   @Override
  23.   public String getMessage() {
  24.     return "请求参数类型：" + this.parameterType + "，参数名： \'" + this.parameterName + message;
  25.   }
  27.   public final String getParameterName() {
  28.     return this.parameterName;
  29.   }
  31.   public final String getParameterType() {
  32.     return this.parameterType;
  33.   }
  35. }


至此，自定义注解以及AOP已经实现完毕

6.统一的返回参以及全局异常捕获

  1. /**
  2.  * 此接口用于返回码枚举使用
  3.  * @author beyond
  4.  * @since 2021/4/11
  5.  */
  6. public interface BaseErrorInfoInterface {
  8.   /** 错误码*/
  9.   String getResultCode();
  11.   /** 错误描述*/
  12.   String getResultMsg();
  14. }

返回码的枚举类，CommonEnum.java：

  2. /**
  3.  * 返回码的枚举类
  4.  *
  5.  * @author beyond
  6.  * @since 2021/4/11
  7.  */
  8. public enum CommonEnum implements BaseErrorInfoInterface {
  10.   // 数据操作错误定义
  11.   SUCCESS("200", "成功!"),
  12.   BODY_NOT_MATCH("400", "请求的数据格式不符!"),
  13.   SIGNATURE_NOT_MATCH("401", "请求的数字签名不匹配!"),
  14.   NOT_FOUND("404", "未找到该资源!"),
  15.   INTERNAL_SERVER_ERROR("500", "服务器内部错误!"),
  16.   SERVER_BUSY("503", "服务器正忙，请稍后再试!"),
  17.   REQUEST_METHOD_SUPPORT_ERROR("40001", "当前请求方法不支持");
  18.   /**
  19.    * 错误码
  20.    */
  21.   private String resultCode;
  22.   /**
  23.    * 错误描述
  24.    */
  25.   private String resultMsg;
  27.   CommonEnum(String resultCode, String resultMsg) {
  28.     this.resultCode = resultCode;
  29.     this.resultMsg = resultMsg;
  30.   }
  32.   @Override
  33.   public String getResultCode() {
  34.     return resultCode;
  35.   }
  37.   @Override
  38.   public String getResultMsg() {
  39.     return resultMsg;
  40.   }
  42. }

定义一个简单的返回体专用类，ResultBody.java：

  1. package com.beyond.demo.paramCheck;
  3. import com.alibaba.fastjson.JSONObject;
  5. /**
  6.  * 返回体专用类
  7.  *
  8.  * @author beyond
  9.  * @since 2021/4/11
  10.  */
  11. public class ResultBody {
  12.   /**
  13.    * 响应代码
  14.    */
  15.   private String code;
  17.   /**
  18.    * 响应消息
  19.    */
  20.   private String message;
  22.   /**
  23.    * 响应结果
  24.    */
  25.   private Object result;
  27.   public ResultBody() {
  28.   }
  30.   public ResultBody(BaseErrorInfoInterface errorInfo) {
  31.     this.code = errorInfo.getResultCode();
  32.     this.message = errorInfo.getResultMsg();
  33.   }
  35.   public String getCode() {
  36.     return code;
  37.   }
  39.   public void setCode(String code) {
  40.     this.code = code;
  41.   }
  43.   public String getMessage() {
  44.     return message;
  45.   }
  47.   public void setMessage(String message) {
  48.     this.message = message;
  49.   }
  51.   public Object getResult() {
  52.     return result;
  53.   }
  55.   public void setResult(Object result) {
  56.     this.result = result;
  57.   }
  59.   /**
  60.    * 成功
  61.    *
  62.    * @return
  63.    */
  64.   public static ResultBody success() {
  65.     return success(null);
  66.   }
  68.   /**
  69.    * 成功
  70.    *
  71.    * @param data
  72.    * @return
  73.    */
  74.   public static ResultBody success(Object data) {
  75.     ResultBody rb = new ResultBody();
  76.     rb.setCode(CommonEnum.SUCCESS.getResultCode());
  77.     rb.setMessage(CommonEnum.SUCCESS.getResultMsg());
  78.     rb.setResult(data);
  79.     return rb;
  80.   }
  82.   /**
  83.    * 失败
  84.    */
  85.   public static ResultBody error(BaseErrorInfoInterface errorInfo) {
  86.     ResultBody rb = new ResultBody();
  87.     rb.setCode(errorInfo.getResultCode());
  88.     rb.setMessage(errorInfo.getResultMsg());
  89.     rb.setResult(null);
  90.     return rb;
  91.   }
  93.   /**
  94.    * 失败
  95.    */
  96.   public static ResultBody error(String code, String message) {
  97.     ResultBody rb = new ResultBody();
  98.     rb.setCode(code);
  99.     rb.setMessage(message);
  100.     rb.setResult(null);
  101.     return rb;
  102.   }
  104.   /**
  105.    * 失败
  106.    */
  107.   public static ResultBody error(String message) {
  108.     ResultBody rb = new ResultBody();
  109.     rb.setCode("-1");
  110.     rb.setMessage(message);
  111.     rb.setResult(null);
  112.     return rb;
  113.   }
  115.   @Override
  116.   public String toString() {
  117.     return JSONObject.toJSONString(this);
  118.   }
  120. }

自定义的业务异常类，和全局异常捕获类

  1. package com.beyond.demo.paramCheck;
  3. /**
  4.  * 自定义的业务异常类
  5.  *
  6.  * @author beyond
  7.  * @since 2021/4/11
  8.  */
  9. public class BizException extends RuntimeException {
  11.   private static final long serialVersionUID = 1L;
  13.   /**
  14.    * 错误码
  15.    */
  16.   protected String errorCode;
  17.   /**
  18.    * 错误信息
  19.    */
  20.   protected String errorMsg;
  22.   public BizException() {
  23.     super();
  24.   }
  26.   public BizException(BaseErrorInfoInterface errorInfoInterface) {
  27.     super(errorInfoInterface.getResultCode());
  28.     this.errorCode = errorInfoInterface.getResultCode();
  29.     this.errorMsg = errorInfoInterface.getResultMsg();
  30.   }
  32.   public BizException(BaseErrorInfoInterface errorInfoInterface, Throwable cause) {
  33.     super(errorInfoInterface.getResultCode(), cause);
  34.     this.errorCode = errorInfoInterface.getResultCode();
  35.     this.errorMsg = errorInfoInterface.getResultMsg();
  36.   }
  38.   public BizException(String errorMsg) {
  39.     super(errorMsg);
  40.     this.errorMsg = errorMsg;
  41.   }
  43.   public BizException(String errorCode, String errorMsg) {
  44.     super(errorCode);
  45.     this.errorCode = errorCode;
  46.     this.errorMsg = errorMsg;
  47.   }
  49.   public BizException(String errorCode, String errorMsg, Throwable cause) {
  50.     super(errorCode, cause);
  51.     this.errorCode = errorCode;
  52.     this.errorMsg = errorMsg;
  53.   }
  56.   public String getErrorCode() {
  57.     return errorCode;
  58.   }
  60.   public void setErrorCode(String errorCode) {
  61.     this.errorCode = errorCode;
  62.   }
  64.   public String getErrorMsg() {
  65.     return errorMsg;
  66.   }
  68.   public void setErrorMsg(String errorMsg) {
  69.     this.errorMsg = errorMsg;
  70.   }
  72.   public String getMessage() {
  73.     return errorMsg;
  74.   }
  76.   @Override
  77.   public Throwable fillInStackTrace() {
  78.     return this;
  79.   }
  80. }
  1. package com.beyond.demo.paramCheck;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.web.HttpRequestMethodNotSupportedException;
  6. import org.springframework.web.bind.MissingServletRequestParameterException;
  7. import org.springframework.web.bind.annotation.ExceptionHandler;
  8. import org.springframework.web.bind.annotation.ResponseBody;
  9. import org.springframework.web.bind.annotation.RestControllerAdvice;
  10. import javax.servlet.http.HttpServletRequest;
  12. /**
  13.  * 全局异常捕获类
  14.  * @author beyond
  15.  * @since 2021/4/11
  16.  */
  17. @RestControllerAdvice
  18. public class GlobalExceptionHandler {
  19.   private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
  21.   /**
  22.    * 处理自定义的业务异常
  23.    * @param req
  24.    * @param e
  25.    * @return
  26.    */
  27.   @ExceptionHandler(value = BizException.class)
  28.   @ResponseBody
  29.   public ResultBody bizExceptionHandler(HttpServletRequest req, BizException e){
  30.     logger.error("发生业务异常！原因是：{}",e.getErrorMsg());
  31.     return ResultBody.error(e.getErrorCode(),e.getErrorMsg());
  32.   }
  34.   /**
  35.    * 处理空指针的异常
  36.    * @param req
  37.    * @param e
  38.    * @return
  39.    */
  40.   @ExceptionHandler(value =NullPointerException.class)
  41.   @ResponseBody
  42.   public ResultBody exceptionHandler(HttpServletRequest req, NullPointerException e){
  43.     logger.error("发生空指针异常！原因是:",e);
  44.     return ResultBody.error(CommonEnum.BODY_NOT_MATCH);
  45.   }
  47.   /**
  48.    * 处理请求方法不支持的异常
  49.    * @param req
  50.    * @param e
  51.    * @return
  52.    */
  53.   @ExceptionHandler(value = HttpRequestMethodNotSupportedException.class)
  54.   @ResponseBody
  55.   public ResultBody exceptionHandler2(HttpServletRequest req, HttpRequestMethodNotSupportedException e){
  56.     logger.error("发生请求方法不支持异常！原因是:",e);
  57.     return ResultBody.error(CommonEnum.REQUEST_METHOD_SUPPORT_ERROR);
  58.   }
  60.   /**
  61.    * 处理请求方法不支持的异常
  62.    * @param req
  63.    * @param e
  64.    * @return
  65.    */
  66.   @ExceptionHandler(value = {ParamIsNullException.class, MissingServletRequestParameterException.class})
  67.   @ResponseBody
  68.   public ResultBody exceptionHandler3(HttpServletRequest req, Exception  e){
  69.     logger.error("参数为空！原因是:",e);
  70.     return ResultBody.error(CommonEnum.SIGNATURE_NOT_MATCH.getResultCode(),e.getMessage());
  71.   }
  73.   /**
  74.    * 处理其他异常
  75.    * @param req
  76.    * @param e
  77.    * @return
  78.    */
  79.   @ExceptionHandler(value =Exception.class)
  80.   @ResponseBody
  81.   public ResultBody exceptionHandler(HttpServletRequest req, Exception e){
  82.     logger.error("未知异常！原因是:",e);
  83.     return ResultBody.error(CommonEnum.INTERNAL_SERVER_ERROR);
  84.   }
  86. }

接下来看看这套实现的东西效果如何：
给需要的校验的参数加上我们的自定义注解即可，如：

  1.     @GetMapping("/hello1")
  2.     public ResultBody hello1(
  3.         /*@ParamCheck(defaultValue = "banbu") */@ParamCheck String name) {
  5.         return ResultBody.success();
  6.     }

image.png
那么我们试试不传参数name：