关于 DiffUtil 笔记

关于 DiffUtil 笔记

准备2个Model

public class LoginModel implements Serializable {

    private static final long serialVersionUID = -8532417847222176161L;

    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "LoginModel{"
            + "username='" + username + "'"
            + ", password='" + password + "'"
            + "}";
    }
}


public class DiffResult<T> {
    /**
     * 新增对象列表
     */
    private List<T> addedList;
    /**
     * 修改后的对象列表
     */
    private List<T> changedList;
    /**
     * 已删除对象列表
     */
    private List<T> deletedList;

    public List<T> getAddedList() {
        return addedList;
    }

    public DiffResult<T> setAddedList(List<T> addedList) {
        this.addedList = addedList;
        return this;
    }

    public List<T> getChangedList() {
        return changedList;
    }

    public DiffResult<T> setChangedList(List<T> changedList) {
        this.changedList = changedList;
        return this;
    }

    public List<T> getDeletedList() {
        return deletedList;
    }

    public DiffResult<T> setDeletedList(List<T> deletedList) {
        this.deletedList = deletedList;
        return this;
    }
}

创建DiffUtil

public class DiffUtil {

    /**
     * 对比两个List的元素
     * 如果 baseList 的元素在 targetList 中存在 PrimaryKey 相等的元素并且 elementComparator 比较结果不相等，则将修改后的值添加到changedList列表中；
     * 如果 baseList 的元素在 targetList 中不存在，将baseList中的元素添加到deletedList中；
     * 如果 targetList 的元素在 baseList 中不存在，将targetList中的元素添加到addedList中；
     *
     * @param baseList            基础List(原来的List)
     * @param targetList          目标List(最新的List)
     * @param elementComparator   元素比较器
     * @param primaryKeyExtractor 主键选择器
     * @return 对比结果
     */
    public static <T> DiffResult<T> diffList(List<T> baseList,
        List<T> targetList,
        Function<T, Object> primaryKeyExtractor,
        Comparator<T> elementComparator) {

        DiffResult<T> checkResult = checkEmptyAndReturn(baseList, targetList);
        if (checkResult != null) {
            return checkResult;
        }

        Map<Object,T> baseMap = new HashMap<>(4096);
        for(T base : baseList){
            Object key = primaryKeyExtractor.apply(base);
            baseMap.put(key,base);
        }

        List<T> addedList = new ArrayList<>();
        List<T> deletedList = new ArrayList<>();
        List<T> changedList = new ArrayList<>();

        //找出新增的 和需要更新的
        for (T target : targetList) {
            Object key = primaryKeyExtractor.apply(target);
            T base = baseMap.get(key);
            if(base == null){
                addedList.add(target);
            }else{
                baseMap.remove(key);
                if (elementComparator.compare(base, target) != 0) {
                    changedList.add(target);
                }
            }
        }

        //剩余的就是需要删除的
        Set<Map.Entry<Object, T>> entrySet = baseMap.entrySet();
        if(ObjectUtils.isNotEmpty(entrySet)){
            for(Map.Entry<Object, T> entry:entrySet){
                deletedList.add(entry.getValue());
            }
        }

        return new DiffResult<T>()
            .setChangedList(changedList)
            .setAddedList(addedList)
            .setDeletedList(deletedList);
    }

    /**
     * 检查baseList 和 targetList 为empty(null||size==0)的情况
     *
     * @param baseList
     * @param targetList
     * @return
     */
    private static <T> DiffResult<T> checkEmptyAndReturn(List<T> baseList, List<T> targetList) {

        if (ObjectUtils.isEmpty(baseList) && ObjectUtils.isEmpty(targetList)) {
            return new DiffResult<T>();
        }

        if (ObjectUtils.isEmpty(baseList) && ObjectUtils.isNotEmpty(targetList)) {
            return new DiffResult<T>();
        }

        if (ObjectUtils.isNotEmpty(baseList) && ObjectUtils.isEmpty(targetList)) {
            return new DiffResult<T>();
        }
        return null;
    }


}

TEST

public static void main(String[] args) {

        List<LoginModel> command = new ArrayList<>();
        LoginModel loginModel1 = new LoginModel();
        loginModel1.setUsername("AAA");
        loginModel1.setPassword("123");
        LoginModel loginModel2 = new LoginModel();
        loginModel2.setUsername("BBB");
        loginModel2.setPassword("123");
        command.add(loginModel1);
        command.add(loginModel2);
        System.out.println("command: " + command);

        List<LoginModel> db = new ArrayList<>();
        LoginModel loginModel3 = new LoginModel();
        loginModel3.setUsername("AAA");
        loginModel3.setPassword("123");
        LoginModel loginModel4 = new LoginModel();
        loginModel4.setUsername("CCC");
        loginModel4.setPassword("123");
        db.add(loginModel3);
        db.add(loginModel4);
        System.out.println("db: " + db);

        Function<LoginModel, Object> function = LoginModel::getUsername;

        DiffResult<LoginModel> diffResult = DiffUtil.diffList(db, command, function, new Comparator<LoginModel>() {
            @Override
            public int compare(LoginModel o1, LoginModel o2) {
                int i = 0;
                if (o1.getPassword().equals(o2.getPassword())) {
                	i = 1;
                }
                return i;
            }
        });

        System.out.println(diffResult);
}