一、工具类概述
在编程中，经常需要对数据进行合并操作。所以我写了一个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;
}
}
