快捷導(dǎo)航

Java循環(huán)對bean的屬性進(jìn)行賦值的實(shí)現(xiàn)

更新時間：2021年08月20日 16:02:26 作者：BHBshy

本文主要介紹了Java循環(huán)對bean的屬性進(jìn)行賦值，文中通過示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下

項(xiàng)目背景

我們開發(fā)過程中會碰到這樣一類問題，就是數(shù)據(jù)層或三方接口返回的Bean對象需要轉(zhuǎn)換重新裝換一下我們需要的對象。我們通常的做法就是通過getter/setter方法進(jìn)行一個一個進(jìn)行賦值，這樣的話書寫起來太復(fù)雜了，并且太重復(fù)了。我嘗試寫了一個工具類，能夠?qū)Ω鞣N場景下的對象進(jìn)行相互賦值。

功能介紹

可以為將要賦值的對象進(jìn)行單個單個的按順序賦值
通過傳遞的屬性的index（就是他是第幾個屬性）獲取本屬性的值
返回對象中屬性的數(shù)量
兩個對象之間相互拷貝屬性值
傳遞一個list,遍歷bean進(jìn)行賦值
傳遞一個數(shù)組，對對象進(jìn)行賦值
返回一個對象的屬性值集合
返回一個對象的屬性值數(shù)組

注意注意注意！?。?br />

getDeclaredFields方法不能保證字段聲明的順序進(jìn)行返回，但是基本上會按照這個順序的。所以以下的方法是建立在返回正確的順序上的基礎(chǔ)上的，但是兩個對象相互拷貝是沒有問題的。

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

/**
 * @author haoyan.shi
 * 想設(shè)計(jì)一個能夠解析一個bean的全部屬性并按照順序進(jìn)行遍歷
 */
public class ObjectUtils {

    /**
     * 按照屬性的順序賦值?？山邮躰ull，但是不能跳過某個屬性進(jìn)行賦值。就是說就算
     * 有一個值為空，那你也要傳遞進(jìn)行null
     *
     * @param target
     * @param value
     * @param <E>
     * @return
     */
    public static <E> E forEachSetValue(E target, Object value) {
        if (target == null) {
            return target;
        }
        List<Field> fields = new ArrayList<>();
        try {
            // 1.解析出所有的屬性
            Field[] declaredFields = target.getClass().getDeclaredFields();
            for (Field declaredField : declaredFields) {
                declaredField.setAccessible(true);
                fields.add(declaredField);
            }
            // 2.把每個屬性放入一個集合中
            if (fields.size() <= 0) {
                return target;
            }
            while (fields.get(0).get(target) != null) {
                fields.remove(0);
            }
            Field field = fields.get(0);
            field.set(target, value);
            fields.remove(0);
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return target;
    }

    /**
     * 本方法為了遍歷索引進(jìn)行賦值
     *
     * @param e
     * @param index
     * @return
     */
    public static Object forEachGetValue(Object e, int index) {
        try {
            Field[] declaredFields = e.getClass().getDeclaredFields();
            for (Field declaredField : declaredFields) {
                declaredField.setAccessible(true);
            }
            return declaredFields[index].get(e);
        } catch (IllegalAccessException illegalAccessException) {
            illegalAccessException.printStackTrace();
        }
        return e;
    }

    public static int size(Object o) {
        if (o == null) {
            return 0;
        }
        Field[] declaredFields = o.getClass().getDeclaredFields();
        return declaredFields.length;
    }

    /**
     * 本方法是為了把已經(jīng)有值得對象中屬性名相同的名屬性賦值到?jīng)]有值得對象用。
     *
     * @param target
     * @param value
     */
    public static <E> E copyValueFromObject(E target, Object value) {
        if (target == null || value == null) {
            return null;
        }
        Field[] vs = target.getClass().getDeclaredFields();
        Field[] ts = value.getClass().getDeclaredFields();

        try {
            for (int i = 0; i < vs.length; i++) {
                for (int j = 0; j < ts.length; j++) {
                    if (vs[i].getName().equals(ts[j])) {
                        ts[j].set(target, vs[i].get(value));
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return target;
    }

    /**
     * 這個方法能把list中的值按照順序設(shè)置到目標(biāo)對象中
     *
     * @param target
     * @param value
     * @param <E>
     * @return
     */
    public static <E> E forEachSetValueFromList(E target, List value) {

        if (target == null || value == null || value.size() == 0) {
            return target;
        }
        Field[] ts = target.getClass().getDeclaredFields();
        try {
            for (int i = 0; i < ts.length; i++) {
                ts[i].set(target, value.get(i));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return target;
    }

    /**
     * 從數(shù)組中進(jìn)行設(shè)置值
     *
     * @param target
     * @param value
     * @param <E>
     * @return
     */
    public static <E> E forEachSetValueFromArray(E target, Object[] value) {

        if (target == null || value == null || value.length == 0) {
            return target;
        }
        Field[] ts = target.getClass().getDeclaredFields();
        try {
            for (int i = 0; i < ts.length; i++) {
                ts[i].set(target, value[i]);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return target;
    }


    public static Object[] getArrayValue(Object o) {
        Field[] declaredFields = o.getClass().getDeclaredFields();
        Object[] result = new Object[declaredFields.length];
        try {
            for (int i = 0; i < declaredFields.length; i++) {
                result[i] = declaredFields[i].get(o);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    public static List getListValue(Object o) {
        Field[] declaredFields = o.getClass().getDeclaredFields();
        List result = new ArrayList(declaredFields.length);
        try {
            for (int i = 0; i < declaredFields.length; i++) {
                result.add(declaredFields[i].get(o));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
}