Spring Boot 通用对象列表比较和去重

1、前言

  在Excel批量导入数据时，常常需要与数据库中已存在数据的比较，并且需要考虑导入数据重复的可能性。

  导入的行数据，一般有一个实体类（对象）与之对应，往往这个实体类在数据库中的字段要比导入数据更多，如主键ID字段，这个ID字段一般不会出现在导入行数据中，此时导入的对象使用其它的唯一键来识别，如导入某个单位的用户数据，用用户名或手机号来唯一识别用户，而不会有用户ID字段（此时新用户的用户ID还有待系统来分配）。

  批量导入数据，往往需要与已存在对象数据进行比较，新的对象使用insert操作，已有对象使用update操作。但如果逐条数据，都先查询数据库，再决定是insert，还是update，是非常低效的，代码也会很臃肿。使用类似Mysql的ON DUPLICATE KEY UPDATE ，是一种解决方案，但在使用全局ID时，可能存在ID主键与其它唯一主键冲突的情况，导致update失败。

  因此，稳妥的作法，是比较导入对象集与存在对象集，比较的结果产生了4个集合：新增数据集合、属性值完全相同的对象集合、对象键值相同但属性有变化的对象集合、剩余对象集合。

  一般批量导入数据，会有一个限定，如导入用户数据，限定导入某一个单位的，这样比较的数据集就不会太大。

  因此，对象列表的比较，是批量数据导入的基础性功能。另外，导入数据，首先要消除数据中重复的对象，这些重复的对象数据是异常数据。

2、解决方案

  对象列表比较，应支持通用实体类对象，这样可实现代码的复用，消除低效重复的针对具体实体类的代码。因此需要支持泛型，且使用反射机制。

  另外，对象比较，是一组属性字段值比较，包括键值与普通属性值，键值用于识别对象。

  代码如下：

package com.abc.example.common.utils;

import java.lang.reflect.Field;
import java.util.List;
import java.util.Map;

import lombok.extern.slf4j.Slf4j;

/**
 * @className	        : ObjectListUtil
 * @description	        : 对象列表工具类
 * @summary		:
 * @history		:
 * ------------------------------------------------------------------------------
 * date		version		modifier		remarks                   
 * ------------------------------------------------------------------------------
 * 2021/08/15	1.0.0		sheng.zheng		初版
 *
 */
@Slf4j
public class ObjectListUtil {
    /**
     * 
     * @methodName	: compareTwoList
     * @description	: 比较两个对象列表，新列表与旧列表对比，根据比较的属性字段字典，比较结果
     * 			  1、新的对象；2、键值相同，属性不同，需要修改的对象；3、属性完全相同
     * 			  这样有新增对象列表，修改对象列表，相同对象列表，剩余对象列表
     * @param <T>	: 泛型类型T
     * @param fieldMap	: 比较字段字典，key为字段名称，value为是否键值，1表示键值字段，0为普通字段。
     * @param newList	: 新列表，要求键值无重复
     * @param oldList	: 旧列表，要求键值无重复，在方法中将被改变
     * @param addList	: 新增对象列表
     * @param sameList	: 相同对象列表
     * @param updateList: 修改对象列表
     * @param remainderList: 剩余对象列表
     * @history		:
     * ------------------------------------------------------------------------------
     * date		version		modifier		remarks                   
     * ------------------------------------------------------------------------------
     * 2021/08/15	1.0.0		sheng.zheng		初版
     *
     */
    public static <T> void compareTwoList(Map<String,Integer> fieldMap,
    	List<T> newList,List<T> oldList,
    	List<T> addList, List<T> sameList, 
    	List<T> updateList, List<T> remainderList) {
    	
    	// 遍历新列表
    	for(int i = 0; i < newList.size(); i++) {
    		T newItem = newList.get(i);
    		// 标记对象是否匹配
    		boolean found = false;
        	// 遍历旧列表，倒序
    		for (int j = oldList.size() - 1; j >= 0; j--) {
    		    T oldItem = oldList.get(j);
    		    // 比较两个对象
    		    int compare = compareTwoItem(fieldMap,newItem,oldItem);
    		    if (compare == 1) {
    			// 如果两个对象相同，加入相同列表中
    			sameList.add(newItem);
    			// 从列表中移除
    			oldList.remove(j);
    			found = true;
    			// 结束本轮遍历
    			break;
    		    }else if(compare == 2) {
    			// pass
    		    }else if(compare == 3) {
    			// 匹配对象，但属性不同，加入修改表中
    			updateList.add(newItem);
    			// 从列表中移除
    			oldList.remove(j);
    			found = true;
    			// 结束本轮遍历
    			break;
    		    }else {
    			// 发生异常
    			return;
    		    }
    		}
    		if (found == false) {
    		    // 如果本轮遍历，未找到匹配项，加入新增列表中
    		    addList.add(newItem);
    		}
    	}
    	
    	// oldList中剩余的项，加入剩余列表中
    	for(int i = 0; i < oldList.size(); i++) {
    		T oldItem = oldList.get(i);
    		remainderList.add(oldItem);
    	}
    	
    }
    
