Java反射应用：判断对象是否为NULL

落日映苍穹つ 2023-10-02 10:07 242阅读 0赞

一、背景

最近在做对接美国的EasyPost快递平台时，发现使用Objects.isNull()判断EasyPost返回的序列化之后的空实体（JSON体为:{}）时，返回结果并不是false；然后情不自禁就自己写了个使用反射判断Java对象是否为“NULL”的工具类。

不过最后处于效率的考虑，我并没用，而是使用业务上的唯一约束做进一步的判空处理。这个工具类就送给有缘人吧，哈哈哈！
在这里插入图片描述

最终版工具类

只想知道最终工具类的老哥，请copy如下代码：

  1. package com.saint.javabase.reflect;
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Type;
  5. import java.util.HashSet;
  6. import java.util.Objects;
  8. /**
  9.  * @author Saint
  10.  */
  11. public class CheckObjectIsNullUtils {
  14.     /**
  15.      * 不纳入判空逻辑的field属性
  16.      */
  17.     static final HashSet<String> fieldHash = new HashSet<>(4);
  19.     static {
  21.         fieldHash.add("serialVersionUID");
  22.     }
  24.     /**
  25.      * 判断一个对象是否为null
  26.      *
  27.      * @param object
  28.      * @return
  29.      */
  30.     public static boolean isNull(Object object) {
  32.         // 获取object的Class对象
  33.         Class<?> clazz = object.getClass();
  34.         // 获取对象的所有属性
  35.         Field[] fields = clazz.getDeclaredFields();
  36.         // 定义返回结果
  37.         boolean flag = true;
  39.         for (Field field : fields) {
  41.             // 使非Public类型的属性可以被访问
  42.             field.setAccessible(true);
  43.             Object fieldValue = null;
  44.             Type type = null;
  46.             try {
  48.                 fieldValue = field.get(object);
  49.                 // 获取到属性类型
  50.                 type = field.getType();
  51.                 // 获取属性名称
  52.                 String fieldName = field.getName();
  53.                 if (fieldHash.contains(fieldName)) {
  55.                     continue;
  56.                 }
  58.                 // TODO 实际应用中建议删掉这一行，仅做测试使用
  59.                 System.out.println("属性类型：" + type + ", 属性名：" + fieldName + ", 属性值：" + fieldValue);
  61.             } catch (Exception e) {
  63.                 // TODO 真实业务场景中，这里可以采用打日志替换
  64.                 e.printStackTrace();
  65.             }
  67.             // 只要有一个属性值不为null 就返回false 表示对象不为null
  68.             if (fieldValue != null) {
  71.                 // 如果fieldValue不为null,并且fieldValue的值等于false时，则不认为对象不为空。
  72.                 if (Objects.equals(type.getTypeName(), "boolean")
  73.                         && Objects.equals(fieldValue, false)) {
  75.                     continue;
  76.                 } else {
  78.                     flag = false;
  79.                     break;
  80.                 }
  81.             }
  82.         }
  84.         return flag;
  85.     }
  86. }

二、判空方式

判断Java对象是否为null可以有两层含义：

（1）第一层： 直接使用 object == null 去判断，对象为null的时候返回true,不为null的时候返回false。

（2）第二层：在object != null 为true的情况 下，进一步去判断对象的所有属性是否为null。

1）第一层判空

建议使用上图的Objects.isNull()方法，比自己写null ===xxx更加优雅。当然这里所做的是只是对象是否null，如果对象被new出来了，但是它的所有属性都是默认值null，Objects.isNull()方法是判断不出来的。

尤其是在前后端交互的过程中，前端传过来的空对象实际是：{}，这时对象不为null，但是对象的所有属性为null。

2）使用反射做第二层判空

User.class

  1. package com.saint.javabase.reflect;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. import java.util.List;
  9. /**
  10.  * @author Saint
  11.  */
  12. @Data
  13. @AllArgsConstructor
  14. @NoArgsConstructor
  15. public class User {
  18.     private  String  name;
  19.     private Boolean age;
  20.     private List<String> hobbies;
  21.     private boolean student;
  23. }

