登录
微信搜索superit|邀请体验：大数据, 数据管理、OLAP分析与可视化平台 | 赞助作者：赞助作者

利用自定义注解和Aspect实现方法参数的非空校验

aop aide_941 42℃

利用自定义注解和Aspect实现方法参数的非空校验

2019年01月02日 23:42:46  阅读数：1201
 版权声明：欢迎转载，记得前排留名哦☞ https://blog.csdn.net/qq_31142553/article/details/85645957

日常开发过程中，最常见的异常莫过于NullPointerException，相信大家都对它恨之入骨吧。我也是。

空指针异常出现的原因有以下几种：

  1. 调用 null 对象的实例方法。
  2. 访问或修改 null 对象的字段。
  3. 如果一个数组为null，试图用属性length获得其长度时。
  4. 如果一个数组为null，试图访问或修改其中某个元素时。
  5. 在需要抛出一个异常对象，而该对象为 null 时。

《dubbo-dev-book.pdf》中提到：

这是我最不喜欢看到的异常，尤其在核心框架中，我更愿看到信息详细的参数不合法异常。这也是一个健状的程序开发人员，在写每一行代码都应在潜意识中防止的异常。基本上要能确保一次写完的代码，在不测试的情况，都不会出现这两个异常才算合格。

方法参数校验又是最频繁的地方，与其在每一个接口的开头写一遍非空校验（如果参数是自定义类型，某些属性可空，某些属性非空，这下就更头疼了），不如将这些重复的工作抽取出来，封装成一个功能组件，这样一劳永逸岂不美哉？！。

废话少说，放码过来 。

一、思路

  1. 首先，在需要校验的方法（该类必须为spring bean，后续欢迎改进）加上自定义注解@CheckNull；
  2. 然后，在需要校验的参数前面也加上自定义注解@CheckNull，如果参数为自定义类型且需要对具体字段校验，那么就在方法参数注解里指定group属性，说明此处校验所属的分组名称；
  3. 接着，在自定义类型里面需要校验的字段添加@NotNull注解，并指定groups属性，说明此处校验对哪些分组有效；
  4. 最后，编写Aspect切面对带有@CheckNull注解的方法做拦截、校验。如果不符合，抛出空指针异常，指明某个类某个方法某个参数某个属性为空。

二、自定义注解

我们定义了两个注解，一个作用于方法和参数上，另一个作用于字段上。

1、CheckNull：作用于方法和参数。

  1. /**
  2. * 设置在不同目标上面有着不同的作用<br>
  3. * 方法：说明该方法需要校验带该注解参数的非空<br>
  4. * 参数：说明该参数需要校验非空（自身非空、属性非空）<br>
  5. * @author z_hh
  6. * @date 2019年1月2日
  7. */
  8. @Documented
  9. @Retention(RUNTIME)
  10. @Target({ METHOD, PARAMETER})
  11. public @interface CheckNull {
  13. /**
  14. * 作用于方法和参数上，表面当前校验属于哪一组
  15. * 不设置的话，无需校验参数的属性
  16. */
  17. String group() default “”;
  18. }

2、NotNull：作用于字段。

  1. /**
  2. * 设置在不同目标上面有着不同的作用<br>
  3. * 字段：说明该字段需要校验非空<br>
  4. * @author z_hh
  5. * @date 2019年1月2日
  6. */
  7. @Documented
  8. @Retention(RUNTIME)
  9. @Target({ FIELD })
  10. public @interface NotNull {
  12. /**
  13. * 作用于字段上，表面当前注解对哪一些组有效
  14. */
  15. String[] groups();
  16. }

三、Aspect切面

敲黑板划重点

1、定义一个本地线程变量，用于存储校验不通过的类-方法-参数-属性的信息。

2、拦截带@CheckNull注解的方法。

3、分别获取目标方法的参数类数组（Java8提供，相关知识在上一篇博客有所介绍，点击传送）和参数值数组。

4、对包含@CheckNull注解的参数做校验。

5、需要的话对自定义类型的字段校验。