    /**
     * 
     * @methodName	: compareTwoItem
     * @description	: 比较两个相同类型的对象
     * @param <T>	: 泛型类型T
     * @param fieldMap	: 比较字段字典，key为字段名称，value为是否键值，1表示键值字段。
     * @param newItem	: 新的对象
     * @param oldItem	: 旧的对象
     * @return		: 返回值定义如下：
     * 		0	:	数据处理异常
     *  	1	:	对象完全相同（比较字段的字段值都相同）
     *  	2	:	对象不同（键值字段的字段值存在不相同）
     *  	3	:	对象相同，属性不同（键值字段的字段值相同，但属性值不同）
     * @history		:
     * ------------------------------------------------------------------------------
     * date		version		modifier		remarks                   
     * ------------------------------------------------------------------------------
     * 2021/08/15	1.0.0		sheng.zheng		初版
     *
     */
    @SuppressWarnings("unchecked")
	public static <T> int compareTwoItem(Map<String,Integer> fieldMap,T newItem, T oldItem) {
    	int retCode = 1;
    	try {
            for (Map.Entry<String,Integer> entry : fieldMap.entrySet()) {
        	// 取得字段名称
        	String fieldName = entry.getKey();
        	Integer keyFlag = entry.getValue();
        		
        	// 取得新对象的当前字段值
    		Class<T> newClazz = (Class<T>) newItem.getClass();        		
        	Field newField = newClazz.getDeclaredField(fieldName);
        	newField.setAccessible(true);
        	Object newValue = newField.get(newItem);
        		
        	// 取得旧对象的当前字段值
    		Class<T> oldClazz = (Class<T>) oldItem.getClass();        		
        	Field oldField = oldClazz.getDeclaredField(fieldName);
        	oldField.setAccessible(true);
        	Object oldValue = oldField.get(oldItem);
        		
        	// 比较两个属性字段的值
        	if (!newValue.equals(oldValue)) {
        	    // 如果字段值不相等
        	    if (keyFlag == 1) {
        		// 如果为键值字段，表示两个对象
        		return 2;
        	    }else {
        		// 非键值字段，表示有属性发生改变
        		retCode = 3;
        	    }
        	}        		
            }
    	}catch (NoSuchFieldException e) {
    		e.printStackTrace();    
    		log.error(e.getMessage());
    		return 0;
    	}catch (IllegalAccessException e) {
    		e.printStackTrace();    		
    		log.error(e.getMessage());
    		return 0;
    	}
    	return retCode;
    }
    
    /**
     * 
     * @methodName	: removeDuplicate
     * @description	: 对象列表去重
     * @param <T>	: 泛型类型T
     * @param fieldMap	: 比较字段字典，key为字段名称，value为是否键值，1表示键值字段。
     * @param inputList	: 对象列表，将被去重
     * @param dupList	: 重复的多余对象列表，将被去重
     * @history		:
     * ------------------------------------------------------------------------------
     * date		version		modifier		remarks                   
     * ------------------------------------------------------------------------------
     * 2021/08/15	1.0.0		sheng.zheng		初版
     *
     */
    public static <T> void removeDuplicate(Map<String,Integer> fieldMap,List<T> inputList,List<T> dupList){
    	// 开始比较下标
    	int pos = 0;
    	while (true) {
    	    if (inputList.size() -1 < pos) {
    	        break;
    	    }    		
    	    // 标记对象是否重复
    	    boolean found = false;    		
    		
    	    // 被比较对象
    	    T compItem = inputList.get(pos);
    		
    	    // 遍历列表
    	    for (int i = pos + 1; i < inputList.size(); i++) {
    		// 比较对象
    		T newItem = inputList.get(i);
    		int compare = compareTwoItem(fieldMap,newItem,compItem);
    		if (compare == 1 || compare == 3) {
    			// 键值相同，为重复对象
    			found = true;
    			// 结束本次比较
    			break;
    		}
    	    }
    	    if (found == true) {
    		// 对象重复
    		dupList.add(compItem);
    		// 移除重复项
    		inputList.remove(pos);
    		// 注意，移除后，当前位置不变
    	    }else {
    		// 不重复，处理下一个
    		pos ++;    			
    	    }    		
    	}
    }
}

3、调用方法

  调用方法如下：

    	// 去重处理
    	// 字段字典
    	Map<String,Integer> fieldMap = new HashMap<String,Integer>();
	// 手机号和用户名作为对象识别属性
    	fieldMap.put("phoneNumber", 1);
    	fieldMap.put("userName", 1);
    	List<UserInfo> dupList = new ArrayList<UserInfo>();
    	ObjectListUtil.removeDuplicate(fieldMap,importUserList,dupList);
	// dupList可以作为导入错误数据输出用

    	// 查询数据库中存在的数据，orgId为导入附加参数，表示单位ID
    	List<UserInfo> dbUserList = userDao.selectItemsByOrgId(orgId);

    	// 对比新旧数据列表
    	List<UserInfo> addList = new ArrayList<UserInfo>();
    	List<UserInfo> updateList = new ArrayList<UserInfo>();
    	List<UserInfo> sameList = new ArrayList<UserInfo>();
    	List<UserInfo> remainderList = new ArrayList<UserInfo>();
    	
	// 对象的其它属性字段，非键值
    	fieldMap.put("age", 0);
    	fieldMap.put("address", 0);    	    	
    	fieldMap.put("height", 0);
    	ObjectListUtil.compareTwoList(fieldMap, importUserList, dbUserList, 
    		addList, sameList, updateList, remainderList);

    	// 对addList执行insert操作，可以批量insert

    	// 对updateList执行update操作，逐个update