如何将两个对象合并在一起，对象合并工具类的实现

一、工具类概述

在编程中，经常需要对数据进行合并操作。所以我写了一个ModelMergeUtil 工具类用于将不同的对象或数据进行合并，以满足在特定场景下的数据整合需求。以下是工具类的使用说明

二、方法详解

（一）merge(String originJsonStr, String currentJsonStr, Class<T> clazz) 方法

这个方法接受两个 JSON 字符串和一个类类型作为参数。它首先将这两个 JSON 字符串转换为 Map 对象，然后进行数据合并，最后将合并后的 Map 转换为指定类型的对象并返回。

以下是针对这个方法的测试示例：

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

class ModelMergeUtilTest {

    @Test
    void testMergeWithJsonStringsAndClass() {
        String originJsonStr = "{\"name\":\"Alice\",\"age\":20}";
        String currentJsonStr = "{\"age\":25,\"city\":\"London\"}";
        ModelMergeUtil modelMergeUtil = new ModelMergeUtil();

        Person mergedPerson = modelMergeUtil.merge(originJsonStr, currentJsonStr, Person.class);

        assertEquals("Alice", mergedPerson.getName());
        assertEquals(25, mergedPerson.getAge());
        assertEquals("London", mergedPerson.getCity());
    }
}

class Person {
    private String name;
    private int age;
    private String city;

    // 省略 getter 和 setter 方法
}

（二）merge(T originObject, T currentObject, Class<T> clazz) 方法

该方法接受两个对象和一个类类型作为参数。它会将这两个对象转换为 JSON 字符串，然后执行与上述方法类似的合并操作。

对应的测试方法如下：

@Test
void testMergeWithObjectsAndClass() {
    Person originPerson = new Person();
    originPerson.setName("Bob");
    originPerson.setAge(30);

    Person currentPerson = new Person();
    currentPerson.setAge(35);
    currentPerson.setCity("New York");

    ModelMergeUtil modelMergeUtil = new ModelMergeUtil();

    Person mergedPerson = modelMergeUtil.merge(originPerson, currentPerson, Person.class);

    assertEquals("Bob", mergedPerson.getName());
    assertEquals(35, mergedPerson.getAge());
    assertEquals("New York", mergedPerson.getCity());
}

（三）merge(String originJsonStr, String currentJsonStr) 方法

此方法接受两个 JSON 字符串，将其转换为 Map 对象进行合并，最后再转换回 JSON 字符串返回。

测试代码如下：

@Test
void testMergeWithJsonStrings() {
    String originJsonStr = "{\"name\":\"Eve\",\"age\":22}";
    String currentJsonStr = "{\"age\":28,\"occupation\":\"Engineer\"}";
    ModelMergeUtil modelMergeUtil = new ModelMergeUtil();

    String mergedJson = modelMergeUtil.merge(originJsonStr, currentJsonStr);

    assertTrue(mergedJson.contains("name\":\"Eve\""));
    assertTrue(mergedJson.contains("age\":28"));
    assertTrue(mergedJson.contains("occupation\":\"Engineer\""));
}

（四）merge(Object originObject, Object currentObject) 方法

该方法能够处理对象类型的输入。如果输入是字符串，则直接调用相应的字符串版本的合并方法；否则，将对象转换为 JSON 字符串后进行合并。

测试示例：

@Test
void testMergeWithObjects() {
    Object originObject = "{\"fruit\":\"Apple\",\"quantity\":5}";
    Object currentObject = "{\"quantity\":10,\"color\":\"Red\"}";
    ModelMergeUtil modelMergeUtil = new ModelMergeUtil();

    String mergedJson = modelMergeUtil.merge(originObject, currentObject);

    assertTrue(mergedJson.contains("fruit\":\"Apple\""));
    assertTrue(mergedJson.contains("quantity\":10"));
    assertTrue(mergedJson.contains("color\":\"Red\""));
}

三、总结

