35 changed files with 2393 additions and 1 deletions
@ -0,0 +1,82 @@ |
|||
package com.zc.business.utils.diff; |
|||
|
|||
import com.zc.business.utils.diff.algorithm.AlgorithmModule; |
|||
import com.zc.business.utils.diff.algorithm.array.SimilarArrayComparator; |
|||
import com.zc.business.utils.diff.algorithm.array.SimpleArrayComparator; |
|||
import com.zc.business.utils.diff.algorithm.nulls.DefaultNullComparator; |
|||
import com.zc.business.utils.diff.algorithm.object.LeftJoinObjectComparator; |
|||
import com.zc.business.utils.diff.algorithm.object.SimpleObjectComparator; |
|||
import com.zc.business.utils.diff.algorithm.other.DefaultOtherComparator; |
|||
import com.zc.business.utils.diff.algorithm.primitive.DefaultPrimitiveComparator; |
|||
|
|||
/** |
|||
* 算法模型枚举类：提供一些默认实现的算法模型 |
|||
* @Author JingWei |
|||
* @create 2022/3/2 |
|||
*/ |
|||
public enum AlgorithmEnum { |
|||
|
|||
/** |
|||
* 默认的比较算法模型 |
|||
*/ |
|||
DEFAULT(defaultAlgorithmModule()), |
|||
|
|||
/** |
|||
* 数组比较采用Simple，对象比较采用Simple |
|||
*/ |
|||
SIMPLE_ARRAY_AND_SIMPLE_OBJECT(simpleAndSimpleAlgorithmModule()), |
|||
|
|||
/** |
|||
* 数组比较采用Simple，对象比较采用LeftJoin |
|||
*/ |
|||
SIMPLE_ARRAY_AND_LEFTJOIN_OBJECT(simpleAndLeftJoinAlgorithmModule()), |
|||
|
|||
/** |
|||
* 数组比较采用Similar，对象比较采用LeftJoin |
|||
*/ |
|||
SIMLAR_ARRAY_AND_LEFTJOIN_OBJECT(similarAndLeftJoinAlgorithmModule()), |
|||
|
|||
/** |
|||
* 数组比较采用Similar，对象比较采用Simple |
|||
*/ |
|||
MOST_COMMONLY_USED(similarAndSimpleAlgorithmModule()); |
|||
|
|||
final private AlgorithmModule algorithmModule; |
|||
|
|||
AlgorithmEnum(AlgorithmModule algorithmModule) { |
|||
this.algorithmModule = algorithmModule; |
|||
} |
|||
|
|||
|
|||
public AlgorithmModule getAlgorithmModule() { |
|||
return algorithmModule; |
|||
} |
|||
|
|||
private static AlgorithmModule defaultAlgorithmModule() { |
|||
return new AlgorithmModule(new SimpleObjectComparator(), new SimilarArrayComparator(), |
|||
new DefaultPrimitiveComparator(), new DefaultNullComparator(), new DefaultOtherComparator()); |
|||
|
|||
} |
|||
|
|||
private static AlgorithmModule simpleAndSimpleAlgorithmModule() { |
|||
return new AlgorithmModule(new SimpleObjectComparator(), new SimpleArrayComparator(), |
|||
new DefaultPrimitiveComparator(), new DefaultNullComparator(), new DefaultOtherComparator()); |
|||
} |
|||
|
|||
|
|||
private static AlgorithmModule simpleAndLeftJoinAlgorithmModule() { |
|||
return new AlgorithmModule(new LeftJoinObjectComparator(), new SimpleArrayComparator(), |
|||
new DefaultPrimitiveComparator(), new DefaultNullComparator(), new DefaultOtherComparator()); |
|||
} |
|||
|
|||
private static AlgorithmModule similarAndLeftJoinAlgorithmModule() { |
|||
return new AlgorithmModule(new LeftJoinObjectComparator(), new SimilarArrayComparator(), |
|||
new DefaultPrimitiveComparator(), new DefaultNullComparator(), new DefaultOtherComparator()); |
|||
} |
|||
|
|||
private static AlgorithmModule similarAndSimpleAlgorithmModule() { |
|||
return new AlgorithmModule(new SimpleObjectComparator(), new SimilarArrayComparator(), |
|||
new DefaultPrimitiveComparator(), new DefaultNullComparator(), new DefaultOtherComparator()); |
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,208 @@ |
|||
package com.zc.business.utils.diff; |
|||
|
|||
import com.google.gson.JsonElement; |
|||
import com.google.gson.JsonParser; |
|||
import com.zc.business.utils.diff.algorithm.AlgorithmModule; |
|||
import com.zc.business.utils.diff.algorithm.array.ArrayComparator; |
|||
import com.zc.business.utils.diff.algorithm.array.SimilarArrayComparator; |
|||
import com.zc.business.utils.diff.algorithm.nulls.DefaultNullComparator; |
|||
import com.zc.business.utils.diff.algorithm.nulls.NullComparator; |
|||
import com.zc.business.utils.diff.algorithm.object.ObjectComparator; |
|||
import com.zc.business.utils.diff.algorithm.object.SimpleObjectComparator; |
|||
import com.zc.business.utils.diff.algorithm.other.DefaultOtherComparator; |
|||
import com.zc.business.utils.diff.algorithm.other.OtherComparator; |
|||
import com.zc.business.utils.diff.algorithm.primitive.DefaultPrimitiveComparator; |
|||
import com.zc.business.utils.diff.algorithm.primitive.PrimitiveComparator; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
import com.zc.business.utils.diff.model.Result; |
|||
import com.zc.business.utils.diff.model.ResultConvertUtil; |
|||
|
|||
import java.util.List; |
|||
|
|||
/** |
|||
* DIFF入口，用于比较两个Json字符串 |
|||
* @Author JingWei |
|||
* @create 2022/2/25 |
|||
*/ |
|||
public class Diff { |
|||
/** |
|||
* 算法模型。根据传入的算法模型使用该算法模型进行diff比较。 |
|||
*/ |
|||
private AlgorithmEnum algorithmEnum; |
|||
/** |
|||
* 特殊路径集合。当前路径符合特殊路径且特殊路径下比较结果相同，会在返回结果中做额外标识标识。 |
|||
*/ |
|||
private List<String> specialPath; |
|||
/** |
|||
* 噪音字段集合。如果当前路径符合噪音字段路径，则不会比较。 |
|||
*/ |
|||
private List<String> noisePahList; |
|||
/** |
|||
* 以下为5种可以自定义的比较器，条件是algorithmEnum为空（如果algorithmEnum有值，直接使用algorithmEnum对应算法模型，比较器不生效） |
|||
*/ |
|||
private ObjectComparator objectComparator; |
|||
private ArrayComparator arrayComparator; |
|||
private PrimitiveComparator primitiveComparator; |
|||
private NullComparator nullComparator; |
|||
private OtherComparator otherComparator; |
|||
|
|||
|
|||
/** |
|||
* @param a 要比较的第一个JsonElement |
|||
* @param b 要比较的第二个JsonElement |
|||
* @return 用来展示的diff结果 |
|||
*/ |
|||
public List<Result> diffElement(JsonElement a, JsonElement b) { |
|||
DiffContext diffContext; |
|||
//用噪音路径和自定义路径构造路径模型
|
|||
PathModule pathModule = new PathModule(noisePahList, specialPath); |
|||
//如果有算法模型直接使用算法模型
|
|||
if(algorithmEnum != null){ |
|||
diffContext = algorithmEnum.getAlgorithmModule().diffElement(a, b, pathModule); |
|||
}//如果也没有比较器，直接用默认算法模型
|
|||
else if(objectComparator == null && arrayComparator == null && primitiveComparator == null && nullComparator == null && otherComparator == null){ |
|||
diffContext = AlgorithmEnum.DEFAULT.getAlgorithmModule().diffElement(a, b, pathModule); |
|||
}//如果有比较器，为空的比较器用默认替换，然后构造算法模型，
|
|||
else { |
|||
constrcutDefaultComparator(); |
|||
diffContext = new AlgorithmModule(objectComparator, arrayComparator, primitiveComparator, nullComparator, otherComparator).diffElement(a, b, pathModule); |
|||
} |
|||
return ResultConvertUtil.constructResult(diffContext); |
|||
} |
|||
|
|||
/** |
|||
* @param strA 要比较的第一个字符串 |
|||
* @param strB 要比较的第二个字符串 |
|||
* @return 用来展示的diff结果 |
|||
*/ |
|||
public List<Result> diff(String strA, String strB) { |
|||
return diffElement(new JsonParser().parse(strA), new JsonParser().parse(strB)); |
|||
} |
|||
|
|||
public Diff() { |
|||
} |
|||
|
|||
/** |
|||
* 没有初始的比较器替换成默认的 |
|||
*/ |
|||
private void constrcutDefaultComparator() { |
|||
//如果没有初始化算法，则采用默认的算法。
|
|||
if(objectComparator == null){ |
|||
objectComparator = defaultObjectComparator(); |
|||
} |
|||
if(arrayComparator == null){ |
|||
arrayComparator = defaultArrayComparator(); |
|||
} |
|||
if(primitiveComparator == null){ |
|||
primitiveComparator = defaultPrimitiveComparator(); |
|||
} |
|||
if(nullComparator == null){ |
|||
nullComparator = defaultNullComparator(); |
|||
} |
|||
if(otherComparator == null){ |
|||
otherComparator = defaultOtherComparator(); |
|||
} |
|||
} |
|||
|
|||
private ObjectComparator defaultObjectComparator() { |
|||
return new SimpleObjectComparator(); |
|||
} |
|||
|
|||
private ArrayComparator defaultArrayComparator() { |
|||
return new SimilarArrayComparator(); |
|||
} |
|||
|
|||
private PrimitiveComparator defaultPrimitiveComparator() { |
|||
return new DefaultPrimitiveComparator(); |
|||
} |
|||
|
|||
private NullComparator defaultNullComparator() { |
|||
return new DefaultNullComparator(); |
|||
} |
|||
|
|||
private OtherComparator defaultOtherComparator() { |
|||
return new DefaultOtherComparator(); |
|||
} |
|||
|
|||
/** |
|||
* 选择算法模型 |
|||
* @param algorithmEnum 算法模型枚举类 |
|||
* @return 对象本身 |
|||
*/ |
|||
public Diff withAlgorithmEnum(AlgorithmEnum algorithmEnum){ |
|||
this.algorithmEnum = algorithmEnum; |
|||
return this; |
|||
} |
|||
|
|||
/** |
|||
* 设置自定义路径 |
|||
* @param specialPath 自定义路径列表 |
|||
* @return 对象本身 |
|||
*/ |
|||
public Diff withSpecialPath(List<String> specialPath){ |
|||
this.specialPath = specialPath; |
|||
return this; |
|||
} |
|||
|
|||
/** |
|||
* 设置噪音路径 |
|||
* @param noisePahList 噪音路径列表 |
|||
* @return 对象本身 |
|||
*/ |
|||
public Diff withNoisePahList(List<String> noisePahList){ |
|||
this.noisePahList = noisePahList; |
|||
return this; |
|||
} |
|||
|
|||
/** |
|||
* 自定义对象比较器 |
|||
* @param objectComparator 对象比较器 |
|||
* @return 对象本身 |
|||
*/ |
|||
public Diff withObjectComparator(ObjectComparator objectComparator) { |
|||
this.objectComparator = objectComparator; |
|||
return this; |
|||
} |
|||
|
|||
/** |
|||
* 自定义数组比较器 |
|||
* @param arrayComparator 数组比较器 |
|||
* @return 对象本身 |
|||
*/ |
|||
public Diff withArrayComparator(ArrayComparator arrayComparator) { |
|||
this.arrayComparator = arrayComparator; |
|||
return this; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* 自定义基本类型比较器 |
|||
* @param primitiveComparator 基本类型比较器 |
|||
* @return 对象本身 |
|||
*/ |
|||
public Diff withPrimitiveAlgorithm(PrimitiveComparator primitiveComparator) { |
|||
this.primitiveComparator = primitiveComparator; |
|||
return this; |
|||
} |
|||
|
|||
/** |
|||
* 自定义空类型比较器 |
|||
* @param nullComparator 空类型比较器 |
|||
* @return 对象本身 |
|||
*/ |
|||
public Diff withNullComparator(NullComparator nullComparator) { |
|||
this.nullComparator = nullComparator; |
|||
return this; |
|||
} |
|||
|
|||
/** |
|||
* 自定义其他类型比较器 |
|||
* @param otherComparator 其他类型比较器 |
|||
* @return 对象本身 |
|||
*/ |
|||
public Diff withOtheComparator(OtherComparator otherComparator) { |
|||
this.otherComparator = otherComparator; |
|||
return this; |
|||
} |
|||
} |
|||
@ -0,0 +1,49 @@ |
|||
package com.zc.business.utils.diff.algorithm; |
|||
|
|||
import com.google.gson.JsonElement; |
|||
import com.zc.business.utils.diff.model.Constants; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
import com.zc.business.utils.diff.model.SingleNodeDifference; |
|||
|
|||
/** |
|||
* 数组和对象比较的公有方法抽象类 |
|||
* @Author JingWei |
|||
* @create 2022/3/1 |
|||
*/ |
|||
public abstract class AbstractObjectAndArray { |
|||
protected AlgorithmModule algorithmModule; |
|||
|
|||
/** |
|||
* diff算法比较核心方法，比较2个JsonElement的入口。 |
|||
* @param a 比较的第一个JsonElement |
|||
* @param b 比较的第二个JsonElement |
|||
* @param pathModule 路径模型 |
|||
* @return 不同的比较结果 |
|||
*/ |
|||
public DiffContext diffElement(JsonElement a, JsonElement b, PathModule pathModule) { |
|||
return algorithmModule.diffElement(a, b, pathModule); |
|||
} |
|||
|
|||
/** |
|||
* 构造算法模型,比如使用对象和数组类型算法比较时，内部会用到其他类型的算法。 |
|||
* @param algorithmModule 算法模型 |
|||
*/ |
|||
public void constructAlgorithmModule(AlgorithmModule algorithmModule) { |
|||
this.algorithmModule = algorithmModule; |
|||
} |
|||
|
|||
/** |
|||
* 如果下层diff结果不同，会把下层diff结果加入到上层diff结果中去。 |
|||
* @param parentResult 上层结果 |
|||
* @param childResult 下层结果 |
|||
*/ |
|||
public void parentContextAddChildContext(DiffContext parentResult, DiffContext childResult) { |
|||
if(childResult.isSame() == Constants.DIFFERENT) { |
|||
for (SingleNodeDifference singleNodeDifference : childResult.getDiffResultModels()) { |
|||
parentResult.getDiffResultModels().add(singleNodeDifference); |
|||
} |
|||
parentResult.setSame(false); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,34 @@ |
|||
package com.zc.business.utils.diff.algorithm; |
|||
|
|||
import com.google.gson.JsonElement; |
|||
|
|||
/** |
|||
* 基本类型和其它类型比较的公有方法抽象类 |
|||
* @Author JingWei |
|||
* @create 2022/1/11 |
|||
*/ |
|||
public abstract class AbstractPrimitiveAndOther { |
|||
/** |
|||
* 将比较的元素转换成String类型方便结果展示 |
|||
* @param element 元素 |
|||
* @return 元素转换成的字符串 |
|||
*/ |
|||
protected static String jsonElement2Str(JsonElement element){ |
|||
//该对象不存在的情况
|
|||
if(element == null){ |
|||
return null; |
|||
} else if (element.isJsonObject()) { |
|||
return "{省略内部字段}"; |
|||
} else if (element.isJsonArray()) { |
|||
return "[省略内部元素]"; |
|||
} else if (element.isJsonPrimitive()) { |
|||
return element.getAsJsonPrimitive().getAsString(); |
|||
} else if (element.isJsonNull()) { |
|||
return "null"; |
|||
}else{ |
|||
throw new RuntimeException("异常"); |
|||
} |
|||
} |
|||
|
|||
|
|||
} |
|||
@ -0,0 +1,66 @@ |
|||
package com.zc.business.utils.diff.algorithm; |
|||
|
|||
import com.google.gson.JsonArray; |
|||
import com.google.gson.JsonElement; |
|||
import com.google.gson.JsonNull; |
|||
import com.google.gson.JsonObject; |
|||
import com.google.gson.JsonPrimitive; |
|||
import com.zc.business.utils.diff.algorithm.array.ArrayComparator; |
|||
import com.zc.business.utils.diff.algorithm.nulls.NullComparator; |
|||
import com.zc.business.utils.diff.algorithm.object.ObjectComparator; |
|||
import com.zc.business.utils.diff.algorithm.other.OtherComparator; |
|||
import com.zc.business.utils.diff.algorithm.primitive.PrimitiveComparator; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
|
|||
/** |
|||
* 算法模型 |
|||
* 算法模型包含5种比较器，对象、数组、基本类型、空类型、其他类型比较器。 |
|||
* 当2个JsonElement的子类同时为对象、数组、基本类型、空类型，使用前4种比较器。当2个JsonElement的子类类型不相同时，使用其它类型比较器。 |
|||
* @Author JingWei |
|||
* @create 2022/1/13 |
|||
*/ |
|||
public class AlgorithmModule{ |
|||
protected ObjectComparator objectAlgorithm; |
|||
protected ArrayComparator arrayAlgorithm; |
|||
protected PrimitiveComparator primitiveComparator; |
|||
protected NullComparator nullComparator; |
|||
protected OtherComparator otherComparator; |
|||
|
|||
public AlgorithmModule(ObjectComparator objectAlgorithm, ArrayComparator arrayAlgorithm, |
|||
PrimitiveComparator primitiveComparator, NullComparator nullComparator, OtherComparator otherComparator) { |
|||
this.arrayAlgorithm = arrayAlgorithm; |
|||
this.objectAlgorithm = objectAlgorithm; |
|||
this.primitiveComparator = primitiveComparator; |
|||
this.nullComparator = nullComparator; |
|||
this.otherComparator = otherComparator; |
|||
objectAlgorithm.constructAlgorithmModule(this); |
|||
arrayAlgorithm.constructAlgorithmModule(this); |
|||
} |
|||
|
|||
/** |
|||
* 判断要比较的两个JsonElement的类型，并根据类型调用对应的算法进行比较 |
|||
* @param a 要比较的第一个元素 |
|||
* @param b 要比较的第二个元素 |
|||
* @param pathModule 路径模型 |
|||
* @return 返回比较结果 |
|||
*/ |
|||
public DiffContext diffElement(JsonElement a, JsonElement b, PathModule pathModule) { |
|||
if (a instanceof JsonObject && b instanceof JsonObject) { |
|||
return objectAlgorithm.diff( (JsonObject) a, (JsonObject) b, pathModule); |
|||
} else if (a instanceof JsonArray && b instanceof JsonArray) { |
|||
return arrayAlgorithm.diffArray((JsonArray) a, (JsonArray) b, pathModule); |
|||
} else if (a instanceof JsonPrimitive && b instanceof JsonPrimitive) { |
|||
return primitiveComparator.diff((JsonPrimitive) a, (JsonPrimitive) b, pathModule); |
|||
} else if (a instanceof JsonNull && b instanceof JsonNull) { |
|||
return nullComparator.diff((JsonNull) a, (JsonNull) b, pathModule); |
|||
} else { |
|||
return otherComparator.diff(a, b, pathModule); |
|||
} |
|||
} |
|||
|
|||
public ArrayComparator getArrayAlgorithm() { |
|||
return arrayAlgorithm; |
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,9 @@ |
|||
package com.zc.business.utils.diff.algorithm; |
|||
|
|||
/** |
|||
* 比较器最顶层的接口，逻辑意义 |
|||
* @Author JingWei |
|||
* @create 2022/3/2 |
|||
*/ |
|||
public interface Comparator { |
|||
} |
|||
@ -0,0 +1,22 @@ |
|||
package com.zc.business.utils.diff.algorithm.array; |
|||
|
|||
import com.zc.business.utils.diff.algorithm.AbstractObjectAndArray; |
|||
|
|||
/** |
|||
* 数组比较的公有方法抽象类 |
|||
* @Author JingWei |
|||
* @create 2022/3/1 |
|||
*/ |
|||
public abstract class AbstractArray extends AbstractObjectAndArray implements ArrayComparator { |
|||
/** |
|||
* 数组索引号加一个中括号表示数组路径 |
|||
* @param i 数组元素的索引号 |
|||
* @return 索引号增加中括号 |
|||
*/ |
|||
protected String constructArrayPath(Integer i){ |
|||
if(i == null || i < 0 ){ |
|||
throw new RuntimeException("数组索引号入参为空或者为负。 入参:" + i); |
|||
} |
|||
return "[" + i + "]"; |
|||
} |
|||
} |
|||
@ -0,0 +1,43 @@ |
|||
package com.zc.business.utils.diff.algorithm.array; |
|||
|
|||
import com.google.gson.JsonArray; |
|||
import com.google.gson.JsonElement; |
|||
import com.zc.business.utils.diff.algorithm.AlgorithmModule; |
|||
import com.zc.business.utils.diff.algorithm.Comparator; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
|
|||
|
|||
/** |
|||
* 数组类型比较器接口，用于2个JsonElement均为数组时对2个元素进行比较。 |
|||
* @Author JingWei |
|||
* @create 2022/2/23 |
|||
*/ |
|||
public interface ArrayComparator extends Comparator { |
|||
/** |
|||
* 对两个JsonArray进行比较的方法 |
|||
* @param a 要比较的第一个JsonArray |
|||
* @param b 要比较的第二个JsonArray |
|||
* @param pathModule 路径模型 |
|||
* @return 返回不相等的结果 |
|||
*/ |
|||
DiffContext diffArray(JsonArray a, JsonArray b, PathModule pathModule) ; |
|||
|
|||
/** |
|||
* 对象内部包含其他非数组类型，对这些类型比较需要使用JsonElement比较方法 |
|||
* @param a 要比较的第一个JsonElement |
|||
* @param b 要比较的第一个JsonElement |
|||
* @param pathModule 路径模型 |
|||
* @return 返回不相等的结果 |
|||
*/ |
|||
DiffContext diffElement(JsonElement a, JsonElement b, PathModule pathModule); |
|||
|
|||
/** |
|||
* 构造算法模型，数组中元素比较需要使用到其他非数组算法 |
|||
* @param algorithmModule 算法模型：包含对象、数组、基本类型、空类型、其他类型算法 |
|||
*/ |
|||
void constructAlgorithmModule(AlgorithmModule algorithmModule); |
|||
|
|||
|
|||
|
|||
} |
|||
@ -0,0 +1,252 @@ |
|||
package com.zc.business.utils.diff.algorithm.array; |
|||
|
|||
import com.google.gson.JsonArray; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
import com.zc.business.utils.diff.model.SingleNodeDifference; |
|||
|
|||
import java.util.LinkedList; |
|||
import java.util.List; |
|||
import java.util.Objects; |
|||
|
|||
/** |
|||
* 相似度数组算法比较器:当数组进行比较找不到相等元素时，通过算法优先找最接近的元素进行匹配 |
|||
* |
|||
* 举例： |
|||
*"[{\"a\":7,\"b\":5,\"c\":6},{\"a\":6,\"b\":2,\"c\":3}]"和 |
|||
*"[{\"a\":1,\"b\":2,\"c\":3},{\"a\":4,\"b\":5,\"c\":6},{\"a\":7,\"b\":8,\"c\":9}]"比较 |
|||
* 数组一中第一个元素依次和数组二中元素比较，分别有3组不同，1组不同，2组不同 |
|||
* 数组一中第二个元素依次和数组二中元素比较，分别有1组不同，3组不同，3组不同 |
|||
* 一、得到相似矩阵如下 |
|||
* 3 1 2 |
|||
* 1 3 3 |
|||
* 二、遍历矩阵所有元素，找到值最小的元素，并且行和列的其他元素不能再被使用。行和列即为要比较的2个元素在各自数组中的索引号 |
|||
* 第一次找到1，第二次找到另外一个1. |
|||
* 三、遍历矩阵中未使用所有列，列索引号为多余的元素在数组中的位置。 |
|||
* 只有第三列可以使用 ，第二组中第3个元素为新增元素。 |
|||
* |
|||
* @Author JingWei |
|||
* @create 2022/2/24 |
|||
*/ |
|||
public class SimilarArrayComparator extends AbstractArray { |
|||
/** |
|||
* USEABLE表示当前位置可以使用 |
|||
*/ |
|||
private final boolean USEABLE = false; |
|||
|
|||
/** |
|||
* USED表示当前位置已经被使用过 |
|||
*/ |
|||
private final boolean USED = true; |
|||
|
|||
|
|||
/** |
|||
* @param a 要比较的第一个数组 |
|||
* @param b 要比较的第二个数组 |
|||
* @param pathModule 路径模型 |
|||
* @return 返回不相等的结果 |
|||
*/ |
|||
@Override |
|||
public DiffContext diffArray(JsonArray a, JsonArray b, PathModule pathModule) { |
|||
DiffContext diffContext; |
|||
//a数组长度小于等于b，直接使用diff数组比较算法
|
|||
if(a.size() <= b.size()){ |
|||
diffContext = diff(a, b, pathModule); |
|||
} |
|||
//当a数组长度大于b时，需要交换pathModule中a和b路径, 并交换数组a和b，再使用diff数组比较算法
|
|||
else { |
|||
exchangeLeftAndRightPath(pathModule); |
|||
diffContext = diff(b, a, pathModule); |
|||
exchangeLeftAndRightPath(pathModule); |
|||
exchangeResult(diffContext); |
|||
} |
|||
return diffContext; |
|||
} |
|||
|
|||
/** |
|||
* 交换返回结果中每一个路径和结果 |
|||
* @param diffContext 返回结果 |
|||
*/ |
|||
private void exchangeResult(DiffContext diffContext) { |
|||
List<SingleNodeDifference> singleNodeDifferences = diffContext.getDiffResultModels(); |
|||
for(SingleNodeDifference singleNodeDifference : singleNodeDifferences){ |
|||
exchangePathAndResult(singleNodeDifference); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 交换返回结果中的路径和结果 |
|||
* @param singleNodeDifference 返回结果 |
|||
*/ |
|||
private void exchangePathAndResult(SingleNodeDifference singleNodeDifference) { |
|||
String tempStringA = singleNodeDifference.getLeftPath(); |
|||
Object tempLeft = singleNodeDifference.getLeft(); |
|||
singleNodeDifference.setLeftPath(singleNodeDifference.getRightPath()); |
|||
singleNodeDifference.setRightPath(tempStringA); |
|||
singleNodeDifference.setLeft(singleNodeDifference.getRight()); |
|||
singleNodeDifference.setRight(tempLeft); |
|||
} |
|||
|
|||
|
|||
/** |
|||
* 将路径模型中a和b的路径交换 |
|||
* @param pathModule 路径模型 |
|||
*/ |
|||
private void exchangeLeftAndRightPath(PathModule pathModule) { |
|||
LinkedList<String> tempA = pathModule.getLeftPath(); |
|||
pathModule.setLeftPath(pathModule.getRightPath()); |
|||
pathModule.setRightPath(tempA); |
|||
} |
|||
|
|||
|
|||
/** |
|||
* 数组比较核心算法，支持数组a长度小于b长度时使用 |
|||
*/ |
|||
DiffContext diff(JsonArray a, JsonArray b, PathModule pathModule ) { |
|||
int rowlength = a.size(); |
|||
int linelength = b.size(); |
|||
//a数组中m个元素，与b数组中n个元素比较，共比较m*n次，所有比较结果会得组成一个矩阵，矩阵中的数字用来存储比较结果。
|
|||
int [][] similarMatrix = new int[rowlength][linelength]; |
|||
//创建一个行和列数组 用来判断当前行和列是否被使用过
|
|||
boolean []row = new boolean[rowlength]; |
|||
boolean []line = new boolean[linelength]; |
|||
for (int i = 0; i < rowlength; i++) { |
|||
pathModule.addLeftPath(constructArrayPath(i)); |
|||
//a数组中m个元素，与b数组中n个元素比较，比较结果生成一个m*n的矩阵
|
|||
constructSimilarMatrix(a, b, i, pathModule, similarMatrix, row, line); |
|||
pathModule.removeLastLeftPath(); |
|||
} |
|||
return obtainDiffResult(a, b, pathModule, row, line, similarMatrix); |
|||
} |
|||
|
|||
|
|||
/** |
|||
* 通过相似度矩阵，获取比较结果。 第一步在矩阵找到最小的数字，即找到最接近的几对结果。 第二步找剩余未使用的列数，即多余的元素 |
|||
*/ |
|||
private DiffContext obtainDiffResult(JsonArray a, JsonArray b, PathModule pathModule, boolean[] row, boolean[] line, int[][] similarMatrix) { |
|||
DiffContext arrayDiffContext = new DiffContext(); |
|||
//找到a和b都有的结果，并且是最接近的几对结果
|
|||
obtainModifyDiffResult(a,b,pathModule,row,line,similarMatrix, arrayDiffContext); |
|||
//a没有b有的结果，即新增的结果
|
|||
obtainAddDiffResult(b,pathModule,line, arrayDiffContext); |
|||
|
|||
return arrayDiffContext; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* 得到新增的结果。由于b数组长度大于a，会有几个元素多余。在选出a和b最接近的几对元素后，剩下的几个元素被认为是新增的。 |
|||
*/ |
|||
private void obtainAddDiffResult(JsonArray b, PathModule pathModule, boolean[] line, DiffContext arrayDiffContext) { |
|||
for (int j = 0; j < line.length; j++) { |
|||
if (line[j] == USED) { |
|||
continue; |
|||
} |
|||
DiffContext addOrDeleteDiffContext = constructAddContext(b, j, pathModule); |
|||
parentContextAddChildContext(arrayDiffContext, addOrDeleteDiffContext); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 从m*n的矩阵中选出最接近的几组结果，矩阵中的数字越小，说明2个元素比较时结果相差越少 |
|||
*/ |
|||
private void obtainModifyDiffResult(JsonArray a, JsonArray b, PathModule pathModule, boolean[] row, boolean[] line, int[][] similarMatrix, DiffContext arrayDiffContext) { |
|||
int counts = 0; |
|||
//找到还未使用行的数量(行数小于列数)
|
|||
for (boolean value : row) { |
|||
if (Objects.equals(USEABLE, value)) { |
|||
counts++; |
|||
} |
|||
} |
|||
//不同结果对数等于未使用的行数
|
|||
for (int n = 0; n < counts; n++) { |
|||
int bestLineIndex = 0; |
|||
int bestRowIndex = 0; |
|||
int minDiffPair = Integer.MAX_VALUE; |
|||
//遍历矩阵中所有元素，找最小的数字，矩阵中的数字越小，说明2个元素比较时结果相差越少
|
|||
for (int i = 0; i < row.length; i++) { |
|||
for (int j = 0; j < line.length; j++) { |
|||
//如果行或列被使用，跳过该行
|
|||
if (row[i] == USED || line[j] == USED) { |
|||
continue; |
|||
} |
|||
//如果当前元素数字更小，那么把当前行和列保存下来，数字更新为当前最优结果
|
|||
if (similarMatrix[i][j] < minDiffPair) { |
|||
bestRowIndex = i; |
|||
bestLineIndex = j; |
|||
minDiffPair = similarMatrix[i][j]; |
|||
} |
|||
} |
|||
} |
|||
//将找到的最优结果添加到返回结果中
|
|||
DiffContext modifyDiffContext = constructModifyContext(a, b, bestRowIndex, bestLineIndex, pathModule); |
|||
row[bestRowIndex] = USED; |
|||
line[bestLineIndex] = USED; |
|||
parentContextAddChildContext(arrayDiffContext, modifyDiffContext); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 此时a数组没有该元素，b数组有元素，结果为新增 |
|||
* @param b 数组 |
|||
* @param index 索引号 |
|||
* @param pathModule 路径模型 |
|||
* @return 生成的不同结果 |
|||
*/ |
|||
private DiffContext constructAddContext(JsonArray b, int index, PathModule pathModule) { |
|||
pathModule.addAllpath(constructArrayPath(index)); |
|||
DiffContext diffContext = diffElement(null, b.get(index), pathModule); |
|||
pathModule.removeAllLastPath(); |
|||
return diffContext; |
|||
} |
|||
|
|||
/** |
|||
* 返回两个数组对应索引号元素比较结果 |
|||
* @param a 数组a |
|||
* @param b 数组b |
|||
* @param i 数组a中元素的索引号 |
|||
* @param bestLineIndex 数组b中元素的索引号，即找到的和a中元素接接近的元素索引号。 |
|||
* @param pathModule 路径模型 |
|||
* @return 返回不同的结果 |
|||
*/ |
|||
private DiffContext constructModifyContext(JsonArray a, JsonArray b, int i, int bestLineIndex, PathModule pathModule) { |
|||
pathModule.addLeftPath(constructArrayPath(i)); |
|||
pathModule.addRightPath(constructArrayPath(bestLineIndex)); |
|||
DiffContext diffContext = diffElement(a.get(i), b.get(bestLineIndex), pathModule); |
|||
pathModule.removeAllLastPath(); |
|||
return diffContext; |
|||
} |
|||
|
|||
/** |
|||
* 用数组a的一个元素与数组b中所有元素分别比较，会得到n次比较结果，结果为不相等的结果对数，在矩阵中更新n次结果。 |
|||
*/ |
|||
private void constructSimilarMatrix(JsonArray arrayA, JsonArray arrayB, int rowIndex, PathModule pathModule, int [][]similarArray, boolean[] row, boolean[] line) { |
|||
if(rowIndex < 0 || rowIndex >= arrayB.size()){ |
|||
throw new RuntimeException("索引号入参超出数组长度。 索引号：" + rowIndex +" 数组B:" + arrayB); |
|||
} |
|||
|
|||
for (int j = 0; j < arrayB.size(); j++) { |
|||
if (line[j] == USEABLE) { |
|||
pathModule.addRightPath(constructArrayPath(j)); |
|||
DiffContext diffContext = diffElement(arrayA.get(rowIndex), arrayB.get(j), pathModule); |
|||
pathModule.removeLastRightPath(); |
|||
if (diffContext.isSame()) { |
|||
row[rowIndex] = USED; |
|||
line[j] = USED; |
|||
return; |
|||
} else if(existSpecialPath(diffContext.getSpecialPathResult())){ |
|||
similarArray[rowIndex][j] = 0 ; |
|||
} else { |
|||
similarArray[rowIndex][j] = diffContext.getDiffResultModels().size(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 判断比较结果是否有特殊路径 |
|||
*/ |
|||
private boolean existSpecialPath(LinkedList<String> specialPathResult) { |
|||
return specialPathResult != null && !specialPathResult.isEmpty(); |
|||
} |
|||
} |
|||
@ -0,0 +1,62 @@ |
|||
package com.zc.business.utils.diff.algorithm.array; |
|||
|
|||
import com.google.gson.JsonArray; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
|
|||
/** |
|||
* 简单数组比较器：数组对比时按照索引号顺序依次进行比较 |
|||
* 例：[A,B,C] 与 [C,B,A]比较时，依次找索引号为0、为1、为2进行比较，相同结果对为<A,C> <B,B> <C,A>，不同结果<A,C> <C,A>会加入到返回结果中。 |
|||
* @Author JingWei |
|||
* @create 2022/1/14 |
|||
*/ |
|||
public class SimpleArrayComparator extends AbstractArray { |
|||
/** |
|||
* 对两个JsonArray进行比较的方法。 |
|||
* @param a 要比较的第一个数组 |
|||
* @param b 要比较的第二个数组 |
|||
* @param pathModule 路径模型 |
|||
* @return 返回不相等的比较结果 |
|||
*/ |
|||
@Override |
|||
public DiffContext diffArray(JsonArray a, JsonArray b, PathModule pathModule) { |
|||
DiffContext arrayDiffContext = new DiffContext(); |
|||
int maxLength = Math.max(a.size(), b.size()); |
|||
//根据数组a和b长度的大的值进行遍历
|
|||
for (int i = 0; i < maxLength; i++) { |
|||
pathModule.addAllpath(constructArrayPath(i)); |
|||
DiffContext diffContext = generateDiffResult(a,b,i,pathModule); |
|||
parentContextAddChildContext(arrayDiffContext, diffContext); |
|||
} |
|||
return arrayDiffContext; |
|||
} |
|||
|
|||
/** |
|||
* 生成比较结果,分以下3种情况考虑 |
|||
* i < a.size() && i < b.size() |
|||
* a.size() <= i |
|||
* b.size() <= i |
|||
* @param a 数组a |
|||
* @param b 数组b |
|||
* @param i 数组a和b中正在比较的元素索引号 |
|||
* @param pathModule 路径模型 |
|||
* @return 返回不相等的比较结果 |
|||
*/ |
|||
private DiffContext generateDiffResult(JsonArray a, JsonArray b, int i, PathModule pathModule) { |
|||
if(i >= a.size() && i >= b.size()){ |
|||
throw new RuntimeException("数组索引号入参超过数组长度。 索引号:" + i + " 数组a:" + a + "数组b：" + b); |
|||
} |
|||
DiffContext diffContext; |
|||
if(i < a.size() && i < b.size()){ |
|||
diffContext = diffElement(a.get(i), b.get(i), pathModule); |
|||
}else if (i >= a.size()){ |
|||
diffContext = diffElement(null, b.get(i), pathModule); |
|||
}else{ |
|||
diffContext = diffElement(a.get(i), null, pathModule); |
|||
} |
|||
return diffContext; |
|||
} |
|||
|
|||
|
|||
} |
|||
|
|||
@ -0,0 +1,27 @@ |
|||
package com.zc.business.utils.diff.algorithm.nulls; |
|||
|
|||
import com.google.gson.JsonNull; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
|
|||
/** |
|||
* 当要比较的两个JsonElement都为空类型时，默认实现的算法比较器 |
|||
* @Author JingWei |
|||
* @create 2022/1/10 |
|||
*/ |
|||
public class DefaultNullComparator implements NullComparator { |
|||
|
|||
/** |
|||
* 当要比较的两个JsonElement是空类型时，默认比较方法 |
|||
* @param a 第一个空类型 |
|||
* @param b 第二个空类型 |
|||
* @param pathModule 路径模型 |
|||
* @return 返回结果 |
|||
*/ |
|||
@Override |
|||
public DiffContext diff(JsonNull a, JsonNull b, PathModule pathModule){ |
|||
return new DiffContext(); |
|||
} |
|||
|
|||
|
|||
} |
|||
@ -0,0 +1,25 @@ |
|||
package com.zc.business.utils.diff.algorithm.nulls; |
|||
|
|||
import com.google.gson.JsonNull; |
|||
import com.zc.business.utils.diff.algorithm.Comparator; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
|
|||
/** |
|||
* 空类型比较器接口，用于2个JsonElement均为JsonNull时对2个元素进行比较。 |
|||
* @Author JingWei |
|||
* @create 2022/2/23 |
|||
*/ |
|||
public interface NullComparator extends Comparator { |
|||
|
|||
/** |
|||
* 对两个JsonNull进行比较时，需要实现此方法。 |
|||
* @param a 要比较的第一个JsonNull |
|||
* @param b 要比较的第二个JsonNull |
|||
* @param pathModule 路径模型 |
|||
* @return 返回不同的比较结果 |
|||
*/ |
|||
DiffContext diff(JsonNull a, JsonNull b, PathModule pathModule); |
|||
|
|||
|
|||
} |
|||
@ -0,0 +1,128 @@ |
|||
package com.zc.business.utils.diff.algorithm.object; |
|||
|
|||
import com.google.common.base.Joiner; |
|||
import com.google.gson.JsonObject; |
|||
import com.zc.business.utils.diff.algorithm.AbstractObjectAndArray; |
|||
import com.zc.business.utils.diff.model.Constants; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
|
|||
import java.util.LinkedList; |
|||
import java.util.List; |
|||
import java.util.Set; |
|||
import java.util.stream.Collectors; |
|||
|
|||
/** |
|||
* 对象比较的一些公有方法抽象类 |
|||
* @Author JingWei |
|||
* @create 2022/2/24 |
|||
*/ |
|||
public abstract class AbstractObject extends AbstractObjectAndArray implements ObjectComparator { |
|||
|
|||
/** |
|||
* 对两个对象进行比较：遍历keySet中的所有key， 在a和b对象中找对应的value值进行比较 |
|||
* @param a 要比较的第一个对象 |
|||
* @param b 要比较的第二个对象 |
|||
* @param keySet key的集合 |
|||
* @param pathModule 路径模型 |
|||
* @return 不同的比较结果 |
|||
*/ |
|||
protected DiffContext diffValueByKey(JsonObject a, JsonObject b, Set<String> keySet, PathModule pathModule) { |
|||
DiffContext objectDiffContext = new DiffContext(); |
|||
LinkedList<String> specialPathResult = new LinkedList<>(); |
|||
for (String key : keySet) { |
|||
//更新a和b当前路径
|
|||
pathModule.addAllpath(key); |
|||
//如果对象当前路径在噪音路径集合中，直接跳过比较
|
|||
if (!needDiff(pathModule.getNoisePahList(), pathModule.getLeftPath())) { |
|||
pathModule.removeAllLastPath(); |
|||
continue; |
|||
} |
|||
//生成比较结果
|
|||
DiffContext diffContext = diffElement(a.get(key), b.get(key), pathModule); |
|||
parentContextAddChildContext(objectDiffContext, diffContext); |
|||
//特殊路径处理
|
|||
specialPathHandle(diffContext.isSame(), specialPathResult, pathModule); |
|||
pathModule.removeAllLastPath(); |
|||
|
|||
} |
|||
objectDiffContext.setSpecialPathResult(specialPathResult); |
|||
return objectDiffContext; |
|||
} |
|||
|
|||
/** |
|||
* 如果比较的路径为特殊路径并且比较相等，特殊路径会被标识，添加到返回结果中。 |
|||
* @param isSame 比较结果是否相等 |
|||
* @param specialPathResult 返回的特殊路径结果 |
|||
* @param pathModule 路径模型 |
|||
*/ |
|||
private void specialPathHandle(boolean isSame,LinkedList<String> specialPathResult, PathModule pathModule) { |
|||
//如果比较结果不等，直接返回。
|
|||
if (!isSame){ |
|||
return; |
|||
} |
|||
//如果存在特殊路径，将特殊路径加入到集合中
|
|||
String specialPath = getSpecialPath(pathModule); |
|||
if( existPath(specialPath)){ |
|||
specialPathResult.add(specialPath); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 校验路径是否存在，即路径是否为空 |
|||
* @param specialPath 特殊路径 |
|||
* @return 特殊路径是否为空 |
|||
*/ |
|||
private boolean existPath(String specialPath) { |
|||
return specialPath != null; |
|||
} |
|||
|
|||
/** |
|||
* 判断当前路径是否在特殊路径集合中，如果在，则返回特殊路径。 |
|||
* @param pathModule 路径模型 |
|||
* @return 返回的特殊路径字符串 |
|||
*/ |
|||
protected String getSpecialPath(PathModule pathModule) { |
|||
if(pathModule == null || pathModule.getSpecialPath() == null || pathModule.getSpecialPath().isEmpty()){ |
|||
return null; |
|||
} |
|||
String currentPath = listJoin(pathModule.getLeftPath()); |
|||
if(pathModule.getSpecialPath().contains(currentPath)){ |
|||
return currentPath; |
|||
} |
|||
return null; |
|||
} |
|||
|
|||
/** |
|||
* 判断当前字段是否需要diff，如果在噪音字段集合中，则不需要diff，返回false。 |
|||
* @param noisePahList 噪音路径列表 |
|||
* @param pathList 当前路径 |
|||
* @return 当前路径是否在噪音路径中 |
|||
*/ |
|||
protected boolean needDiff(List<String> noisePahList, LinkedList<String> pathList) { |
|||
if(noisePahList == null || pathList == null || noisePahList.isEmpty() || pathList.isEmpty()){ |
|||
return true; |
|||
} |
|||
String path = listJoin(pathList); |
|||
if(noisePahList.contains(path)){ |
|||
return false; |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
/** |
|||
* 将path路径列表改为字符串 |
|||
* @param path 当前路径 |
|||
* @return 当前路径字符串 |
|||
*/ |
|||
protected String listJoin(LinkedList<String> path) { |
|||
if(path == null){ |
|||
throw new RuntimeException("当前路径不能为空"); |
|||
} |
|||
List<String> collect = path.stream().filter(e -> e.charAt(0) != '[').collect(Collectors.toList()); |
|||
return Joiner.on(Constants.MERGE_PATH).join(collect); |
|||
} |
|||
|
|||
|
|||
|
|||
} |
|||
@ -0,0 +1,30 @@ |
|||
package com.zc.business.utils.diff.algorithm.object; |
|||
|
|||
import com.google.gson.JsonObject; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
|
|||
/** |
|||
* 左匹配对象比较器：当对两个JsonObject进行比较时，只对第一个对象中keySet中存在keyValue值进行比较。 |
|||
* |
|||
* 举例： |
|||
* {"a":1,"b":2,"c":3}和{"a":1,"b":4,"c":3,"d":4}进行比较 |
|||
* 只会比较第一个对象中有的字段，即比较第一个对象中有的"a","b","c"3个字段，第二个对象中的"d"字段没有被比较 |
|||
* |
|||
* @Author JingWei |
|||
* @create 2022/2/18 |
|||
*/ |
|||
public class LeftJoinObjectComparator extends AbstractObject { |
|||
/** |
|||
* @param a 要比较的第一个JsonObject |
|||
* @param b 要比较的第二个JsonObject |
|||
* @param pathModule 路径模型 |
|||
* @return 不同的比较结果 |
|||
*/ |
|||
@Override |
|||
public DiffContext diff(JsonObject a, JsonObject b, PathModule pathModule){ |
|||
//用a的keySet作为遍历集合。
|
|||
return diffValueByKey(a, b, a.keySet(), pathModule); |
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,40 @@ |
|||
package com.zc.business.utils.diff.algorithm.object; |
|||
|
|||
import com.google.gson.JsonElement; |
|||
import com.google.gson.JsonObject; |
|||
import com.zc.business.utils.diff.algorithm.AlgorithmModule; |
|||
import com.zc.business.utils.diff.algorithm.Comparator; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
|
|||
/** |
|||
* 对象类型比较器接口，用于2个JsonElement均为JsonObject时对2个元素进行比较。 |
|||
* @Author JingWei |
|||
* @create 2022/2/23 |
|||
*/ |
|||
public interface ObjectComparator extends Comparator { |
|||
|
|||
/** |
|||
* 对两个JsonObject进行比较时，需要实现此方法。 |
|||
* @param a 要比较的第一个JsonObject |
|||
* @param b 要比较的第二个JsonObject |
|||
* @param pathModule 路径模型 |
|||
* @return 返回不同的比较结果 |
|||
*/ |
|||
DiffContext diff(JsonObject a, JsonObject b, PathModule pathModule); |
|||
|
|||
/** |
|||
* 对象内部包含其他非JsonObject类型，对这些类型比较需要使用JsonElement比较方法 |
|||
* @param a 元素a |
|||
* @param b 元素b |
|||
* @param pathModule 路径模型 |
|||
* @return 返回不同的比较结果 |
|||
*/ |
|||
DiffContext diffElement(JsonElement a, JsonElement b, PathModule pathModule); |
|||
|
|||
/** |
|||
* 构造算法模型，对象比较时，内部元素比较需要使用到其他非数组算法 |
|||
* @param algorithmModule 算法模型：包含对象、数组、基本类型、空类型、其他类型算法 |
|||
*/ |
|||
void constructAlgorithmModule(AlgorithmModule algorithmModule); |
|||
} |
|||
@ -0,0 +1,33 @@ |
|||
package com.zc.business.utils.diff.algorithm.object; |
|||
|
|||
import com.google.common.collect.Sets; |
|||
import com.google.gson.JsonObject; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
|
|||
import java.util.Set; |
|||
|
|||
/** |
|||
* 简单对象比较器：当对两个JsonObject进行比较时，两个对象所有keySet中key对应的Value都会被比较。 |
|||
* 举例： |
|||
* {"b":2,"c":3}和{"a":1,"d":4}进行比较 |
|||
* 会比较两个对象中所有的字段，即比较两个对象中并集"a","b","c","d"4个字段 |
|||
* @Author JingWei |
|||
* @create 2022/2/16 |
|||
*/ |
|||
public class SimpleObjectComparator extends AbstractObject { |
|||
/** |
|||
* @param a 要比较的第一个JsonObject |
|||
* @param b 要比较的第二个JsonObject |
|||
* @param pathModule 路径模型 |
|||
* @return 不同的比较结果 |
|||
*/ |
|||
@Override |
|||
public DiffContext diff(JsonObject a, JsonObject b, PathModule pathModule) { |
|||
Set<String> unionSet = Sets.union(a.keySet(), b.keySet()); |
|||
//用a和b的keySet的并集作为遍历集合。
|
|||
return diffValueByKey(a, b, unionSet, pathModule); |
|||
} |
|||
|
|||
|
|||
} |
|||
@ -0,0 +1,38 @@ |
|||
package com.zc.business.utils.diff.algorithm.other; |
|||
|
|||
import com.google.common.base.Joiner; |
|||
import com.google.gson.JsonElement; |
|||
import com.zc.business.utils.diff.algorithm.AbstractPrimitiveAndOther; |
|||
import com.zc.business.utils.diff.model.Constants; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
import com.zc.business.utils.diff.model.SingleNodeDifference; |
|||
|
|||
import java.util.ArrayList; |
|||
import java.util.List; |
|||
|
|||
/** |
|||
* 当要比较的两个JsonElement的不同时为对象、组数、空、基本类型时，默认实现的比较器。 |
|||
* @Author JingWei |
|||
* @create 2022/1/10 |
|||
*/ |
|||
public class DefaultOtherComparator extends AbstractPrimitiveAndOther implements OtherComparator { |
|||
|
|||
/** |
|||
* @param a 要比较的第一个JsonElement |
|||
* @param b 要比较的第二个JsonElement |
|||
* @param pathModule 路径模型 |
|||
* @return 不同的比较结果 |
|||
*/ |
|||
@Override |
|||
public DiffContext diff(JsonElement a, JsonElement b, PathModule pathModule){ |
|||
//比较结果一定会不同，因为要比较的a和b类型不同才会调用该方法。
|
|||
DiffContext otherDiffContext = new DiffContext(Constants.DIFFERENT); |
|||
List<SingleNodeDifference> singleNodeDifferences = new ArrayList<>(); |
|||
singleNodeDifferences.add(new SingleNodeDifference(Joiner.on(Constants.MERGE_PATH).join(pathModule.getLeftPath()), Joiner.on(Constants.MERGE_PATH).join(pathModule.getRightPath()), jsonElement2Str(a), jsonElement2Str(b))); |
|||
otherDiffContext.setDiffResultModels(singleNodeDifferences); |
|||
return otherDiffContext; |
|||
} |
|||
|
|||
|
|||
} |
|||
@ -0,0 +1,24 @@ |
|||
package com.zc.business.utils.diff.algorithm.other; |
|||
|
|||
import com.google.gson.JsonElement; |
|||
import com.zc.business.utils.diff.algorithm.Comparator; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
|
|||
/** |
|||
* 其他类型比较器接口，用于2个JsonElement不同时为对象、数组、空、基本类型时对2个元素进行比较。 |
|||
* |
|||
* 举例：第一个要比较类型为对象类型，第二个要比较类型为数组类型。 |
|||
* @Author JingWei |
|||
* @create 2022/2/23 |
|||
*/ |
|||
public interface OtherComparator extends Comparator { |
|||
/** |
|||
* 对两个JsonElement进行比较并且两个JsonElement的类型不相等时，需要实现此方法。 |
|||
* @param a 要比较的第一个JsonElement |
|||
* @param b 要比较的第二个JsonElement |
|||
* @return 不同的比较结果 |
|||
*/ |
|||
DiffContext diff(JsonElement a, JsonElement b, PathModule pathModule); |
|||
|
|||
} |
|||
@ -0,0 +1,39 @@ |
|||
package com.zc.business.utils.diff.algorithm.primitive; |
|||
|
|||
import com.google.common.base.Joiner; |
|||
import com.google.gson.JsonPrimitive; |
|||
import com.zc.business.utils.diff.algorithm.AbstractPrimitiveAndOther; |
|||
import com.zc.business.utils.diff.model.Constants; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
import com.zc.business.utils.diff.model.SingleNodeDifference; |
|||
|
|||
import java.util.ArrayList; |
|||
import java.util.List; |
|||
|
|||
/** |
|||
* 当要比较的两个JsonElement是基本类型时，默认实现的比较器。 |
|||
* @Author JingWei |
|||
* @create 2022/1/10 |
|||
*/ |
|||
public class DefaultPrimitiveComparator extends AbstractPrimitiveAndOther implements PrimitiveComparator { |
|||
/** |
|||
* @param a 要比较的第一个JsonPrimitive |
|||
* @param b 要比较的第二个JsonPrimitive |
|||
* @param pathModule 路径模型 |
|||
* @return 不同的比较结果 |
|||
*/ |
|||
@Override |
|||
public DiffContext diff(JsonPrimitive a, JsonPrimitive b, PathModule pathModule){ |
|||
DiffContext primitiveDiffContext = new DiffContext(); |
|||
//如果a和b不相等，返回a和b的比较结果。
|
|||
if(Constants.DIFFERENT == a.equals(b)) { |
|||
List<SingleNodeDifference> singleNodeDifferences = new ArrayList<>(); |
|||
singleNodeDifferences.add(new SingleNodeDifference(Joiner.on(Constants.MERGE_PATH).join(pathModule.getLeftPath()), Joiner.on(Constants.MERGE_PATH).join(pathModule.getRightPath()), jsonElement2Str(a), jsonElement2Str(b))); |
|||
primitiveDiffContext.setDiffResultModels(singleNodeDifferences); |
|||
primitiveDiffContext.setSame(Constants.DIFFERENT); |
|||
} |
|||
return primitiveDiffContext; |
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,23 @@ |
|||
package com.zc.business.utils.diff.algorithm.primitive; |
|||
|
|||
import com.google.gson.JsonPrimitive; |
|||
import com.zc.business.utils.diff.algorithm.Comparator; |
|||
import com.zc.business.utils.diff.model.DiffContext; |
|||
import com.zc.business.utils.diff.model.PathModule; |
|||
|
|||
/** |
|||
* 基本类型比较器接口，用于2个JsonElement均为基本类型的时对2个元素进行比较。 |
|||
* @Author JingWei |
|||
* @create 2022/2/23 |
|||
*/ |
|||
public interface PrimitiveComparator extends Comparator { |
|||
/** |
|||
* 对两个基本类型进行比较时，需要实现此方法。 |
|||
* @param a 要比较的第一个JsonPrimitive |
|||
* @param b 要比较的第二个JsonPrimitive |
|||
* @param pathModule 路径模型 |
|||
* @return 不同的比较结果 |
|||
*/ |
|||
DiffContext diff(JsonPrimitive a, JsonPrimitive b, PathModule pathModule); |
|||
|
|||
} |
|||
@ -0,0 +1,20 @@ |
|||
package com.zc.business.utils.diff.model; |
|||
|
|||
|
|||
/** |
|||
* 常量 |
|||
* @Author JingWei |
|||
* @create 2022/3/2 |
|||
*/ |
|||
public class Constants { |
|||
/** |
|||
* 描述比较结果不同 |
|||
*/ |
|||
public static final boolean DIFFERENT = false; |
|||
/** |
|||
* 描述比较结果相同 |
|||
*/ |
|||
public static final boolean SAME = true; |
|||
public static final String SPLIT_PATH = "\\."; |
|||
public static final String MERGE_PATH = "."; |
|||
} |
|||
@ -0,0 +1,61 @@ |
|||
package com.zc.business.utils.diff.model; |
|||
|
|||
import java.util.ArrayList; |
|||
import java.util.LinkedList; |
|||
import java.util.List; |
|||
|
|||
/** |
|||
* diff比较上下文 |
|||
* @Author JingWei |
|||
* @create 2022/3/2 |
|||
*/ |
|||
public class DiffContext { |
|||
/** |
|||
* 比较结果是否相同 |
|||
*/ |
|||
private boolean isSame; |
|||
|
|||
/** |
|||
* 比较结果不同时，存储所有不同的结果对 |
|||
*/ |
|||
private List<SingleNodeDifference> singleNodeDifferences; |
|||
|
|||
/** |
|||
* 比较结果中，出现了特殊路径下值相等的情况，会存储该特殊路径。 |
|||
*/ |
|||
private LinkedList<String> specialPathResult; |
|||
|
|||
public DiffContext(boolean isSame) { |
|||
this.isSame = isSame; |
|||
this.singleNodeDifferences = new ArrayList<>(); |
|||
} |
|||
|
|||
public boolean isSame() { |
|||
return isSame; |
|||
} |
|||
|
|||
public void setSame(boolean same) { |
|||
isSame = same; |
|||
} |
|||
|
|||
public List<SingleNodeDifference> getDiffResultModels() { |
|||
return singleNodeDifferences; |
|||
} |
|||
|
|||
public void setDiffResultModels(List<SingleNodeDifference> singleNodeDifferences) { |
|||
this.singleNodeDifferences = singleNodeDifferences; |
|||
} |
|||
|
|||
public DiffContext() { |
|||
this.isSame = true; |
|||
this.singleNodeDifferences = new ArrayList<>(); |
|||
} |
|||
|
|||
public LinkedList<String> getSpecialPathResult() { |
|||
return specialPathResult; |
|||
} |
|||
|
|||
public void setSpecialPathResult(LinkedList<String> specialPathResult) { |
|||
this.specialPathResult = specialPathResult; |
|||
} |
|||
} |
|||
@ -0,0 +1,122 @@ |
|||
package com.zc.business.utils.diff.model; |
|||
|
|||
import java.util.LinkedList; |
|||
import java.util.List; |
|||
|
|||
/** |
|||
* 路径模型 |
|||
* A和B比较时，实时更新当前正在进行比较的元素路径。 |
|||
* |
|||
* @Author JingWei |
|||
* @create 2022/2/15 |
|||
*/ |
|||
public class PathModule { |
|||
/** |
|||
* 对象A当前遍历到的路径 |
|||
*/ |
|||
private LinkedList<String> leftPath; |
|||
/** |
|||
* 对象B当前遍历到的路径 |
|||
*/ |
|||
private LinkedList<String> rightPath; |
|||
/** |
|||
* 特殊路径集合。当前路径符合特殊路径且特殊路径下比较结果相同，会在返回结果中做额外标识标识。 |
|||
*/ |
|||
private List<String> specialPath; |
|||
/** |
|||
* 噪音字段集合。如果当前路径符合噪音字段路径，则不会比较。 |
|||
*/ |
|||
private List<String> noisePahList; |
|||
|
|||
public PathModule() { |
|||
this.leftPath = new LinkedList<>(); |
|||
this.rightPath = new LinkedList<>(); |
|||
} |
|||
|
|||
public PathModule(List<String> noisePahList) { |
|||
this.leftPath = new LinkedList<>(); |
|||
this.rightPath = new LinkedList<>(); |
|||
this.noisePahList = noisePahList; |
|||
} |
|||
|
|||
public PathModule(List<String> noisePahList, List<String> specialPath) { |
|||
this.leftPath = new LinkedList<>(); |
|||
this.rightPath = new LinkedList<>(); |
|||
this.noisePahList = noisePahList; |
|||
this.specialPath = specialPath; |
|||
} |
|||
|
|||
public List<String> getNoisePahList() { |
|||
return noisePahList; |
|||
} |
|||
|
|||
public void setNoisePahList(List<String> noisePahList) { |
|||
this.noisePahList = noisePahList; |
|||
} |
|||
|
|||
public List<String> getSpecialPath() { |
|||
return specialPath; |
|||
} |
|||
|
|||
public void setSpecialPath(LinkedList<String> specialPath) { |
|||
this.specialPath = specialPath; |
|||
} |
|||
|
|||
public LinkedList<String> getLeftPath() { |
|||
return leftPath; |
|||
} |
|||
|
|||
public void setLeftPath(LinkedList<String> leftPath) { |
|||
this.leftPath = leftPath; |
|||
} |
|||
|
|||
public LinkedList<String> getRightPath() { |
|||
return rightPath; |
|||
} |
|||
|
|||
public void setRightPath(LinkedList<String> rightPath) { |
|||
this.rightPath = rightPath; |
|||
} |
|||
|
|||
/** |
|||
* 同时在A和B路径列表最后加上一个Path路径 |
|||
*/ |
|||
public void addAllpath(String lastPath) { |
|||
leftPath.add(lastPath); |
|||
rightPath.add(lastPath); |
|||
} |
|||
|
|||
public void addLeftPath(String lastPath) { |
|||
leftPath.add(lastPath); |
|||
} |
|||
|
|||
public void addRightPath(String lastPath) { |
|||
rightPath.add(lastPath); |
|||
} |
|||
|
|||
|
|||
/** |
|||
* 同时移除A和B路径列表中最后的一个路径 |
|||
*/ |
|||
public void removeAllLastPath() { |
|||
leftPath.removeLast(); |
|||
rightPath.removeLast(); |
|||
} |
|||
|
|||
/** |
|||
* 移除A路径列表中最后的一个路径 |
|||
*/ |
|||
public void removeLastLeftPath() { |
|||
leftPath.removeLast(); |
|||
} |
|||
|
|||
/** |
|||
* 移除B路径列表中最后的一个路径 |
|||
*/ |
|||
public void removeLastRightPath() { |
|||
rightPath.removeLast(); |
|||
} |
|||
|
|||
|
|||
} |
|||
|
|||
@ -0,0 +1,71 @@ |
|||
package com.zc.business.utils.diff.model; |
|||
|
|||
import java.io.Serializable; |
|||
|
|||
/** |
|||
* diff比较最终结果 |
|||
* @Author JingWei |
|||
* @create 2022/3/2 |
|||
*/ |
|||
public class Result implements Serializable { |
|||
/** |
|||
* 第一个对象路径 |
|||
*/ |
|||
private String leftPath; |
|||
/** |
|||
* 第二个对象路径 |
|||
*/ |
|||
private String rightPath; |
|||
/** |
|||
* 第一个对象值 |
|||
*/ |
|||
private Object left; |
|||
/** |
|||
* 第二个对象值 |
|||
*/ |
|||
private Object right; |
|||
/** |
|||
* 比较结果 |
|||
*/ |
|||
private String diffType; |
|||
|
|||
public String getLeftPath() { |
|||
return leftPath; |
|||
} |
|||
|
|||
public String getRightPath() { |
|||
return rightPath; |
|||
} |
|||
|
|||
public void setLeftPath(String leftPath) { |
|||
this.leftPath = leftPath; |
|||
} |
|||
|
|||
public void setRightPath(String rightPath) { |
|||
this.rightPath = rightPath; |
|||
} |
|||
|
|||
public Object getLeft() { |
|||
return left; |
|||
} |
|||
|
|||
public void setLeft(Object left) { |
|||
this.left = left; |
|||
} |
|||
|
|||
public Object getRight() { |
|||
return right; |
|||
} |
|||
|
|||
public void setRight(Object right) { |
|||
this.right = right; |
|||
} |
|||
|
|||
public String getDiffType() { |
|||
return diffType; |
|||
} |
|||
|
|||
public void setDiffType(String diffType) { |
|||
this.diffType = diffType; |
|||
} |
|||
} |
|||
@ -0,0 +1,66 @@ |
|||
package com.zc.business.utils.diff.model; |
|||
|
|||
import java.util.ArrayList; |
|||
import java.util.Objects; |
|||
|
|||
/** |
|||
* 结果转换工具:将diff上下文转换成diff最终结果 |
|||
* @Author JingWei |
|||
* @create 2022/2/25 |
|||
*/ |
|||
public class ResultConvertUtil { |
|||
public static final String OBJECT_NULL = null; |
|||
//diff结果类型分为修改、新增、删除
|
|||
public static final String TYPE_MODIFY = "MODIFY"; |
|||
public static final String TYPE_ADD = "ADD"; |
|||
public static final String TYPE_DELETE = "DELETE"; |
|||
|
|||
/** |
|||
* 将diff上下文转换成diff最终结果 |
|||
* @param diffContext diff比较的直接结果 |
|||
* @return diff展示的结果 |
|||
*/ |
|||
public static ArrayList<Result> constructResult(DiffContext diffContext) { |
|||
ArrayList<Result> list = new ArrayList<>(); |
|||
for (SingleNodeDifference resultModel : diffContext.getDiffResultModels()) { |
|||
Result printModel = convert(resultModel); |
|||
boolean leftAndRightBothNull = (Objects.equals(OBJECT_NULL,resultModel.getLeft())) |
|||
&& Objects.equals(OBJECT_NULL,resultModel.getRight()) ; |
|||
//判断两个对象是否同时为空
|
|||
if (leftAndRightBothNull) { |
|||
printModel.setDiffType(TYPE_MODIFY); |
|||
} |
|||
//这种情况为对象A中keySet没这个key，或者A数组长度小于B 数组中没这个元素。
|
|||
else if (Objects.equals(OBJECT_NULL,resultModel.getLeft()) ) { |
|||
printModel.setDiffType(TYPE_ADD); |
|||
printModel.setLeftPath(null); |
|||
} |
|||
//这种情况为对象B中keySet没这个key，或者B数组长度小于A 数组中没这个元素。
|
|||
else if (Objects.equals(OBJECT_NULL,resultModel.getRight()) ) { |
|||
printModel.setDiffType(TYPE_DELETE); |
|||
printModel.setRightPath(null); |
|||
} |
|||
//其他情况
|
|||
else { |
|||
printModel.setDiffType(TYPE_MODIFY); |
|||
} |
|||
list.add(printModel); |
|||
} |
|||
return list; |
|||
} |
|||
|
|||
|
|||
/** |
|||
* 数据模型转换，增加类型字段。 |
|||
* @param resultModel 比较结果 |
|||
* @return 展示模型 |
|||
*/ |
|||
private static Result convert(SingleNodeDifference resultModel) { |
|||
Result printModel = new Result(); |
|||
printModel.setLeft(resultModel.getLeft()); |
|||
printModel.setRight(resultModel.getRight()); |
|||
printModel.setLeftPath(resultModel.getLeftPath()); |
|||
printModel.setRightPath(resultModel.getRightPath()); |
|||
return printModel; |
|||
} |
|||
} |
|||
@ -0,0 +1,69 @@ |
|||
package com.zc.business.utils.diff.model; |
|||
|
|||
import java.io.Serializable; |
|||
|
|||
/** |
|||
* 单对元素比较结果 |
|||
* @Author JingWei |
|||
* @create 2022/3/2 |
|||
*/ |
|||
public class SingleNodeDifference implements Serializable { |
|||
/** |
|||
* 第一个对象路径 |
|||
*/ |
|||
private String leftPath; |
|||
/** |
|||
* 第二个对象路径 |
|||
*/ |
|||
private String rightPath; |
|||
/** |
|||
* 第一个对象值 |
|||
*/ |
|||
private Object left; |
|||
/** |
|||
* 第二个对象值 |
|||
*/ |
|||
private Object right; |
|||
/** |
|||
* 比较结果 |
|||
*/ |
|||
|
|||
public SingleNodeDifference(String leftPath, String rightPath, Object left, Object right) { |
|||
this.leftPath = leftPath; |
|||
this.rightPath = rightPath; |
|||
this.left = left; |
|||
this.right = right; |
|||
} |
|||
|
|||
public String getLeftPath() { |
|||
return leftPath; |
|||
} |
|||
|
|||
public void setLeftPath(String leftPath) { |
|||
this.leftPath = leftPath; |
|||
} |
|||
|
|||
public String getRightPath() { |
|||
return rightPath; |
|||
} |
|||
|
|||
public void setRightPath(String rightPath) { |
|||
this.rightPath = rightPath; |
|||
} |
|||
|
|||
public Object getLeft() { |
|||
return left; |
|||
} |
|||
|
|||
public void setLeft(Object left) { |
|||
this.left = left; |
|||
} |
|||
|
|||
public Object getRight() { |
|||
return right; |
|||
} |
|||
|
|||
public void setRight(Object right) { |
|||
this.right = right; |
|||
} |
|||
} |
|||
Loading…
Reference in new issue