java 实现的excel数据导入及导入模板下载

/**
     * 下载导入数据模板
     * @param response
     * @param redirectAttributes
     * @return
     */
    @RequiresPermissions("persion:infoTbPersonLive:view")
    @RequestMapping(value = "import/template")
    public String importFileTemplate(HttpServletResponse response, RedirectAttributes redirectAttributes) {
        try {
            String fileName = "居住信息导入模板.xlsx";
            List<InfoTbPersonLive> list = Lists.newArrayList(); {
                InfoTbPersonLive simple  = new InfoTbPersonLive();
                //租客名，租客身份证，户主名，户主身份证，所在主体类型，主体门牌，入住时间,与户主关系，居住方式，租住事由，住所类别，购买意外保险，保险购买日期，离开日期
                InfoTbPerson person = new InfoTbPerson();
                simple.setPerson(person);
                simple.setPersoncrednum("441900XXXXXXXXXXXX");
                simple.setPersonname("租客名");
                simple.setPersonsex("1");
                simple.setPersonresiaddr("广东省东莞市厚街镇");
                simple.setCredType("111");
                
                person = new InfoTbPerson();
                person.setName("户主名");
                simple.setHouseholderPerson(person);
                simple.setHouseholderpersoncrednum("441900XXXXXXXXXXXX");
                
                simple.setSubjectType("03");
                simple.setHouseNum("市场主体的门牌号");
                
                simple.setRoomHouseNum("填写所在房间号");
                
                simple.setLiveSdate(DateUtils.formatDate(new Date(), "yyyy-MM-dd"));
                simple.setRelationWithHouseholder("8");
                simple.setLiveWay("1");
                
                simple.setLiveReason("1");
                simple.setLiveWhere("2");
                simple.setHaveInsurance("0");
                simple.setInsuranceBuydate(DateUtils.formatDate(new Date(), "yyyy-MM-dd"));
                simple.setLiveEdate(DateUtils.formatDate(new Date(), "yyyy-MM-dd"));
                simple.setPersonnation("01");
                
                list.add(simple);
            }
            new ExportExcel("居住记录", InfoTbPersonLive.class, 2).setDataList(list).write(response, fileName).dispose();
            return null;
        } catch (Exception e) {
            addMessage(redirectAttributes, "导入模板下载失败！失败信息："+e.getMessage());
        }
        return "redirect:"+Global.getAdminPath()+"/persion/infoTbPersonLive/?repage";

    }

//导入

