自定义对象数据替换其字段值

最新推荐文章于 2023-08-25 13:43:29 发布

原创最新推荐文章于 2023-08-25 13:43:29 发布 · 1.3k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #map #对象 #替换 #数据

java 专栏收录该内容

7 篇文章

订阅专栏

本文介绍了一个Java工具类，用于实现对象之间的字段复制、验证对象字段是否为空、对象与Map之间的转换等功能。提供了两种对象复制的方法，一种适用于相同类型的对象间复制，另一种可在不同类型但有相同字段的对象间进行复制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

/**
 * 数据操作工具类
 * @author xuyang
 * @time 2016/11/10 15:58
 */
public class DataHelper {
    /**
     * 替换对象的字段数据（对象类型必须相同）
     * @param sourceObject 被替换的源数据对象 replaceObject 替换的数据对象
     * @return Object 替换后的数据对象
     * @author xuyang
     * @time 2016/11/10 15:58
     */
    public static <T> T updateObject(T sourceObject,T replaceObject){
        Class<?> sourceClazz = sourceObject.getClass();
        Field[] sourceFields = sourceClazz.getDeclaredFields();

        Class<?> replaceClazz = sourceObject.getClass();
        Field[] replaceFields = replaceClazz.getDeclaredFields();

        try {
            for (int i = 0;i < replaceFields.length;i++){
                Field replaceField = replaceFields[i];
                replaceField.setAccessible(true);
                //字段子更新赋值判断
                if (null != replaceField.get(replaceObject)) {
                    Field sourceField = sourceFields[i];
                    sourceField.setAccessible(true);
                    sourceField.set(sourceObject,replaceField.get(replaceObject));
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return sourceObject;
    }

    /**
     * 替换对象的字段数据(对象类型可以不同，只替换同类型同字段名的字段值)
     * @param sourceObject 被替换的源数据对象 replaceObject 替换的数据对象
     * @return Object 替换后的数据对象
     * @author xuyang
     * @time 2016/11/10 15:58
     */
    public static <T> T updateDifObject(T sourceObject,Object replaceObject){
        Class<?> sourceClazz = sourceObject.getClass();
        Field[] sourceFields = sourceClazz.getDeclaredFields();

        Class<?> replaceClazz = replaceObject.getClass();
        Field[] replaceFields = replaceClazz.getDeclaredFields();

        try {
            for (int i = 0;i < replaceFields.length;i++){
                Field replaceField = replaceFields[i];
                replaceField.setAccessible(true);
                //字段子更新赋值判断
                if (null != replaceField.get(replaceObject)) {
                    for (int j = 0; j < sourceFields.length; j++) {
                        Field sourceField = sourceFields[j];
                        if(sourceField.getName().equals(replaceField.getName())
                                && sourceField.getType().getName().equals(replaceField.getType().getName())){
                            sourceField.setAccessible(true);
                            sourceField.set(sourceObject,replaceField.get(replaceObject));
                            break;
                        }
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return sourceObject;
    }


    /**
     * 判断对象某些值是否为空
     * @param object
     * @param <T>
     * @return
     * @author gaoliubei
     */
    public static <T> String verify(T object,String[] needVerify)
    {
        Class<?> sourceClazz = object.getClass();
        Field [] fields = sourceClazz.getDeclaredFields();
        StringBuilder result = new StringBuilder();
        boolean isLegal = true;
        for (int i = 0;i < fields.length;i++)
        {
            Field field = fields[i];
            field.setAccessible(true);
            try {
                Object value = field.get(object);
                if (value == null)
                {

                    String filedName = field.getName();
                    boolean isd = false;
                    for (int j = 0;j < needVerify.length; j++)
                    {
                        String isResult = needVerify[j];
                        if (isResult == filedName)
                        {
                            isLegal = false;
                            isd = true;
                            break;
                        }
                    }

                    if (isd)
                    {
                        result.append(filedName+" : 不能为空 ");
                    }

                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }

        if (!isLegal)
        {
            return result.toString();
        }
        return null;
    }

    /**
     * map转对象
     * @param map
     * @param beanClass
     * @return
     * @throws Exception
     */
    public static Object mapToObject(Map<String, Object> map, Class<?> beanClass) {
        try {
            if (map == null)
                return null;

            Object obj = beanClass.newInstance();

            BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor property : propertyDescriptors) {
                Method setter = property.getWriteMethod();
                if (setter != null) {
                    setter.invoke(obj, map.get(property.getName()));
                }
            }

            return obj;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 对象转map
     * @param obj
     * @return
     */
    public static Map<?, ?> objectToMap(Object obj) {
        try {
            if(obj == null)
                return null;

            Map<String, Object> map = new HashMap<String, Object>();

            BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor property : propertyDescriptors) {
                String key = property.getName();
                if (key.compareToIgnoreCase("class") == 0) {
                    continue;
                }
                Method getter = property.getReadMethod();
                Object value = getter!=null ? getter.invoke(obj) : null;
                map.put(key, value);
            }

            return map;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

}