工具类：CheckObjectIsNullUtils

  1. package com.saint.javabase.reflect;
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Type;
  6. /**
  7.  * @author Saint
  8.  */
  9. public class CheckObjectIsNullUtils {
  12.     /**
  13.      * 判断一个对象是否为null
  14.      *
  15.      * @param object
  16.      * @return
  17.      */
  18.     public static boolean isNull(Object object) {
  20.         // 获取object的Class对象
  21.         Class<?> clazz = object.getClass();
  22.         // 获取对象的所有属性
  23.         Field[] fields = clazz.getDeclaredFields();
  24.         // 定义返回结果
  25.         boolean flag = true;
  27.         for (Field field : fields) {
  29.             // 使非Public类型的属性可以被访问
  30.             field.setAccessible(true);
  31.             Object fieldValue = null;
  33.             try {
  35.                 fieldValue = field.get(object);
  36.                 // 获取到属性类型
  37.                 Type type = field.getType();
  38.                 // 获取属性名称
  39.                 String fieldName = field.getName();
  41.                 // TODO 实际应用中建议删掉这一行，仅做测试使用
  42.                 System.out.println("属性类型：" + type + ", 属性名：" + fieldName + ", 属性值：" + fieldValue);
  44.             } catch (Exception e) {
  46.                 // TODO 真实业务场景中，这里可以采用打日志替换
  47.                 e.printStackTrace();
  48.             }
  50.             // 只要有一个属性值不为null 就返回false 表示对象不为null
  51.             if (fieldValue != null) {
  53.                 flag = false;
  54.                 break;
  55.             }
  56.         }
  58.         return flag;
  59.     }
  60. }
1>>>>>当含有一个boolean类型的属性时

测试类：

  1. package com.saint.javabase.reflect;
  3. /**
  4.  * 对象是否为空工具-测试类
  5.  * @author Saint
  6.  */
  7. public class CheckObjectIsNullTest {
  9.     public static void main(String[] args) {
  11.         User user = new User();
  12.         boolean flag = CheckObjectIsNullUtils.isNull(user);
  13.         System.err.println("User对象是否为空： " +  flag);
  14.     }
  15. }

控制台输出：

属性类型：class java.lang.String, 属性名：name, 属性值：null
属性类型：class java.lang.Boolean, 属性名：age, 属性值：null
属性类型：interface java.util.List, 属性名：hobbies, 属性值：null
属性类型：boolean, 属性名：student, 属性值：false
User对象是否为空： false

从输出上来看，收到boolean类型的影响，结果为false。

另外需要注意的是数据类型： boolean与Boolean
boolean 定义的变量默认值为false,Boolean定义的变量默认值为 null.

ps： 在定义boolean类型变量时，最好不要使用 isXxx,因为默认生成的get方法就是 isXxx(), RPC框架在反向解析的时候，以为对应的属性名是 xxx,从而导致属性获取不到，抛出异常。

2>>>>>修改工具类，兼容boolean类型的属性

工具类：CheckObjectIsNullUtils

  1. package com.saint.javabase.reflect;
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Type;
  5. import java.util.Objects;
  7. /**
  8.  * @author 周鑫(玖枭)
  9.  */
  10. public class CheckObjectIsNullUtils {
  13.     /**
  14.      * 判断一个对象是否为null
  15.      *
  16.      * @param object
  17.      * @return
  18.      */
  19.     public static boolean isNull(Object object) {
  21.         // 获取object的Class对象
  22.         Class<?> clazz = object.getClass();
  23.         // 获取对象的所有属性
  24.         Field[] fields = clazz.getDeclaredFields();
  25.         // 定义返回结果
  26.         boolean flag = true;
  28.         for (Field field : fields) {
  30.             // 使非Public类型的属性可以被访问
  31.             field.setAccessible(true);
  32.             Object fieldValue = null;
  33.             Type type = null;
  35.             try {
  37.                 fieldValue = field.get(object);
  38.                 // 获取到属性类型
  39.                 type = field.getType();
  40.                 // 获取属性名称
  41.                 String fieldName = field.getName();
  43.                 // TODO 实际应用中建议删掉这一行，仅做测试使用
  44.                 System.out.println("属性类型：" + type + ", 属性名：" + fieldName + ", 属性值：" + fieldValue);
  46.             } catch (Exception e) {
  48.                 // TODO 真实业务场景中，这里可以采用打日志替换
  49.                 e.printStackTrace();
  50.             }
  52.             // 只要有一个属性值不为null 就返回false 表示对象不为null
  53.             if (fieldValue != null) {
  56.                 // 如果fieldValue不为null,并且fieldValue的值等于false时，则不认为对象不为空。
  57.                 if (Objects.equals(type.getTypeName(), "boolean")
  58.                         && Objects.equals(fieldValue, false)) {
  60.                     continue;
  61.                 } else {
  63.                     flag = false;
  64.                     break;
  65.                 }
  66.             }
  67.         }
  69.         return flag;
  70.     }
  71. }

