对象A转为对象B（只赋值相同属性名的信息）

package com.zh.vmc.common.utils;


import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.*;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author liuhuanhuan    @date 2019/8/6
 */
public class BeanConvertUtil {

    enum FieldType { STATIC, NOT_STATIC, ALL }

    private static ReentrantReadWriteLock.WriteLock lock = new ReentrantReadWriteLock().writeLock();

    private static final Map<Class<?>, Map<String, Field>> METADATA = new HashMap<>();



    /**
     * 对象转换
     *
     * @param source
     *            源对象
     * @param targetClass
     *            目标类
     * @return 返回一个新的目标类对象, 该目标类对象的属性值从源对象中拷贝而来
     */
    public static <T> T convert(Object source, Class<T> targetClass) {
        T target = newInstance(targetClass);
        copyProperties(source, target);
        return target;
    }

    /**
     * 对象列表转换
     *
     * @param sources
     *            源对象列表
     * @param targetClass
     *            目标类
     * @return 返回一个新的目标对象列表, 每个目标类对象的属性值从源对象中拷贝而来
     */
    public static <T> List<T> convert(Collection<?> sources, Class<T> targetClass) {
        List<T> targets = new ArrayList<T>();
        if (sources != null && sources.size() > 0) {
            for (Object source : sources) {
                targets.add(convert(source, targetClass));
            }
        }
        return targets;
    }