6、校验不通过时，抛出NullPointerException，并说明为空的参数（或其属性）。

  1. /**
  2. * 非空校验的切面
  3. * @author z_hh
  4. * @date 2019年1月2日
  5. */
  6. @Component
  7. @Aspect
  8. public class CheckNullAspect {
  10. private static final ThreadLocal<Info> LOCAL_INFO = new ThreadLocal<Info>() {
  11. protected Info initialValue() {
  12. return new Info();
  13. };
  14. };
  16. // 拦截带@CheckNull的方法
  17. @Pointcut(“@annotation(cn.zhh.null_verify.annotation.CheckNull)”)
  18. private void annotationPointCut() {
  19. }
  21. // 环绕切面
  22. @Around(“annotationPointCut()”)
  23. public Object process(ProceedingJoinPoint pjp) throws Throwable {
  25. // 1、获取目标方法
  26. Signature signature = pjp.getSignature();
  27. MethodSignature methodSignature = (MethodSignature)signature;
  28. Method targetMethod = methodSignature.getMethod();
  29. // 1.1、设置info的类名和方法名
  30. Info info = LOCAL_INFO.get();
  31. info.setClassName(targetMethod.getDeclaringClass().getName());
  32. info.setMethodName(targetMethod.getName());
  34. // 2、获取方法参数和参数值
  35. Parameter[] parameters = targetMethod.getParameters();
  36. Object[] args = pjp.getArgs();
  38. // 3、校验每个参数
  39. for (int i = 0; i < parameters.length; i++) {
  40. Parameter parameter = parameters[i];
  41. // 3.1、获取参数注解
  42. CheckNull annotation = parameter.getAnnotation(CheckNull.class);
  43. // 3.1、不存在@NotNull，忽略
  44. if (Objects.isNull(annotation)) {
  45. continue;
  46. }
  47. // 3.2、校验参数
  48. boolean verify = verifyParameter(annotation.group(), parameter.getName(), args[i]);
  49. if (!verify) {
  50. throw new NullPointerException(LOCAL_INFO.get().toString() + “为空！”);
  51. }
  52. }
  54. // finish、执行目标方法
  55. return pjp.proceed();
  56. }
  58. private boolean verifyParameter(String groupName, String paramName, Object paramValue) throws Exception {
  59. // 1、设置info的参数名
  60. Info info = LOCAL_INFO.get();
  61. info.setParamName(paramName);
  62. // 2、校验参数本身是否为null
  63. if (Objects.isNull(paramValue)) {
  64. return false;
  65. }
  66. // 3、如果参数注解的group属性为””，则无需校验参数属性
  67. if (Objects.equals(groupName, “”)) {
  68. return true;
  69. }
  70. // 4、校验类的字段
  71. Class<?> clazz = paramValue.getClass();
  72. Field[] fields = clazz.getDeclaredFields();
  73. for (Field field : fields) {
  74. NotNull fieldAnnotation = field.getAnnotation(NotNull.class);
  75. // 3.1、没有注解或者注解不包含指定分组
  76. if (Objects.isNull(fieldAnnotation) || !Arrays.asList(fieldAnnotation.groups()).contains(groupName)) {
  77. // 不需要校验
  78. continue;
  79. }
  80. field.setAccessible(true);
  81. // 3.2、获取属性值
  82. Object value = field.get(paramValue);
  83. if (Objects.isNull(value)) {
  84. //获取属性名
  85. String name = field.getName();
  86. info.setFieldName(name);
  87. return false;
  88. }
  89. }
  90. // 5、校验通过
  91. return true;
  92. }
  93. }

你们需要的Info类。

  1. /**
  2. * 参数相关信息
  3. * @author z_hh
  4. * @time 2019年1月2日
  5. */
  6. public class Info {
  8. /** 类名 */
  9. private String className;
  11. /** 方法名 */
  12. private String methodName;
  14. /** 参数名 */
  15. private String paramName;
  17. /** 属性名 */
  18. private String fieldName;
  20. public String getClassName() {
  21. return className;
  22. }
  24. public void setClassName(String className) {
  25. this.className = className;
  26. }
  28. public String getMethodName() {
  29. return methodName;
  30. }
  32. public void setMethodName(String methodName) {
  33. this.methodName = methodName;
  34. }
  36. public String getParamName() {
  37. return paramName;
  38. }
  40. public void setParamName(String paramName) {
  41. this.paramName = paramName;
  42. }
  44. public String getFieldName() {
  45. return fieldName;
  46. }
  48. public void setFieldName(String fieldName) {
  49. this.fieldName = fieldName;
  50. }
  52. @Override
  53. public String toString() {
  54. StringBuilder builder = new StringBuilder();
  55. if (Objects.nonNull(className)) {
  56. builder.append(“类”).append(className);
  57. }
  58. if (Objects.nonNull(methodName)) {
  59. builder.append(“的方法”).append(methodName);
  60. }
  61. if (Objects.nonNull(paramName)) {
  62. builder.append(“的参数”).append(paramName);
  63. }
  64. if (Objects.nonNull(fieldName)) {
  65. builder.append(“的属性”).append(fieldName);
  66. }
  68. return builder.toString();
  69. }
  71. }

四、测试

写完一个功能后最开心的时刻。

1、使用该功能的目标方法。

  1. /**
  2. * 测试非空校验的服务
  3. * @author z_hh
  4. * @time 2019年1月2日
  5. */
  6. @Service
  7. public class CheckNullService {
  9. @CheckNull
  10. public void test(String nullVal, @CheckNull(group=“test”) Param param) {
  11. System.out.println(param);
  12. }
  13. }

2、自定义参数类。

我们设置了property3非空。

  1. /**
  2. * 自定义参数类
  3. * @author z_hh
  4. * @time 2019年1月2日
  5. */
  6. public class Param {
  8. private int property1;
  10. private String property2;
  12. @NotNull(groups = { “test” })
  13. private Date property3;
  15. @Override
  16. public String toString() {
  17. return “Param [property1=” + property1 + “, property2=” + property2 + “, property3=” + property3 + “]”;
  18. }
  20. /* 省略getter和setter */
  22. }

3、Junit测试代码。

  1. /**
  2. * Junit测试类
  3. * @author z_hh
  4. * @time 2019年1月2日
  5. */
  6. @RunWith(SpringRunner.class)
  7. @SpringBootTest
  8. public class CheckNullServiceTest {
  10. @Autowired
  11. private CheckNullService service;
  13. @Test
  14. public void test() {
  16. Param param = new Param();
  17. service.test(null, param);
  19. }
  20. }

4、运行结果。

哎呀，报错了？？？不对，这不就是我们期望的结果吗？！

※如果看到property3变成了arg1，说明你的开发环境没有配置开启-parameters（怎么弄？我教你，点击传送）。

五、优化&扩展

1、可以在@CheckNull里面定义一个message属性，作用于方法参数上时指定相应的值，然后在切面里面校验到参数（或其部分属性）为空时，获取注解的该属性值，取代默认的”类-方法-参数-属性为空！”的信息。

2、可以将切面里面校验到参数（或其部分属性）为空时抛出空指针异常改为返回指定的值（一般是我们封装的通用方法返回值对象）。

转载请注明：SuperIT » 利用自定义注解和Aspect实现方法参数的非空校验

喜欢 (0)or分享 (0)

    没有相关文章!
  • 暂无相关文章！