@ResponseBody
    @RequiresPermissions("persion:infoTbPersonLive:edit")
    @RequestMapping(value = "importPersonLiveAjax", method=RequestMethod.POST)
    public String importPersonLiveAjax(MultipartFile file, final HttpServletRequest request){
        Map<String, String> result = new HashMap<String, String>();
        if(Global.isDemoMode()){     
            result.put("status", "1");
            result.put("msg", "演示模式，不允许操作！");
        }else{
            try {
                /*导入Excel*/
                if(file != null && file.getSize() > 0){
                        Map<String, Object> importResult = new HashMap<String, Object>();
                        importResultMap.put(request.getSession().getId(), importResult);
                        
                        importResult.put("process", "0");
                        /*进行文件导入操作,使用线程操作,避免因数据量过大导致session超时*/
                        Runnable importRunable = new ImportPersonLiveRunable(importResult, file);
                        Thread importThread = new Thread(importRunable);
                        importThread.start();
                        
                        result.put("status", "0");
                        result.put("msg", "文件导入处理中,请等待...");
                    
                }else{
                    result.put("status", "1");
                    result.put("msg", "导入文件不能为空,数据导入失败!");
                }
            } catch (Exception e) {
                e.printStackTrace();
                logger.error(e.getMessage());
                result.put("status", "1");
                result.put("msg", "系统错误,请联系管理人员!");
            }
        }
        return gson.toJson(result);
    }
    private class ImportPersonLiveRunable implements Runnable {
        
        private Map<String, Object> importResult;
        private MultipartFile file;
        
        
        public ImportPersonLiveRunable(Map<String, Object> importResult, MultipartFile file){
            this.importResult = importResult;
            this.file = file;
        }
        
        public void run() {
            int line = 0;
            try {
                /*从Excel中读取的信息列 */
                importResult.put("processMsg", "读取文件中...");
                
                ImportExcel ei = new ImportExcel(file,1, 0);
                //将excel转为List对象
                List<InfoTbPersonLive> importList = ei.getDataList(InfoTbPersonLive.class,importResult);
                
                
                importResult.put("processMsg", "文件读取完毕");
                
                if(importList != null && importList.size() > 0){ //有数据
                    //过滤条件
                    String scope = UserUtils.getScope();
                    StringBuilder failureMsg = new StringBuilder();    //错误信息
                    /*数据准备*/
                    User user = UserUtils.getUser();
                    Date currentDate = new Date();
                    SubjectBuildingRelation sbr = new SubjectBuildingRelation();
                    int successNum = 0; //成功条数
                    int failureNum = 0;    //失败条数
                    /*验证数据重复性*/
                    importResult.put("processMsg", "正在校验数据...");
                    Map<String, Map<Integer, InfoTbPersonLive>> resultMap = infoTbPersonLiveService.checkDuplicateInfo(importList);
                    Map<Integer, InfoTbPersonLive> duplicateMap = resultMap.get("duplicateMap");
                    Map<Integer, InfoTbPersonLive> personDiffMap = resultMap.get("personDiffMap");
                    Map<Integer, InfoTbPersonLive> noProblemMap = resultMap.get("noProblemMap");
                    if(duplicateMap.size() > 0){
                        for(Entry<Integer, InfoTbPersonLive> duplicate : duplicateMap.entrySet()){
                            //不允许该条导入
                            failureMsg.append(duplicate.getValue().getErrorMsg() + "<br>");
                            failureNum++;    //失败数量加一条
                        }
                    }
                    if(personDiffMap.size() > 0){
                        for(Entry<Integer, InfoTbPersonLive> personDiff : personDiffMap.entrySet()){
                            //不允许该条导入
                            failureMsg.append(personDiff.getValue().getErrorMsg() + "<br>");
                            failureNum++;    //失败数量加一条
                        }
                    }
                    importResult.put("processMsg", "数据校验完毕");
                    importResult.put("errorMsg", failureMsg.toString());
                    
                    duplicateMap = null;
                    personDiffMap = null;
                    
                    int sumLine = noProblemMap.size();
                    int count = 0;
                    if(sumLine > 0){
                        importResult.put("processMsg", "开始处理数据...");
                        for(Entry<Integer, InfoTbPersonLive> noProblem : noProblemMap.entrySet()){
                            try{
                                count++;
                                line = noProblem.getKey();
                                
                                InfoTbPerson personAdd = null;//需要新增的人员
                                InfoTbPerson personUpdate = null;//需要更新的人员
                                InfoTbPersonCred personCredAdd = null;//需要新增的证件
                                BuildingFloor floorAdd = null;//需要新增的楼层
                                BuildingRoom roomAdd = null;//需要新增的房间
                                InfoTbPersonLive personLiveAdd = null;//需要新增的居住记录
                                List<InfoTbPersonLive> personLiveUpdate = new ArrayList<InfoTbPersonLive>();//需要新增的房间
                                
                                
                                importResult.put("process", (int)((double)count/(double)sumLine * 100));
                                importResult.put("processMsg", "正在处理第" + count + "行数据!");
                                
                                InfoTbPersonLive personLiveExcel = noProblem.getValue();
                                
                                /*验证数据正确性*/
                                BeanValidators.validateWithException(validator, personLiveExcel);
                                String checkResult = infoTbPersonLiveService.checkInfo(personLiveExcel);
                                if(checkResult == null){
                                    //验证excel中的主体是否存在(判断条件为 主体类型和门牌,还必须为已入驻建筑)
                                    sbr.setSubjectType(personLiveExcel.getSubjectType());
                                    sbr.setHouseNum(personLiveExcel.getHouseNum());
                                    sbr.getSqlMap().put("dsf", scope);
                                    
                                    /*获取关联的建筑*/
                                    InfoTbBuilding building = null;
                                    List<SubjectBuildingRelation> relationList = subjectBuildingRelationService.findList(sbr);
                                    String subjectId = null;
                                    String subjectType = null;
                                    if(relationList != null && relationList.size() > 0){
                                        building = relationList.get(0).getBuilding();
                                        subjectId = relationList.get(0).getSubjectId();
                                        subjectType = relationList.get(0).getSubjectType();
                                    }
                                    
                                    if(building != null && building.getId() != null){//主体存在
                                        
                                        //验证楼层类型 楼层是否存在
                                        BuildingFloor floorExcel = new BuildingFloor();
                                        floorExcel.setFloorType(personLiveExcel.getFloorType());
                                        floorExcel.setFloorNum(personLiveExcel.getFloorNum());
                                        floorExcel.setBuilding(building);
                                        List<BuildingFloor> floorList = buildingFloorService.findList(floorExcel);
                                        
                                        //房间
                                        BuildingRoom roomExcel = new BuildingRoom();
                                        roomExcel.setHouseNum(personLiveExcel.getRoomHouseNum());
                                        
                                        BuildingRoom room = null;
                                        BuildingFloor floor = null;
                                        
                                        if(floorList != null && floorList.size() > 0){//楼层存在
                                            floor = floorList.get(0);
                                            roomExcel.setFloor(floor);
                                            
                                            /*判断房间是否存在*/
                                            List<BuildingRoom> roomList = buildingRoomService.findList(roomExcel);
                                            if(roomList != null && roomList.size() > 0){
                                                room = roomList.get(0);
                                            }
                                        }else{
                                            //新增楼层
                                            floor = floorExcel;
                                            floor.preInsert();
                                            
                                            floorAdd = floor;
                                            floorAdd.setDelFlag(BuildingFloor.DEL_FLAG_NORMAL);
                                            //新增房间
                                            roomExcel.setFloor(floor);
                                        }
                                        //房间不存在则新增
                                        if(room == null){
                                            room = roomExcel;
                                            room.setBuilding(building);
                                            room.setUseSituation("01");//房间类型"01-出租"
                                            room.preInsert();
        //                                    roomDao.insert(room);
                                            roomAdd = room;
                                            roomAdd.setDelFlag(BuildingRoom.DEL_FLAG_NORMAL);
                                        }
                                        
                                        //查询excel中的租住人是否已经存在
                                        InfoTbPerson infoTbPersonExcel = new InfoTbPerson();
                                        infoTbPersonExcel.setName(personLiveExcel.getPersonname());
                                        infoTbPersonExcel.setCredNum(personLiveExcel.getPersoncrednum());
                                        System.out.println("infoTbPersonExcel");
                                        List<InfoTbPerson> personList = infoTbPersonService.findListByCredNumAndName(infoTbPersonExcel);
                                        System.out.println("infoTbPersonExcel");
                                        InfoTbPerson person = null;
                                        if(personList != null && personList.size() > 0){
                                            person = personList.get(0);
                                        }else{
                                            person = new InfoTbPerson();
                                        }
                                        /*填充person*/
                                        person.setName(personLiveExcel.getPersonname());
                                        person.setCredNum(personLiveExcel.getPersoncrednum());
                                        person.setTel1(personLiveExcel.getPersontel());
                                        person.setNation(personLiveExcel.getPersonnation());
                                        person.setSex(personLiveExcel.getPersonsex());
                                        person.setResiAddr(personLiveExcel.getPersonresiaddr());
                                        person.setPersonType(InfoTbPerson.DEF_PERSON_TYPE);
                                        person.setHomeland(InfoTbPerson.DEF_HOMELAND);
                                        person.setCredType(personLiveExcel.getCredType());
                                        
                                        boolean isNewPerson = false;
                                        
                                        if(person.getId() == null){    //如果租住人不存在
                                            /*新增租住人*/
                                            person.preInsert();
                                            isNewPerson = true;
                                        }
                                        InfoTbPersonLive pl = new InfoTbPersonLive();
                                        pl.setSubjectId(relationList.get(0).getSubjectId());
                                        pl.setSubjectType(personLiveExcel.getSubjectType());
                                        pl.setPerson(person);
                                        pl.setBuilding(building);
                                        pl.setFloor(floor);
                                        pl.setRoom(room);
                                        pl.setIsLeave(null);
                                        
                                        boolean isExistsPersonLive = false;
                                        boolean isUpdateRecord = false;
                                        if(!isNewPerson){ //非新增人员
                                            //查找以往居住记录
                                            
                                            List<InfoTbPersonLive> plList = infoTbPersonLiveService.findList(pl);
                                            System.out.println("查询");
                                            long currentTimeLong = System.currentTimeMillis();
                                            
                                            /**遍历以往的居住信息**/
                                            if(plList != null && plList.size() > 0){
                                                for(InfoTbPersonLive p : plList){//循环旧记录
                                                    Date liveSdateOld = DateUtils.parseDate(p.getLiveSdate());//旧记录中的入住时间
                                                    Date liveSdateNew = DateUtils.parseDate(personLiveExcel.getLiveSdate());//excel中的入住时间
                        
                                                    /*
                                                    Calendar oldTime = Calendar.getInstance();
                    
                                                    oldTime.setTime(p.getUpdateDate());
                                                    oldTime.add(Calendar.MONTH, 1);    
                                                    if(currentTimeLong < oldTime.getTimeInMillis()){//不够30天
                                                        failureMsg.append("行号:" + line + ", 数据更新时间还未达到，请于 ["+oldTime.get(Calendar.YEAR)+"年"+
                                                                (oldTime.get(Calendar.MONTH)+1)+"月"+oldTime.get(Calendar.DATE)+"号] 后再更新这条数据！！");
                                                        failureNum++;
                                                        isExistsPersonLive = true;
                                                        break;
                                                    }*/
                                                    
                                                    /**入住时间一样**/
                                                    if(liveSdateOld != null && liveSdateNew != null && liveSdateOld.getTime() == liveSdateNew.getTime()){
                                                        //如果新记录的离开时间不为空,旧记录为空,则更新旧记录
                                                        if(StringUtils.isEmpty(p.getLiveEdate()) && StringUtils.isNotEmpty(personLiveExcel.getLiveEdate())){
                                                            p.setLiveEdate(personLiveExcel.getLiveEdate());
                                                            p.setUpdateDate(currentDate);
                                                            personLiveUpdate.add(p);
                                                            isUpdateRecord = true;
                                                        }else{
                                                            
                                                            
                                                            
                                                            /*failureMsg.append("行号:" + line + ", 数据已存在,请核对后再添加!<br/>");
                                                            failureNum++;
                                                            isExistsPersonLive = true;
                                                            break;*/
                                                        }
                                                    }else if(liveSdateOld != null && liveSdateNew != null && liveSdateOld.getTime() > liveSdateNew.getTime()){
                                                        if(StringUtils.isNotEmpty(p.getLiveEdate())){
                                                            if(liveSdateOld.getTime() > currentDate.getTime()){//旧记录入住时间大于当前日期
                                                                p.setLiveEdate(DateUtils.formatDate(liveSdateNew));//旧数据中的离开时间设置为当前时间
                                                            }else{
                                                                p.setLiveEdate(DateUtils.formatDate(currentDate));
                                                            }
                                                            p.setUpdateDate(currentDate);
                                                            personLiveUpdate.add(p);
                                                        }
                                                    }else{
                                                        if(liveSdateOld == null){
                                                            p.setLiveSdate(DateUtils.formatDate(liveSdateNew));
                                                        }
                                                        if(liveSdateNew != null){
                                                            p.setLiveEdate(DateUtils.formatDate(liveSdateNew));//旧数据中的离开时间设置为新入住时间
                                                        }else{
                                                            p.setLiveEdate(DateUtils.formatDate(currentDate));//旧数据中的离开时间设置为当前时间
                                                        }
                                                        p.setUpdateDate(currentDate);
                                                        personLiveUpdate.add(p);
                                                    }
                                                    
                                                    
                                                    Calendar oldTime = Calendar.getInstance();
                                                    
                                                    oldTime.setTime(p.getUpdateDate());
                                                    oldTime.add(Calendar.MONTH, 1);    
                                                    if(currentTimeLong < oldTime.getTimeInMillis()){//不够30天
                                                        failureMsg.append("行号:" + line + ", 数据更新时间还未达到，请于 ["+oldTime.get(Calendar.YEAR)+"年"+
                                                                (oldTime.get(Calendar.MONTH)+1)+"月"+oldTime.get(Calendar.DATE)+"号] 后再更新这条数据！！");
                                                        failureNum++;
                                                        isExistsPersonLive = true;
                                                        break;
                                                    }
                                                    
                                                }
                                            }
                                        }
                                        
                                        
                                        
                                        if(isExistsPersonLive && !isUpdateRecord){//已经存在的记录而且不是更新的信息
                                            importResult.put("errorMsg", failureMsg.toString());
                                        }else{
                                            /*如果不是重复记录*/
                                            if(!isExistsPersonLive && !isUpdateRecord){
                                                pl.setLiveSdate(personLiveExcel.getLiveSdate());
                                                pl.setLiveEdate(personLiveExcel.getLiveEdate());
                                                pl.setCreateBy(user);
                                                pl.setUpdateDate(currentDate);
                                                pl.setCreateDate(currentDate);
                                                pl.setUpdateBy(user);
                                                
                                                personLiveAdd = pl;
                                                personLiveAdd.setDelFlag(InfoTbPersonLive.DEL_FLAG_NORMAL);
                                                
                                            }
                                            
                                            //更新人口信息
                                            if(isNewPerson){
                                                personAdd = person;
                                                personAdd.setDelFlag(InfoTbPerson.DEL_FLAG_NORMAL);
                                                String credNum = personAdd.getCredNum();
                                                if(!Str.IsEmpty(credNum) && credNum.length() == 18){
                                                    String birthDay = credNum.substring(6,14);
                                                    try {
                                                        personAdd.setBirthday(DateUtils.parseDate(birthDay, "yyyyMMdd"));
                                                    } catch (Exception e) {
                                                        e.printStackTrace();
                                                    }
                                                    
                                                }
                                                /*新增身份证信息表信息*/
                                                InfoTbPersonCred infoTbPersonCred = new InfoTbPersonCred();
                                                infoTbPersonCred.setPerson(person);
                                                infoTbPersonCred.setCredNum(person.getCredNum());
                                                infoTbPersonCred.setName(person.getName());
                                                infoTbPersonCred.setCredType(person.getCredType());
                                                infoTbPersonCred.preInsert();
                                                personCredAdd = infoTbPersonCred;
                                                personCredAdd.setDelFlag(InfoTbPersonCred.DEL_FLAG_NORMAL);
                                            }else{
                                                personUpdate = person;
                                            }
                                            
                                            infoTbPersonLiveService.importPersonLive(subjectId, subjectType, floorAdd, roomAdd, personAdd,personUpdate,personCredAdd,personLiveUpdate, personLiveAdd);
                                            successNum++;
                                            
                                        }
                                        
                                    }else{
                                        failureMsg.append("行号:" + line + ", 该主体不存在!<br>");
                                        importResult.put("errorMsg", failureMsg.toString());
                                        failureNum++;    //失败数量加一条
                                    }
                                }else{//有错误信息
                                    failureMsg.append("行号:" + line + "," + checkResult + "<br/>");
                                    importResult.put("errorMsg", failureMsg.toString());
                                    failureNum++;
                                }
                            }catch (Exception e) {
                                failureMsg.append("行号:" + line + ", 导入失败!<br>");
                                importResult.put("errorMsg", failureMsg.toString());
                                failureNum++;    //失败数量加一条
                                logger.error(e.getMessage());
                                e.printStackTrace();
                            }
                        }
                        
                    }
                    importResult.put("processMsg", "导入完成,成功:" + successNum + "条, 失败:" + failureNum + "条");
                    importResult.put("errorMsg", failureMsg.toString());
                }else{//文件为空
                    importResult.put("errorMsg", "导入文件信息不正确!");
                }
                importResult.put("process", "100");
                importResult.put("finish", "1");
            }catch(InvalidFormatException e){
                e.printStackTrace();
                logger.error(e.getMessage());
                importResult.put("processMsg", null);
                importResult.put("errorMsg", "导入文件不正确!");
                importResult.put("exception", e.getMessage());
                importResult.put("finish", "1");
            }catch(IOException e){
                e.printStackTrace();
                logger.error(e.getMessage());
                importResult.put("processMsg", null);
                importResult.put("errorMsg", "导入文件不正确!");
                importResult.put("exception", e.getMessage());
                importResult.put("finish", "1");
            }catch(Exception e){
                e.printStackTrace();
                logger.error(e.getMessage());
                importResult.put("processMsg", null);
                if(line != 0){
                    importResult.put("errorMsg", "行号:" + line + ",导入过程发生错误,导入失败!");
                }else{
                    importResult.put("errorMsg", "导入过程发生错误,导入失败!");
                }
                importResult.put("exception", e.getMessage());
                importResult.put("finish", "1");
            }    
            System.out.println("finish........");
        }
        
    }