SpringBoot 自定义注解 + AOP实现参数效验，默认值赋值
SpringBoot 自定义注意 + AOP实现参数效验，默认值赋值，和@RequestParam相同功能
写自定义注解的意义在于，@RequestParam没有对参数值进行效验，如空值；
经过测试发现，@RequestParam只对本次请求中带不带参数名进行了效验，如参数是?userName=，@RequestParam则会放行，只有当userName不存在参数列表中是，才会提示报错，这就会导致很多问题，需要后台每次对数据都进行空值判断；
又或者前端人员参数为定义，传入了一个undefined，那造成的麻烦更多，所以自定义注解 + AOP来解决这个问题。
开发的这个自定义注解，能实现和@RequestParam一样的功能，但是进行了加强，对参数空值或者undefined进行效验，还可以实现默认值赋值
自定义注解
自定义注解相比怎么写应该都知道，其实就是一个接口，在接口上添加一个其他注解，实现了自己的注解
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @Retention 作用：标识此注解的生命周期，有三种可选值
* 1.RetentionPolicy.SOURCE:在源文件中有效（即源文件保留）
* 2.RetentionPolicy.CLASS:在class文件中有效（即class保留）
* 3.RetentionPolicy.RUNTIME:在运行时有效（即运行时保留）
*
* @Target 作用：标识此注解能用在什么地方
* 1.ElementType.CONSTRUCTOR:用于构造器
* 2.ElementType.FIELD:用于属性
* 3.ElementType.LOCAL_VARIABLE:用于局部变量
* 4.ElementType.METHOD:用于方法
* 5.ElementType.PACKAGE:用于包
* 6.ElementType.PARAMETER:用于参数
* 7.ElementType.TYPE:用于类、接口(包括注解类型) 或enum声明
*/
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface ParamCheck {
/**
* 是否非空,默认不能为空
*/
boolean notNull() default true;
/**
* 默认值
* @return
*/
String defaultValue() default "";
}
自定义注解是写好了，Spring Boot项目中带有了AOP的jar包，可以不用引入，接下来写实现逻辑
用AOP实现注解功能
import com.hm.common.util.cast.CastValueTypeUtil;
import com.hm.common.util.exception.ParamIsNullException;
import com.hm.spss.annotation.ParamCheck;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
/**
* 参数效验AOP
*/
@Component
@Aspect
public class ParamCheckAOP {
/**
* 定义有一个切入点，范围为web包下的类
*/
@Pointcut("execution(public * com.hm.spss.controller..*.*(..))")
public void checkParam() {
}
/**
* 方法执行前执行
* @param joinPoint
*/
@Before("checkParam()")
public void doBefore(JoinPoint joinPoint) {
}
@Around("checkParam()")
public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
MethodSignature signature = ((MethodSignature) pjp.getSignature());
//得到拦截的方法
Method method = signature.getMethod();
//获取方法参数注解，返回二维数组是因为某些参数可能存在多个注解
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
if (parameterAnnotations == null || parameterAnnotations.length == 0) {
return pjp.proceed();
}
//获取方法参数名
String[] paramNames = signature.getParameterNames();
//获取参数值
Object[] paranValues = pjp.getArgs();
//获取方法参数类型
Class<?>[] parameterTypes = method.getParameterTypes();
for (int i = 0; i < parameterAnnotations.length; i++) {
for (int j = 0; j < parameterAnnotations[i].length; j++) {
//如果该参数前面的注解不为空并且是ParamCheck的实例，并且notNull()=true,并且默认值为空，则进行非空校验
if (parameterAnnotations[i][j] != null && parameterAnnotations[i][j] instanceof ParamCheck && ((ParamCheck) parameterAnnotations[i][j]).notNull() && StringUtils.isEmpty(((ParamCheck)parameterAnnotations[i][j]).defaultValue())) {
paramIsNull(paramNames[i], paranValues[i], parameterTypes[i] == null ? null : parameterTypes[i].getName());
break;
}
//如果该参数前面的注解不为空并且是ParamCheck的实例，并且默认值不为空，并且参数值为空，则进行赋默认值
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()))){
paranValues[i] = putParam(((ParamCheck)parameterAnnotations[i][j]).defaultValue(), parameterTypes[i]);
}
}
}
return pjp.proceed(paranValues);
}
/**
* 在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理）
* TODO 留着做以后处理返回值用
* @param joinPoint
*/
@AfterReturning(value = "checkParam()", returning = "result")
public void doAfterReturning(JoinPoint joinPoint, Object result) {
}
/**
* 参数非空校验，如果参数为空，则抛出ParamIsNullException异常
* @param paramName
* @param value
* @param parameterType
*/
private void paramIsNull(String paramName, Object value, String parameterType) {
if (value == null || "".equals(value.toString().trim())) {
throw new ParamIsNullException(paramName, parameterType, "，不能为空！");
}
if ("undefined".equals(value.toString().trim())){
throw new ParamIsNullException(paramName, parameterType, "，不能为undefined！");
}
}
private Object putParam(Object value, Class<?> parameterType){
return CastValueTypeUtil.parseValue(parameterType, value.toString());
}
}
其中有两个Java类，一个是Value转换，一个是自定义异常，转换类的意义在于，默认值在赋予的时候是String字符串，但是实际赋值的时候，给参数赋值，是不确定元素，可以确实的是，这个参数肯定是八大类型中的其中一个
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 转换Object类型
*
*/
public class CastValueTypeUtil {
public static Object parseValue(Class<?> parameterTypes, String value) {
if(value==null || value.trim().length()==0){
return null;
}
value = value.trim();
if (Byte.class.equals(parameterTypes) || Byte.TYPE.equals(parameterTypes)) {
return parseByte(value);
} else if (Boolean.class.equals(parameterTypes) || Boolean.TYPE.equals(parameterTypes)) {
return parseBoolean(value);
}/* else if (Character.class.equals(fieldType) || Character.TYPE.equals(fieldType)) {
return value.toCharArray()[0];
}*/ else if (String.class.equals(parameterTypes)) {
return value;
} else if (Short.class.equals(parameterTypes) || Short.TYPE.equals(parameterTypes)) {
return parseShort(value);
} else if (Integer.class.equals(parameterTypes) || Integer.TYPE.equals(parameterTypes)) {
return parseInt(value);
} else if (Long.class.equals(parameterTypes) || Long.TYPE.equals(parameterTypes)) {
return parseLong(value);
} else if (Float.class.equals(parameterTypes) || Float.TYPE.equals(parameterTypes)) {
return parseFloat(value);
} else if (Double.class.equals(parameterTypes) || Double.TYPE.equals(parameterTypes)) {
return parseDouble(value);
} else if (Date.class.equals(parameterTypes)) {
return parseDate(value);
} else {
throw new RuntimeException("request illeagal type, type must be Integer not int Long not long etc, type=" + parameterTypes);
}
}
public static Byte parseByte(String value) {
try {
value = value.replaceAll(" ", "");
return Byte.valueOf(value);
} catch(NumberFormatException e) {
throw new RuntimeException("parseByte but input illegal input=" + value, e);
}
}
public static Boolean parseBoolean(String value) {
value = value.replaceAll(" ", "");
if (Boolean.TRUE.toString().equalsIgnoreCase(value)) {
return Boolean.TRUE;
} else if (Boolean.FALSE.toString().equalsIgnoreCase(value)) {
return Boolean.FALSE;
} else {
throw new RuntimeException("parseBoolean but input illegal input=" + value);
}
}
public static Integer parseInt(String value) {
try {
value = value.replaceAll(" ", "");
return Integer.valueOf(value);
} catch(NumberFormatException e) {
throw new RuntimeException("parseInt but input illegal input=" + value, e);
}
}
public static Short parseShort(String value) {
try {
value = value.replaceAll(" ", "");
return Short.valueOf(value);
} catch(NumberFormatException e) {
throw new RuntimeException("parseShort but input illegal input=" + value, e);
}
}
public static Long parseLong(String value) {
try {
value = value.replaceAll(" ", "");
return Long.valueOf(value);
} catch(NumberFormatException e) {
throw new RuntimeException("parseLong but input illegal input=" + value, e);
}
}
public static Float parseFloat(String value) {
try {
value = value.replaceAll(" ", "");
return Float.valueOf(value);
} catch(NumberFormatException e) {
throw new RuntimeException("parseFloat but input illegal input=" + value, e);
}
}
public static Double parseDouble(String value) {
try {
value = value.replaceAll(" ", "");
return Double.valueOf(value);
} catch(NumberFormatException e) {
throw new RuntimeException("parseDouble but input illegal input=" + value, e);
}
}
public static Date parseDate(String value) {
try {
String datePattern = "yyyy-MM-dd HH:mm:ss";
SimpleDateFormat dateFormat = new SimpleDateFormat(datePattern);
return dateFormat.parse(value);
} catch(ParseException e) {
throw new RuntimeException("parseDate but input illegal input=" + value, e);
}
}
}
自定义异常类
public class ParamIsNullException extends RuntimeException {
private final String parameterName;
private final String parameterType;
private final String message;
public ParamIsNullException(String parameterName, String parameterType, String message) {
super();
this.parameterName = parameterName;
this.parameterType = parameterType;
this.message = message;
}
@Override
public String getMessage() {
return "请求参数类型：" + this.parameterType + "，参数名： \'" + this.parameterName + message;
}
public final String getParameterName() {
return this.parameterName;
}
public final String getParameterType() {
return this.parameterType;
}
}
以上就是完成了，非常的简单，接下来看如何使用
@GetMapping("/getRisk")
public Result getRisk(@ParamCheck(defaultValue = "1") Integer page,
@ParamCheck(defaultValue = "10") Integer size,
@ParamCheck(notNull = false) String worksName) {
return ResultUtil.success();
}
结语
当参数名传了，参数值没传时，会抛出异常返回，参数名没传也一样的效果，并且也可以赋予默认值，具体看代码逻辑实现，也可以自行修改，只描述个大概。