Java反射机制,如何将一个实体类所有字段赋值为null

目录
  • 将一个实体类所有字段赋值为null
    • 起因
    • 第一种方法
    • 第二种方法
  • 将实体类中的null属性置为““或者空值
    • 工具类
    • 测试类
    • 先创建需要的实体

将一个实体类所有字段赋值为null

起因

在我们想要使用一个实体类的时候,如果发现创建这个类的时候,给某一些字段设置了初始值(某些场景下的特殊需要),但我们这个时候又不需要这些初始化值的时候,我们就会想要把这些值全部清除掉,让其变为一个干净的类,我们可以手动一个一个去赋null值,我一开始就是这么做的,同事看到后告诉我,你可以尝试使用反射机制,自己封装一个工具类,这样大家都可以使用,于是我就这么做了,也就有了下面比较low B 的代码:

我的代码:

public static void reflectClassValueToNull(Object model) throws Exception {        
        //获取此类的所有父类
        List<Class<?>> listSuperClass = Lists.newArrayList();
        Class<?> superclass = model.getClass().getSuperclass();
        while (superclass != null) {
            if (superclass.getName().equals("java.lang.Object")) {
                break;
            }
            listSuperClass.add(superclass);
            superclass = superclass.getSuperclass();
        }
        //遍历处理所有父类的字段
        for (Class<?> clazz : listSuperClass) {
            Field[] fields = clazz.getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                String name = fields[i].getName();
                Class type = fields[i].getType();
                Method method = clazz.getMethod("set" + name.replaceFirst(name.substring(0, 1),
                        name.substring(0, 1).toUpperCase()), type);
                method.invoke(model, new Object[]{null});
            }
        }
        //处理此类自己的字段
        Field[] fields = model.getClass().getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            String name = fields[i].getName();
            Class type = fields[i].getType();
            //获取属性的set方法
            Method method = model.getClass().getMethod("set" + name.replaceFirst(name.substring(0, 1),
                    name.substring(0, 1).toUpperCase()), type);
            //将值设为null
            method.invoke(model, new Object[]{null});
        }
    }

代码写完的那一刻,真的很爽,虽然这个东西比较简单,但还是有一点成就感。然后告诉同事我写好了,让他帮忙优化一下(毕竟他在我心里是一个真正的大牛),午休结束后,他发来了两个方法给我,以不同的方式实现,不过都是基于反射机制。以下是他的代码:

第一种方法

public static <T> T byMethod(T t) {
        ReflectionUtils.getAllMethods(t.getClass(), method -> Objects.requireNonNull(method).getName().indexOf("set") == 0).forEach(method -> {
            try {
                method.invoke(t, new Object[]{null});
            } catch (IllegalAccessException | InvocationTargetException e) {
                throw new RuntimeException(e);
            }
        });
        return t;
    }

第二种方法

