vue合并两个对象

Posted 2023-04-20

参考技术A Object.assign() 方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。

如何将两个java对象合并为一个？

【中文标题】如何将两个java对象合并为一个？

【英文标题】：How to merge two java objects into one?

【发布时间】：2017-01-11 22:57:20

【问题描述】：

我有两个 java 对象实例，我想将它们的值合并到一个实例中。当两个对象实例都包含一个字段的值时，我需要选择哪个对象实例优先。我也不想用空值覆盖值。

例子：

MyClass source = new MyClass("source", 1, null);
MyClass target = new MyClass("target", 2, "b");
merge(source, target);
// target now has values ("source", 1, "b")

我正在使用 Java 8 和 Spring boot 1.4.1。

编辑：看起来我不清楚，所以我添加了更多描述。另外，我已经提供了自己的解决方案。目的是在其他人遇到相同问题时提供此解决方案。我在这里找到了其他线程询问相同或类似的问题，但他们没有像我在下面发布的那样提供完整的解决方案。

【问题讨论】：

这是一个不清楚的问题。在什么意义上合并？您可以合并列表，至少如果它们已排序，但我怀疑您还有其他想法？

我有对象 A 和对象 B。两者都有字段 String X、int Y、列表 Z。我想将对象 A 中的所有字段（而不是空字段）复制到对象 B 中。这就是我可以将来自两个来源的输入合并到一个最终对象中以持久化。

【参考方案1】：

Spring 的 spring-beans 库有一个 org.springframework.beans.BeanUtils 类，它提供了一个 copyProperties 方法来将源对象实例复制到目标对象实例中。但是，它只对对象的第一级字段这样做。这是我的解决方案，基于BeanUtils.copyProperties，递归地为每个子对象执行复制，包括集合和映射。

package my.utility;

import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeansException;
import org.springframework.beans.FatalBeanException;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * Created by cdebergh on 1/6/17.
 */
public class BeanUtils extends org.springframework.beans.BeanUtils 

    /**
     * Copy the not null property values of the given source bean into the target bean.
     * <p>Note: The source and target classes do not have to match or even be derived
     * from each other, as long as the properties match. Any bean properties that the
     * source bean exposes but the target bean does not will silently be ignored.
     * <p>This is just a convenience method. For more complex transfer needs,
     * consider using a full BeanWrapper.
     * @param source the source bean
     * @param target the target bean
     * @throws BeansException if the copying failed
     * @see BeanWrapper
     */
    public static void copyPropertiesNotNull(Object source, Object target) throws BeansException 
        copyPropertiesNotNull(source, target, null, (String[]) null);
    

    private static void setAccessible(Method method) 
        if (!Modifier.isPublic(method.getDeclaringClass().getModifiers())) 
            method.setAccessible(true);
        
    

    /**
     * Copy the not null property values of the given source bean into the given target bean.
     * <p>Note: The source and target classes do not have to match or even be derived
     * from each other, as long as the properties match. Any bean properties that the
     * source bean exposes but the target bean does not will silently be ignored.
     * @param source the source bean
     * @param target the target bean
     * @param editable the class (or interface) to restrict property setting to
     * @param ignoreProperties array of property names to ignore
     * @throws BeansException if the copying failed
     * @see BeanWrapper
     */
    private static void copyPropertiesNotNull(Object source, Object target, Class<?> editable, String... ignoreProperties)
            throws BeansException 

        Assert.notNull(source, "Source must not be null");
        Assert.notNull(target, "Target must not be null");

        Class<?> actualEditable = target.getClass();
        if (editable != null) 
            if (!editable.isInstance(target)) 
                throw new IllegalArgumentException("Target class [" + target.getClass().getName() +
                        "] not assignable to Editable class [" + editable.getName() + "]");
            
            actualEditable = editable;
        
        PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
        List<String> ignoreList = (ignoreProperties != null ? Arrays.asList(ignoreProperties) : null);

        for (PropertyDescriptor targetPropertyDescriptor : targetPds) 
            Method targetWriteMethod = targetPropertyDescriptor.getWriteMethod();
            if (targetWriteMethod != null
                    && (ignoreList == null || !ignoreList.contains(targetPropertyDescriptor.getName()))) 
                PropertyDescriptor sourcePropertyDescriptor =
                        getPropertyDescriptor(source.getClass(), targetPropertyDescriptor.getName());
                if (sourcePropertyDescriptor != null) 
                    Method sourceReadMethod = sourcePropertyDescriptor.getReadMethod();
                    if (sourceReadMethod != null &&
                            ClassUtils.isAssignable(
                                    targetWriteMethod.getParameterTypes()[0], sourceReadMethod.getReturnType())) 
                        try 
                            Method targetReadMethod = targetPropertyDescriptor.getReadMethod();
                            setAccessible(sourceReadMethod);
                            setAccessible(targetWriteMethod);
                            Object sourceValue = sourceReadMethod.invoke(source);

                            if (sourceValue != null && targetReadMethod != null) 
                                setAccessible(targetReadMethod);
                                Object targetValue = targetReadMethod.invoke(target);
                                if (targetValue == null) 
                                    targetWriteMethod.invoke(target, sourceValue);
                                 else if(targetValue instanceof Collection<?>) 
                                    ((Collection) targetValue).addAll((Collection) sourceValue);
                                 else if (targetValue instanceof Map<?,?>) 
                                    ((Map) targetValue).putAll((Map) sourceValue);
                                 else 
                                    copyPropertiesNotNull(sourceValue, targetValue, editable, ignoreProperties);
                                
                            
                        
                        catch (Throwable ex) 
                            throw new FatalBeanException(
                                    "Could not copy property '" + targetPropertyDescriptor.getName() +
                                    "' from source to target", ex);