    /**
     * 创建类的一个实例
     *
     * @param beanClass
     *            类
     */
    public static <T> T newInstance(Class<T> beanClass) {
        try {
            return beanClass.newInstance();
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 属性拷贝, 当且仅当两个对象的非静态属性名称相同且对应的属性类型也相同时才进行属性值拷贝
     *
     * @param source
     *            源对象
     * @param target
     *            目标对象
     */
    public static void copyProperties(Object source, Object target) {
        copyProperties(source, target, true);
    }

    /**
     * 属性拷贝, 当且仅当两个对象的非静态属性名称相同且对应的属性类型也相同时才进行属性值拷贝
     *
     * @param source
     *            源对象
     * @param target
     *            目标对象
     * @param copyNullProperty
     *            是否拷贝null属性值
     */
    public static void copyProperties(Object source, Object target, boolean copyNullProperty) {
        if (source == null) {
            return ;
        }
        Class<?> sourceClass = source.getClass();
        Class<?> targetClass = target.getClass();
        Map<String, Field> targetFields = getFieldsMap(targetClass, FieldType.NOT_STATIC);
        Map<String, Field> sourceFields = getFieldsMap(sourceClass, FieldType.NOT_STATIC);
        for (String name : targetFields.keySet()) {
            if (sourceFields.containsKey(name)) {
                Field sourceField = sourceFields.get(name);
                Field targetField = targetFields.get(name);
                if (targetField.getType() == sourceField.getType()) {
                    Object value = getPropertyValue(source, sourceField);
                    if (value == null && !copyNullProperty) {
                        continue ;
                    }
                    setPropertyValue(target, targetField, value);
                }
            }
        }
    }

    /**
     * 设置对象属性的值
     *
     * @param bean
     *            目标对象
     * @param field
     *            属性名称
     * @param propertyValue
     *            属性的值
     */
    public static void setPropertyValue(Object bean, Field field, Object propertyValue) {
        try {
            field.set(bean, propertyValue);
        } catch (Throwable e) {
            throw new RuntimeException(bean.getClass().getName() + " " + field.getName() + " " + propertyValue, e);
        }
    }

    /**
     * 获取目标属性的值
     *
     * @param bean
     *            目标对象
     * @param field
     *            属性名称
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T getPropertyValue(Object bean, Field field) {
        try {
            return (T) field.get(bean);
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 设置属性的值
     *
     * @param bean
     *            对象或类
     * @param property
     *            类属性或对象属性名称
     * @param propertyValue
     *            属性的值
     */
    public static void setPropertyValue(Object bean, String property, Object propertyValue) {
        if (bean != null) {
            Class<?> beanClass = null;
            if (bean instanceof Class) {
                beanClass = (Class<?>) bean;
            } else {
                beanClass = bean.getClass();
            }
            Field field = getFieldsMap(beanClass, FieldType.ALL).get(property);
            if (field != null) {
                setPropertyValue(bean, field, propertyValue);
            }
        }
    }

    /**
     * 获取属性的值
     *
     * @param bean
     *            对象或类
     * @param property
     *            类属性名称或对象属性名称
     * @return
     */
    public static <T> T getPropertyValue(Object bean, String property) {
        if (bean != null) {
            Class<?> beanClass = null;
            if (bean instanceof Class) {
                beanClass = (Class<?>) bean;
            } else {
                beanClass = bean.getClass();
            }
            Field field = getFieldsMap(beanClass, FieldType.ALL).get(property);
            if (field != null) {
                return getPropertyValue(bean, field);
            }
        }
        return null;
    }

    /**
     * 获取属性的类型
     *
     * @param bean
     *            对象或类
     * @param property
     *            类属性名称或对象属性名称
     * @return
     */
    public static Class<?> getPropertyType(Object bean, String property) {
        if (bean != null) {
            Class<?> beanClass = null;
            if (bean instanceof Class) {
                beanClass = (Class<?>) bean;
            } else {
                beanClass = bean.getClass();
            }
            Field field = getFieldsMap(beanClass, FieldType.ALL).get(property);
            if (field != null) {
                return field.getType();
            }
        }
        return null;
    }

    /**
     * 获取声明的属性表
     *
     * @param beanClass
     *            目标类
     * @param fieldType
     *            属性类型
     * @return
     */
    private static Map<String, Field> getFieldsMap(Class<?> beanClass, FieldType fieldType) {
        Map<String, Field> map = getReferableFieldsMap(beanClass);
        Map<String, Field> target = new HashMap<>();
        if (map != null && !map.isEmpty()) {
            for (String name : map.keySet()) {
                Field field = map.get(name);
                switch (fieldType) {
                    case ALL:
                        target.put(name, field);
                        break;
                    case STATIC:
                        if ((field.getModifiers() & Modifier.STATIC) == Modifier.STATIC) {
                            target.put(name, field);
                        }
                        break;
                    case NOT_STATIC:
                        if ((field.getModifiers() & Modifier.STATIC) != Modifier.STATIC) {
                            target.put(name, field);
                        }
                        break;
                }
            }
        }
        return target;
    }

    /**
     * 获取声明的所有属性表
     *
     * @param beanClass
     *            目标类
     * @return
     */
    private static Map<String, Field> getReferableFieldsMap(Class<?> beanClass) {
        if (!METADATA.containsKey(beanClass)) {
            try {
                lock.lock();
                if (!METADATA.containsKey(beanClass)) {
                    Map<String, Field> map = new HashMap<>();
                    while (beanClass != null) {
                        map.putAll(getDeclaredFieldsMap(beanClass));
                        beanClass = beanClass.getSuperclass();
                    }
                    METADATA.put(beanClass, map);
                }
            } finally {
                lock.unlock();
            }
        }
        return METADATA.get(beanClass);
    }

    /**
     * 获取当前类声明的属性表
     *
     * @param beanClass
     *            目标类
     * @return
     */
    private static Map<String, Field> getDeclaredFieldsMap(Class<?> beanClass) {
        Field[] fields = beanClass.getDeclaredFields();
        Map<String, Field> map = new HashMap<String, Field>();
        if (fields != null && fields.length > 0) {
            for (Field field : fields) {
                field.setAccessible(true);
                map.put(field.getName(), field);
            }
        }
        return map;
    }


}

最后

以上就是苗条夏天为你收集整理的对象A转为对象B（只赋值相同属性名的信息）的全部内容，希望文章能够帮你解决对象A转为对象B（只赋值相同属性名的信息）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。