ModelMergeUtil 工具类通过多种 merge 方法的实现，为我们提供了灵活且高效的数据合并解决方案，使得在处理对象和数据的合并操作时更加便捷和可靠。希望以上说明和测试示例能够帮助您更好地理解和使用 ModelMergeUtil 工具类。

ModelMergeUtil 工具类的依赖gson。

<dependency>
	<groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.8</version>
</dependency>

ModelMergeUtil 工具类的完整代码如下：

package com.fhey.common.utils;

import com.ecwid.consul.json.GsonFactory;
import com.google.gson.Gson;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.ObjectUtils;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * @author: fhey
 * @create: 2021-02-22 13:53
 * @description: 对象合并工具类
 */
@Slf4j
public class ModelMergeUtil2 {
    /**
     * 将当前对象与原始对象比较，并将数据合并到原始对象中
     *
     * @param originJsonStr
     * @param currentJsonStr
     * @param clazz
     */
    public static <T> T merge(String originJsonStr, String currentJsonStr, Class<T> clazz) {
        String mergeStr = merge(originJsonStr, currentJsonStr);
        T object =  GsonFactory.getGson().fromJson(mergeStr, clazz);
        return object;
    }

    /**
     * 将当前对象与原始对象比较，并将数据合并到原始对象中
     *
     * @param originObject
     * @param currentObject
     * @param clazz
     */
    public static <T> T merge(T originObject, T currentObject, Class<T> clazz) {
        String mergeStr = merge(originObject, currentObject);
        T object = GsonFactory.getGson().fromJson(mergeStr, clazz);
        return object;
    }

    /**
     * 将当前对象与原始对象比较，并将数据合并到原始对象中
     *
     * @param originJsonStr
     * @param currentJsonStr
     */
    public static String merge(String originJsonStr, String currentJsonStr) {
        log.info("merge's origin ---> {}", originJsonStr);
        log.info("merge's current ---> {}", currentJsonStr);

        Gson gson = GsonFactory.getGson();
        Map<String, Object> originMap = StringUtils.isBlank(originJsonStr)
                ? new HashMap<>()
                : gson.fromJson(originJsonStr, Map.class);
        Map<String, Object> currentMap = StringUtils.isBlank(currentJsonStr)
                ? new HashMap<>()
                : gson.fromJson(currentJsonStr, Map.class);
        Map<String, Object> newMap = merge(originMap, currentMap);
        String merge = gson.toJson(newMap);
        log.info("merge's result ---> {}", merge);
        return merge;
    }

    /**
     * 将当前对象与原始对象比较，并将数据合并到原始对象中
     *
     * @param originObject
     * @param currentObject
     */
    public static String merge(Object originObject, Object currentObject) {
        if (originObject instanceof String && currentObject instanceof String) {
            return merge(originObject.toString(), currentObject.toString());
        }
        Gson gson = GsonFactory.getGson();
        String originJsonStr = ObjectUtils.isEmpty(originObject) ? StringUtils.EMPTY : gson.toJson(originObject);
        String currentJsonStr = ObjectUtils.isEmpty(currentObject) ? StringUtils.EMPTY : gson.toJson(currentObject);
        return merge(originJsonStr, currentJsonStr);
    }



    /**
     * 将当前Map与原始Map比较，并将数据统一存在原始Map中
     *
     * @param originMap
     * @param currentMap
     */
    private static Map<String, Object> merge(Map<String, Object> originMap, Map<String, Object> currentMap) {
        for (Iterator<Map.Entry<String, Object>> it = currentMap.entrySet().iterator(); it.hasNext(); ) {
            Map.Entry<String, Object> item = it.next();
            String key = item.getKey();
            Object newValue = item.getValue();
            if (originMap.containsKey(key)) {
                Object oldValue = originMap.get(key);
                if (!newValue.equals(oldValue)) {
                    originMap.put(key, newValue);
                }
            } else {
                originMap.put(key, newValue);
            }
        }
        return originMap;
    }
}