easyexcel导入获取表头并且表头为不固定列

Controller

@PostMapping("upload")
    @ResponseBody
    public HashMap<String, Object> upload(@RequestParam(value = "file") MultipartFile file,
                                          @RequestParam(value = "ztId") int ztId,
                                          @RequestParam(value = "qj") String qj,
                                          @RequestParam(value = "gzlbId") String gzlbId) throws IOException {
      
        gzdrService.init(ztId, qj, gzlbId);
        //生成uuid
        String uuid = UUID.randomUUID().toString();
        GzdrListener gzdrListener = new GzdrListener(ztId, gzdrService, uuid, qj, gzlbId);
        EasyExcel.read(file.getInputStream(), gzdrListener).sheet("导入模板").doReadSync();
        HashMap<String, Object> hashMap = new HashMap<>();
        List<String> errMessage = gzdrListener.getErrMessage();
        if (errMessage.isEmpty()) {
            hashMap.put("success", true);
        } else {
            hashMap.put("success", false);
            hashMap.put("errMessage", errMessage);
        }
        return hashMap;
    }

GzdrListener 

public class GzdrListener extends AnalysisEventListener<Map<Integer, String>> {

    /**
     * 每隔128条存储数据库，然后清理list ，方便内存回收
     */

    private static final int BATCH_COUNT = 128;
    private int ztId;
    private List<String> errMessage;
    private GzdrService gzdrService;
    List<Map<Integer, String>> list = new ArrayList<Map<Integer, String>>();
    private String uuid;
    private String qj;
    private String gzlbId;

    public GzdrListener(int ztId, GzdrService gzdrService, String uuid, String qj, String gzlbId) {
        this.ztId = ztId;
        this.gzdrService = gzdrService;
        this.uuid = uuid;
        this.qj = qj;
        this.gzlbId = gzlbId;
        errMessage = new ArrayList<>();
    }

    @Override
    public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
        logger.info("解析到一条头数据：{}, currentRowHolder: {}", headMap.toString(), context.readRowHolder().getRowIndex());
        list.add(headMap);
    }

    @Override
    public void invoke(Map<Integer, String> data, AnalysisContext context) {
        logger.info("解析到一条数据：{}, currentRowHolder: {}", data.toString(), context.readRowHolder().getRowIndex());
        list.add(data);
        // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
        if (list.size() >= BATCH_COUNT) {
            errMessage.addAll(saveData());
            // 存储完成清理 list
            list.clear();
        }
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        // 这里也要保存数据，确保最后遗留的数据也存储到数据库
        errMessage.addAll(saveData());
        logger.info("所有数据解析完成！");
    }

    /**
     * 加上存储数据库
     */
    private List<String> saveData() {
        logger.info("{}条数据，开始存储数据库！,ztId:{}  ", list.size(), ztId);
        return gzdrService.save(list, ztId, uuid, qj, gzlbId);
    }

    public List<String> getErrMessage() {
        return errMessage;
    }

    public void setErrMessage(List<String> errMessage) {
        this.errMessage = errMessage;
    }

    public GzdrService getGzdrService() {
        return gzdrService;
    }

    public void setGzdrService(GzdrService gzdrService) {
        this.gzdrService = gzdrService;
    }

    private final static Logger logger = LoggerFactory.getLogger(GzdrListener.class);
}

gzdrService的save做对应的校验和保存就行了。