public static <T> T byField(T t) {
        ReflectionUtils.getAllFields(t.getClass()).forEach(field -> {
            try {
                field.setAccessible(true);
                field.set(t, null);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        });
        return t;
    }

所以,差距你们看到了吗?反正我看到了!

将实体类中的null属性置为““或者空值

工具类

package com.chryl.util; 
import java.lang.reflect.Field;
import java.lang.reflect.Method; 
public class ReflectionUtils { 
    /**
     * 将实体类中的String类型属性为null的置为""
     *
     * @param o
     * @return
     */
    public static Object nullifyStrings(Object o) {
        Field[] declaredFields = o.getClass().getDeclaredFields();
        for (Field f : declaredFields) {
            f.setAccessible(true);
            String name = f.getName();
            if ("serialVersionUID".equals(name)) {
                continue;
            }
            //获取属性类型
            Class type = f.getType();
            try {
                //只操作String类型
                if (type.equals(String.class)) {
                    String value = (String) f.get(o);
                    //如果为空
                    if (value == null || value.trim().isEmpty()) {
                        //获取属性的set方法
                        Method method = o.getClass().getMethod("set" + name.replaceFirst(name.substring(0, 1), name.substring(0, 1).toUpperCase()), type);
//                        f.set(o, null);
                        //将值设为空串
                        method.invoke(o, "");
                    }
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        return o;
    } 
 
    /**
     * 含递归
     * 将实体类中的 String类型或对象 属性为null的置为""或空对象
     *
     * @param o
     * @return
     */
    public static Object nullifyObjectOrStrings(Object o) throws ClassNotFoundException {
        Field[] declaredFields = o.getClass().getDeclaredFields();
        for (Field f : declaredFields) {
            f.setAccessible(true);
            String name = f.getName();
            if ("serialVersionUID".equals(name)) {
                continue;
            }
 
            //获取属性类型
            Class type = f.getType();
            try {
                //获取属性的set方法
                String setterMethod = "set" + name.replaceFirst(name.substring(0, 1), name.substring(0, 1).toUpperCase());
                Method method = o.getClass().getMethod(setterMethod, type);
                //只操作String类型
                if (type.equals(String.class)) {
                    String value = (String) f.get(o);
                    //如果为空
                    if (value == null || value.trim().isEmpty()) {
//                        f.set(o, null);
                        //将值设为空串
                        method.invoke(o, "");
                    }
                } else {
                    Class<?> aClass = Class.forName(f.getGenericType().getTypeName());
                    Object createObj = aClass.newInstance();
                    //实体赋值
                    method.invoke(o, createObj);
                    nullifyObjectOrStrings(createObj);
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        return o;
    }
}

测试类

package com.chryl.test;  
import com.chryl.entity.User;
import com.chryl.util.ReflectionUtils;
 
/**
 * Created By Chryl on 2021-08-11.
 */
public class NullStrTest {
    public static void main(String[] args) throws Exception { 
        User user = new User();
        User user1 = (User) ReflectionUtils.nullifyStrings(user);
        System.out.println(user1); 
        User user12 = (User) ReflectionUtils.nullifyObjectOrStrings(user);
        System.out.println(user12);  
    } 
}

先创建需要的实体

package com.chryl.entity; 
import java.io.Serializable; 
/**
 * Created By Chryl on 2021-08-11.
 */
public class User implements Serializable {
    private static final long serialVersionUID = 930878416859194735L; 
    private String username;
    private String password;
    private String age;
    private ParamsList paramsList; 
    public User() {
    }
 
    public User(String username, String password, String age) {
        this.username = username;
        this.password = password;
        this.age = age;
    }
 
    public User(String username, String password, String age, ParamsList paramsList) {
        this.username = username;
        this.password = password;
        this.age = age;
        this.paramsList = paramsList;
    }
 
    public static long getSerialVersionUID() {
        return serialVersionUID;
    }
 
    public String getUsername() {
        return username;
    }
 
    public void setUsername(String username) {
        this.username = username;
    }
 
    public String getPassword() {
        return password;
    }
 
    public void setPassword(String password) {
        this.password = password;
    }
 
    public String getAge() {
        return age;
    }
 
    public void setAge(String age) {
        this.age = age;
    }
 
    public ParamsList getParamsList() {
        return paramsList;
    }
 
    public void setParamsList(ParamsList paramsList) {
        this.paramsList = paramsList;
    }
}
package com.chryl.entity; 
/**
 * Created By Chryl on 2021-08-12.
 */
public class ParamsList {
    private String param1;
    private String param2;
    private String param3;
    private String param4; 
    public ParamsList() {
    }
 
    public ParamsList(String param1, String param2, String param3, String param4) {
        this.param1 = param1;
        this.param2 = param2;
        this.param3 = param3;
        this.param4 = param4;
    }
 
    public String getParam1() {
        return param1;
    }
 
    public void setParam1(String param1) {
        this.param1 = param1;
    }
 
    public String getParam2() {
        return param2;
    }
 
    public void setParam2(String param2) {
        this.param2 = param2;
    }
 
    public String getParam3() {
        return param3;
    }
 
    public void setParam3(String param3) {
        this.param3 = param3;
    }
 
    public String getParam4() {
        return param4;
    }
 
    public void setParam4(String param4) {
        this.param4 = param4;
    }
}

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • JAVA的反射机制你了解多少

    目录 1.什么是反射? 2.反射能够干什么? 3.反射相关API 4.Class类的理解 (1).介绍: (2).类的加载过程: ①加载: ②链接: ③初始化 ④使用 ⑤卸载 (3)类加载器 总结 1.什么是反射? 在java开发中有一个非常重要的概念就是java反射机制,也是java的重要特征之一. 反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问.检测和修改它本身状态或行为的一种能力,通过反射可以调用私有方法和私有属性,大部分框架也都是运用反射原理的. Reflectio

  • Java实例讲解反射机制是怎么一回事

    Java反射机制的概述 1.Java的反射(reflection) :机制是指在程序的运行状态中,可以构造任意一个类的对象,可以了解任意一个对象所属的类,可以了解任意一个类的成员变量和方法,可以调用任意一个对象的属性和方法.这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制.反射被视为动态语言的关键,反射让Java成为一个准动态语言 .缺点增加不安全性. 2.动态语言(弱类型语言) 是运行时才确定数据类型的语言,变量在使用之前无需申明类型,通常变量的值是被赋值的那个值的类型..

  • Java中的反射机制基本运用详解

    目录 Java中的反射机制基本运用 1.什么是反射(reflect) 2.反射机制提供的功能 3.反射->获取类对象 4.反射->利用无参构造实例化对象 5.反射->利用有参构造实例化对象 6.反射->调用无参方法 7.反射->调用有参方法 8.反射->访问私有方法 9.反射->类加载路径 总结 Java中的反射机制基本运用 看完反射可以了解一下注解 注解annotation://www.jb51.net/article/221276.htm 1.什么是反射(re

  • Java基础篇之反射机制详解

    目录 1.反射概述 1.1什么是反射 1.2.反射能干什么 2.解剖类 2.1反射构造方法 2.1.1反射无参的构造函数 2.1.2反射“一个参数”的构造函数 2.1.3反射“多个参数”的构造函数 2.1.4反射“私有”的构造函数 2.1.5反射得到类中所有的构造函数 2.2反射类中的方法 2.3反射类中的属性字段 思考:在讲反射之前,先思考一个问题,java中如何创建一个对象,有哪几种方式? Java中创建对象大概有这几种方式: 1.使用new关键字:这是我们最常见的也是最简单的创建对象的方式

  • Java基础篇之反射机制示例详解

    目录 一.什么是反射: 二.反射的原理: 三.反射的优缺点: 四.反射的用途: 五.反射机制常用的类: 六.反射的基本使用: 1.获得Class:主要有三种方法: 2.判断是否为某个类的示例: 3.创建实例:通过反射来生成对象主要有两种方法: 4.通过反射获取构造方法并使用: 5.获取成员变量并调用: 6.获取成员方法并调用: 7.反射main方法: 8.利用反射创建数值: 9.反射方法的其他使用--通过反射运行配置文件内容: 10.反射方法的其他使用--通过反射越过泛型检查: 总结 一.什么是

  • JAVA中反射机制和模块化的深入讲解

    目录 一.类加载 1.1类加载描述 1.2类的加载 1.3类的连接 1.4类的初始化 1.4.1类初始化的作用 1.4.2初始化步骤 1.4.3类的初始化时机 二.反射 2.1反射的概述 2.2获取Class类对象的三种方式 2.3反射获取构造方法 2.4反射获取成员变量 2.5反射获取成员方法 2.6反射的案例 2.6.1反射练习之越过泛型检查 2.6.2运行配置文件中指定类的指定方法 三.模块化 3.1模块化概述 ​​​​​​​​​​​​​​3.2模块化使用 3.3模块化的基本使用 总结 一

  • java反射机制最详解

    目录 java反射机制 什么是反射? 反射的功能: 反射常用类: 1.Class枚举类 2.Constructor构造器 3.Method方法类 4.Field变量类 反射运行指示图 通过反射获取对象 总结 java反射机制 什么是反射? 在java开发中有一个非常重要的概念就是java反射机制,也是java的重要特征之一.反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问.检测和修改它本身状态或行为的一种能力,通过反射可以调用私有方法和私有属性,大部分框架也都是运用反射原理的

  • Java反射机制如何解决数据传值为空的问题

    目录 反射机制数据传值为空的问题 java反射处理空值 反射机制数据传值为空的问题 两个小方法,用于解决BeanUtils.copyProperties(x, y);中源对象的值为空问题 1.通过实体注解数据库字段为Map的Key,需要的非空值为Value封装数据 @Override     public Map<String, Object> setNodeParamItems(DispatchInfoItem dispatchInfoItem) throws NoSuchMethodExc

  • Java反射机制,如何将一个实体类所有字段赋值为null

    目录 将一个实体类所有字段赋值为null 起因 第一种方法 第二种方法 将实体类中的null属性置为““或者空值 工具类 测试类 先创建需要的实体 将一个实体类所有字段赋值为null 起因 在我们想要使用一个实体类的时候,如果发现创建这个类的时候,给某一些字段设置了初始值(某些场景下的特殊需要),但我们这个时候又不需要这些初始化值的时候,我们就会想要把这些值全部清除掉,让其变为一个干净的类,我们可以手动一个一个去赋null值,我一开始就是这么做的,同事看到后告诉我,你可以尝试使用反射机制,自己封

  • java 利用java反射机制动态加载类的简单实现

    如下所示: ////////////////// Load.java package org.bromon.reflect; import java.util.ArrayList; import java.util.List; public class Load implements Operator { @Override public List<?> act(List<?> params) { // TODO Auto-generated method stub List<

  • 利用java反射机制实现自动调用类的简单方法

    1. 新建TestServlet类 package com.yanek.test; import java.io.IOException; import java.lang.reflect.Method; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.ht

  • java反射机制给实体类相同字段自动赋值实例

    一.封装一个工具类 1.简易版 package net.aexit.construct.acceptance.websky.utils; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class ClassReflection { /** * @par

  • Java如何基于反射机制获取不同的类

    什么是反射机制 Java的反射(reflection)机制是指在程序的运行状态中,可以构造任意一个类的对象,可以了解任意一个对象所属的类,可以了解任意一个类的成员变量和方法,可以调用任意一个对象的属性和方法.这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制.反射被视为动态语言的关键(在运行阶段可以改变其结构) 特点: 1.极大的提高了程序的灵活性和扩展性,降低模块的耦合性,提高自身的适应能力 2.通过反射机制可以让程序创建和控制任何类的对象,无需提前硬编码目标类 3.能够在运

  • 利用java反射机制调用类的私有方法(推荐)

    试想一下,如果你可以轻易地调用一个类的私有方法,那么是不是说你的封装都失效了?最近在看java的反射机制,发现居然可以利用java的反射机制去调用其他类的私有方法,至于这能干什么,那就见人见智了.. 我写的一段简易实例代码如下: import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; /** * @author thomaslwq * @version 创建时间:Sep 4, 201

  • Java 反射机制实例详解

    Java 反射机制实例详解 一.JAVA是动态语言吗? 一般而言,说到动态言,都是指在程序运行时允许改变程序结构或者变量类型,从这个观点看,Java和C++一样,都不是动态语言. 但JAVA它却有着一个非常突出的动态相关机制:反射.通过反射,Java可以于运行时加载.探知和使用编译期间完全求和的类.生成其对象实体,调用其方法或者对属性设值.所以Java算是一个半动态的语言吧. 反射的概念: 在Java中的反射机制是指在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法; 对于任意一个对

  • 老生常谈Java反射机制(必看篇)

    什么是反射机制 反射是java语言的一个特性,它允程序在运行时(注意不是编译的时候)来进行自我检查并且对内部的成员进行操作.例如它允许一个java的类获取他所有的成员变量和方法并且显示出来.这个能特定我们不常看到,但是在其他的比如C或者C++语言中很不就存在这个特性.一个常见的例子是在JavaBean中,一些组件可以通过一个构造器来操作.这个构造器就是用的反射在动态加载的时候来获取的java中类的属性的. 主要的类 Class 类的实例表示正在运行的 Java 应用程序中的类和接口.Class没

  • Java 反射机制原理与用法详解

    本文实例讲述了Java 反射机制原理与用法.分享给大家供大家参考,具体如下: 反射反射,程序员的快乐! 1.什么是反射? Java反射就是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意方法和属性:并且能改变它的属性.而这也是Java被视为动态(或准动态,为啥要说是准动态,因为一般而言的动态语言定义是程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言.从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C#不是

  • 利用Java反射机制实现对象相同字段的复制操作

    一.如何实现不同类型对象之间的复制问题? 1.为什么会有这个问题? 近来在进行一个项目开发的时候,为了隐藏后端数据库表结构.同时也为了配合给前端一个更友好的API接口文档(swagger API文档),我采用POJO来对应数据表结构,使用VO来给传递前端要展示的数据,同时使用DTO来进行请求参数的封装.以上是一个具体的场景,可以发现这样子一个现象:POJO.VO.DTO对象是同一个数据的不同视图,所以会有很多相同的字段,由于不同的地方使用不同的对象,无可避免的会存在对象之间的值迁移问题,迁移的一

随机推荐