此时运行测试类结果如下：
在这里插入图片描述

从结果上来看，已经符合我们的预期了。

3>>>>>当User类实现序列化接口 Serializable 时

User类：

  1. @Data
  2. @AllArgsConstructor
  3. @NoArgsConstructor
  4. public class User implements Serializable {
  7.     private static final long serialVersionUID = 1L;
  9.     private  String  name;
  10.     private Boolean age;
  11.     private List<String> hobbies;
  12.     private boolean student;
  14. }

运行测试类输出如下：
在这里插入图片描述

结果为false，因为serialVersionUID有值。

所以我们在判空时需要排除一些特殊的字段。

4>>>>>修改工具类，兼容特殊字段serialVersionUID

工具类CheckObjectIsNullUtils：

  1. public class CheckObjectIsNullUtils {
  4.     /**
  5.      * 不纳入判空逻辑的field属性
  6.      */
  7.     static final HashSet<String> fieldHash = new HashSet<>(4);
  9.     static {
  11.         fieldHash.add("serialVersionUID");
  12.     }
  14.     /**
  15.      * 判断一个对象是否为null
  16.      *
  17.      * @param object
  18.      * @return
  19.      */
  20.     public static boolean isNull(Object object) {
  22.         // 获取object的Class对象
  23.         Class<?> clazz = object.getClass();
  24.         // 获取对象的所有属性
  25.         Field[] fields = clazz.getDeclaredFields();
  26.         // 定义返回结果
  27.         boolean flag = true;
  29.         for (Field field : fields) {
  31.             // 使非Public类型的属性可以被访问
  32.             field.setAccessible(true);
  33.             Object fieldValue = null;
  34.             Type type = null;
  36.             try {
  38.                 fieldValue = field.get(object);
  39.                 // 获取到属性类型
  40.                 type = field.getType();
  41.                 // 获取属性名称
  42.                 String fieldName = field.getName();
  43.                 if (fieldHash.contains(fieldName)) {
  45.                     continue;
  46.                 }
  48.                 // TODO 实际应用中建议删掉这一行，仅做测试使用
  49.                 System.out.println("属性类型：" + type + ", 属性名：" + fieldName + ", 属性值：" + fieldValue);
  51.             } catch (Exception e) {
  53.                 // TODO 真实业务场景中，这里可以采用打日志替换
  54.                 e.printStackTrace();
  55.             }
  57.             // 只要有一个属性值不为null 就返回false 表示对象不为null
  58.             if (fieldValue != null) {
  61.                 // 如果fieldValue不为null,并且fieldValue的值等于false时，则不认为对象不为空。
  62.                 if (Objects.equals(type.getTypeName(), "boolean")
  63.                         && Objects.equals(fieldValue, false)) {
  65.                     continue;
  66.                 } else {
  68.                     flag = false;
  69.                     break;
  70.                 }
  71.             }
  72.         }
  74.         return flag;
  75.     }
  76. }

再运行测试类结果如下：
在这里插入图片描述
从结果来看，做判空是排除了serialVersionUID字段。

总结

综上所述，当你需要判断Java对象是否为null的时候，你可以先通过 obj == null 去判断，如果obj 不等于null，再根据业务需求决定是否需要进一步判断 obj的所有属性是否都为null。

发表评论

表情：
评论列表 （有 0 条评论，242人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java判断对象是否为空

    在Java编程中，经常需要判断一个对象是否为空。一个对象为空表示它没有被实例化，或者它的引用值为null。在这篇文章中，我们将详细介绍如何判断一个对象是否为空，并提供相应的源代

    浅浅的花香味﹌浅浅的花香味﹌/ 0 赞/ 153 阅读

    相关 JAVA 反射判断NULL

    用户完善资料,会进行修改状态, 我本来是在用户添加资料那进行同步操作状态,但是产品经理说,用户可以选择不填满这个档案资料,好吧,只能 改需求30个字段,不可以一个一个去判断是

    落日映苍穹つ落日映苍穹つ/ 0 赞/ 267 阅读