SpringMVC文件上传 Excle文件 Poi解析 验证 去重 并批量导入 MYSQL数据库

SpringMVC文件上传 Excle文件 Poi解析并批量导入 MYSQL数据库 

/**
* 业务需求说明：
* 1 批量导入成员 并且 自主创建账号
* 2 校验数据格式 且 重复导入提示 已被占用
* 3 导入手机相同 则更新源有信息
* 4 返回错误信息
*/

jsp文件 部分 浏览 以及功能键 代码：

   <div class="modal-body" style="position: relative;">
         <form class="" role="form" id="upload_form">
             <select class="form-control m-b" id="upload_dept" name="uploadDept">
             </select>
             <div class="input-group">
                 <input type="text" class="form-control input-sm" name="upload_filename">
                     <div class="input-group-btn">
                         <button type="button" class="btn btn-sm btn-primary">
                         浏览
                         </button>
                     </div>
             </div>
               <!--  选择上传文件按钮   type类型指定为 file   accept 可以在浏览过程中 进行过滤显示   支持多个用逗号隔开  -->
                             <!-- 选择文件后显示文件名称  对更改事件绑定了事件监听器 selectUploadFile(this)   此框按钮id为: upload_file    -->
                 <input type="file" id="upload_file" onchange="selectUploadFile(this)" name="uploadFile" accept=".xls,.xlsx" class="input-fzliulan">
         </form>
     </div>
     <div class="modal-footer">
         <button type="button" id="btn_upCancel" class="btn btn-white" data-dismiss="modal">关闭</button>
         <button type="button" id="btn_upSubmit" class="btn btn-success pdlr16"><span id="uploadTxt">导入</span><img id="loadingImg" style="display: none" src="<%=contextPath%>/resource/images/loading.gif" /></button>
     </div>

comm.jsp文件定义的变量:

   var userId = '<c:out value="${sessionScope.USER.userId}" />';
     var orgId = '<c:out value="${sessionScope.ORG.orgId}" />';
     var authLevel = '<c:out value="${sessionScope.USER.authLevel}" />';
     var userType = '<c:out value="${sessionScope.USER.type}" />';
     var orgAmount= '<c:out value="${sessionScope.AGENT.orgAmount}" />';
     var loginUser = {userId: userId, orgId: orgId, authLevel: authLevel, type: userType ,orgAmount:orgAmount};

页面js：

 $(function(){
     bindEvent();
 })
 /** 为页面按钮绑定事件
  */
 function bindEvent(){
     /**
      * 显示上传文件名称
      * @param fileObj
      */
     function selectUploadFile(fileObj){
         var fullPath = $(fileObj).val();
         var index = fullPath.lastIndexOf('\\') + 1;
         var fileName = fullPath.substring(index);
         $('input[name="upload_filename"]').val(fileName);
     }

  $('#downLoadTemplate').click(function(){  //下载模板按钮的监听器
         var url = webContext + '/file\\template\\组织用户信息模板.xlsx';
         downloadFile(url)
     });

 /**
  * 上传文件
  */

   $('#btn_upSubmit').click(function(){
      var valid = uploadValidator.checkForm(); //检测传单内容输入是否有问题
         if(!valid){
             uploadValidator.showErrors();
         } else{ //检测成功
             $('#uploadTxt').text('');
             $('#loadingImg').show();  //按钮换成动画效果图片
 /** 准备参数： */
             var orgId = loginUser.orgId;  //但钱用户的组织id
             var deptId = $('#upload_dept').val();  //  选框中选择的部门id
             var password = hex_md5('123456');//  默认密码 进行加密
             var param = {orgId: orgId, deptId: deptId, password: password};  //ajax传输 携带json详细信息
             var url = webContext + '/org/uploadOrgUser';  //   /** 使用ajaxFileUpload */
     $.ajaxFileUpload({
         url: url, //用于文件上传的服务器端请求地址
         secureuri: false, //是否需要安全协议，一般设置为false
         fileElementId: 'upload_file', //文件上传域的ID  就是选定文件的 type=file的input框的id  ajaxFileUpload 会帮我们把他分装到ajax请求的 携带对象域中去
         dataType: 'json', //返回值类型 一般设置为json
         type: 'post',
         data: param,
         success:function(){
         //成功的success 回调方法等业务流程结束后再写
         //先留已空白
         }
     })
         }
   })
 }

项目使用SpringMVC ：

其controller为:

 //-----------------------------------MVC 的控制器----------------------
 //Controller为：
 @Controller
 @RequestMapping("/org")
 public class OrgController extends BaseController {

     @Autowired
     private IOrgService orgService;

     @RequestMapping("/uploadOrgUser")
     @ResponseBody
     public Map<String, Object> uploadOrgUser(HttpServletRequest request){
         Map<String, Object> map = new HashMap<String, Object>();
         String flag = "failure";
         String msg = "上传成功";
         MultipartHttpServletRequest mtRequest = (MultipartHttpServletRequest) request;//多部分httpRquest对象    是HttpServletRequest类的一个子类接口   支持文件分段上传对象
         Integer orgId = RequestUtil.getIntParam(mtRequest, "orgId");  //组织id
         Integer deptId = RequestUtil.getIntParam(mtRequest, "deptId"); //选取部门id
         String password = RequestUtil.getStringParam(request, "password"); // 初始密码 已被md5加密
         MultipartFile upFile = mtRequest.getFile("uploadFile"); // 直接获取文件对象
         if(null == upFile || upFile.getSize()==0){   //文件不存在的情况
             msg = "上传文件不存在或为空文件";
             map.put("flag", flag);
             map.put("msg", msg);
             return map;  //返回错误信息
         }
         String targetPath = request.getServletContext().getRealPath("/file/upload"); //获取服务器 中file/update 的 url地址
         map = orgService.uploadOrgUser(targetPath, orgId, deptId, password, upFile);  //调用实现类 返回 界面消息 对象
         return map;
     }
 }

--业务层接口--说明：

 public interface IOrgService {
     /**
      * @param targetPath
      * @param orgId
      * @param deptId
      * @param password
      * @param upFile
      * @return
      */
     public Map<String, Object> uploadOrgUser(String targetPath, Integer orgId, Integer deptId, String password, MultipartFile upFile);
 }

--业务层实现类：

 //业务层实现类：
 @Service("orgService")
 public class OrgServiceImpl extends BaseService implements IOrgService {

     @Autowired
     private IOrgDao orgDao;

     @Autowired
     private IUserDao userDao;

     @Autowired
     private IDeptDao deptDao;

     @Autowired
     private IOrgUserDao orgUserDao;

     @Autowired
     private IServiceAuthDao authDao;

     /**  批量导入 业务方法  **/
     public Map<String, Object> uploadOrgUser(String targetPath, Integer orgId, Integer deptId, String password, MultipartFile upFile) {
         Map<String,Object> rm = new HashMap<String,Object>();
         String flag ="failure";
         String msg = "上传失败";
         File f = new File(targetPath) //实例硬盘中文件夹（路径）对象
         if(!f.exists()){//判断此路径/文件夹是否存在
             f.mkdirs(); //如果不存在  则创建文件夹/目录
         }
         String originalName = upFile.getOriginalFilename();//获取文件对象原始文件名
         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
         String tag = sdf.format(new Date());
         String upFileName = targetPath + File.separator+tag+"_"+originalName;// 拼接出文件的要存储的位置（全路径）
         File file = new File(upFileName);//创建 内存中的File对象
         if(file.exists()){ //判断是否存在
             file.delete();//如果有重名文件存在  就删除文件
             // 这个对象对应的硬盘必须删  不能存在  如果已经存在 则会抛出
             // IOException异常
         }
         List<OrgUser> orgUsers = null;
         List<User> users = null;
         List<RowData> offedData = null;  //List 集合对象准备
         try{
             upFile.transferTo(file);//转存文件  写入硬盘  //这个  本质还是一样的打开流传文件  需要注意 file对应的硬盘中的文件不能存在 需要删除  否则会抛出 文件已经存在且不能删除 异常
             // 校验上传数据
             /**  辅助方法一 **/
         Map<String,Object> validData = validUpload(file,orgId,deptId);// 校验数据    分类 返回 map形式
         users = (List<User>) validData.get("PASSED_USERS");  //通过的user  是向 m_user 表的
         orgUsers = (List<OrgUser>) validData.get("PASSED_ORGUSERS"); //  是向 m_org_user 表的
         offedData = (List<RowData>) validData.get("OFFED_ROW");    //？
         int rowNum = (Integer) validData.get("DATA_SIZE");   //  excle 数据总长度
         rm.put("ROW_COUNT", rowNum);//业务类的总长度

         List<OrgUser> ous = orgUserDao.getOrgUsers(orgId);//获取组织的所有用户
         ServiceAuth sa = new ServiceAuth(); //权限对象
         sa.setOrgId(orgId);  //  设置组织id
         sa.setServiceCode(Sys.GROUP_ORG); //设置服务编码  多用户版基础服务
         sa.setType(Sys.TYPE_BUY); //设置 类型 为购买类型
         ServiceAuth nSa = authDao.getOrgServiceAuthInfo(sa); //获取组织服务等级 详细信息
         int actSize = ous.size(); // 当前组织已有用户的总长度
         int license = nSa.getLicense(); // 组织上限人数
         int totalNum = 0;  //设置总数为 0

         Org o = orgDao.getOrgById(orgId);  //获取组织对象
         Date duration = DateFormater.stringToDate(o.getDuration(), "yyyy-MM-dd"); //获取服务到期时间
         //上数据库插入数据
         if(null!=users && !users.isEmpty()){
             totalNum = actSize + users.size();  //总数现在等于 添加人数和已有人数
             if(totalNum < license){//上传人数和原有人数之和小于组织服务人数上限
                 for(int i=0; i<users.size(); i++){
                     User u = users.get(i);
                     u.setPassword(password);
                     OrgUser ou = orgUsers.get(i);
                     userDao.addUser(u);
                     //添加到微信企业号
                     addCpUser(u);
                     //添加个人空间
                     Org selfOrg = new Org();
                     selfOrg.setAdminName(u.getUserName());
                     selfOrg.setType(Sys.ORG_TYPE_PER);
                     selfOrg.setState(Sys.ORG_VERIFY_1);
                     selfOrg.setAdminId(u.getUserId());
                     selfOrg.setAdminName(u.getUserName());
                     selfOrg.setDuration(duration);
                     selfOrg.setDel(Sys.UN_STOPED);
                     selfOrg.setCreateTime(new Date());
                     selfOrg.setUpdateTime(new Date());
                     selfOrg.setIdparent(0);
                     orgDao.addOrg(selfOrg);
                     Dept d = new Dept();
                     d.setDeptId(0);
                     addOrgUserRelation(selfOrg, d, u);
                     if(null!=u.getUserId() && u.getUserName().equals(ou.getOrgUserName())){
                         ou.setUserId(u.getUserId());
                         orgUserDao.addOrgUser(ou);
                     }
                 }
                 rm.put("PASSED_COUNT", users.size());//成功数据
             } else {
                 rm.put("ORG_LICENSE", license);  //上限
                 rm.put("ORG_ACTSIZE", actSize);  //
                 rm.put("OVER_LICENSE", totalNum - license);
             }

         }
         int offedCount = 0;
         if(null!= offedData && !offedData.isEmpty()){
             offedCount = offedData.size();
             rm.put("OFFED_DATA", offedData);
         }
         rm.put("OFFED_COUNT", offedCount);

         flag = "success";
         msg = "上传成功";
         }  catch (Exception e2) {
             logger.error("Exception while uploadOrgUser", e2);
         }
         rm.put("flag", flag);
         rm.put("msg", msg);

         return rm;

     }
 }

----------------------------------------------------------------------------------------------------------------------------------------------

//辅助方法清单：

  //*************************** 辅助方法一 *****************************************************************
     /**
      * 校验上传文件
      * 参数：文件对象
      *       组织id
      *       部门id
      */
     private Map<String, Object> validUpload(File uploadFile, Integer orgId, Integer deptId) throws Exception{
         Map<String, Object> map = new HashMap<String, Object>();
         List<User> passed = null;
         List<User> offed = null;
         List<String> mobileList = userDao.getAllActiveMobile();//为了防止已注册用户再次注册
         List<String> emailList = userDao.getAllActiveEmail();//  现在还是查询出所有的     ------需要优化标记
         //获取上传的excel中的数据
         //******辅助方法二*********
         ExcelData uploaddata = getUploadUserData(uploadFile);//获取内存中解析好的excle数据对象
         //校验上传数据
         //******辅助方法三*********
         Map<String, Object> dataMap = validUploadData(orgId, deptId, uploaddata, mobileList, emailList); //返回的是数据对象

         return dataMap;
 }

  //*************************** 辅助方法二 *****************************************************************
    /**
     * 获取上传文件的数据
     * @param uploadFile
     * @return
     * @throws Exception
     */
    private ExcelData getUploadUserData(File uploadFile) throws Exception{
        List<User> list = new ArrayList<User>();
        String[] columnKey = {"userName", "mobile", "phone", "email", "QQ", "weixin", "job", "dept", "note"};
        int startRow = 1;
        ExcelData uploadData = FileUtil.parseExcelFile(uploadFile, startRow, columnKey);//将要抛出异常
        return uploadData;
    }

}

   //*************************** 辅助方法三 *****************************************************************
     /**
      *   方法说明：
      *              校验上传数据
      *
      *
      * @param orgId     其应该所属的组织
      * @param deptId    所选的部门id
      * @param excelData excel表格数据对象
      * @param mobiles   所有的手机号码 集合   用来判断手机是否注册
      * @param emails    所有的邮箱号码 集合
      * @return
      */
     private Map<String, Object> validUploadData(Integer orgId, Integer deptId,ExcelData excelData, List<String> mobiles, List<String> emails) {
         Map<String, Object> map = new HashMap<String, Object>();
         List<RowData> passed = new ArrayList<RowData>();
         List<User> passedUsers = new ArrayList<User>();  // 通过验证的  到 m_user
         List<OrgUser> passedOrgUsers = new ArrayList<OrgUser>(); //通过验证的   到m_org_user
         List<RowData> offed = new ArrayList<RowData>();
         List<RowData> rows = null;//  所有数据
         Date createTime = new Date();//创建时间
         Date updateTime = new Date();  //更新时间
         List<Dept> deptList = null;  //当前组织的所有部门的   list集合
         Map<String, Dept> deptMap = new HashMap<String, Dept>();
         if(null != excelData && null != excelData.getRows() && !excelData.getRows().isEmpty()){  //如果传入对象不为空
             rows = excelData.getRows();  //获取对象中的所有数据   类型应该是List集合 每个元素应该是一行数据 即：RowData
             map.put("DATA_SIZE", rows.size());// 设置总数据有多少条
             List<String> excelMobiles = new ArrayList<String>();  //用于存放excle表格中的电话号码
             List<String> excelEmails = new ArrayList<String>(); //用于存放excle表格中的邮箱号码
             deptList = deptDao.getDeptsByOrgId(orgId);//获取所有部门？
             for(Dept dept:deptList){
                 String deptName = dept.getDeptName();
                 deptMap.put(deptName, dept);//转成map了
             }
 rowloop:     //行循环跳出坐标准备
             for (int i = 0; i < rows.size(); i++) {//循环便利数据
                 OrgUser orgUser = new OrgUser();  //组织用户 实例化对象准备
                 User user = new User();  //用户 POJO准备
                 //获取行数据
                 RowData r = rows.get(i);  //  获取行数据
                 int rowIndex = r.getRowIndex();  //  获取当前行是第几行
                 List<CellData> cells = r.getCells();  //获取当前行的所有数据  cell 的s
                 boolean flag = true;
                 String userName="",mobile="",phone="",email="",qq="",weixin="",job="";
                 int mIndex = 0;
                 int eIndex = 0;
 columnloop: //列循环跳出坐标准备
                 for (int j = 0; j < cells.size(); j++) {  // 每一行单元格数据 遍历
                     CellData c = cells.get(j);  //获取出当前的 数据独立单元格
                     String key = c.getKey();  //属于哪一列？
                     String cellValue = c.getCellValue(); //值
                     if("userName".equals(key)){
                         userName = cellValue;
                         if(StringUtil.isBlank(cellValue)){
                             flag = false;
                             c.setPassed(0);
                             c.setExtraInfo("用户姓名不能为空");
                             continue columnloop;
                         }
                         user.setUserName(cellValue);
                         orgUser.setOrgUserName(cellValue);
                     } else if("mobile".equals(key)){  //手机相关验证
                         mIndex = j;
                         mobile = cellValue;
                         if(!StringUtil.isBlank(cellValue)){
                             if(!Validator.isMobile(cellValue)){ //校验手机格式
                                 flag = false;
                                 c.setPassed(0);
                                 c.setExtraInfo("不正确的手机号");
                                 continue columnloop;
                             }

                             if(mobiles.contains(cellValue.trim())){// 比对数据库中的  是否已被注册
                                 flag = false;
                                 c.setPassed(0);
                                 c.setExtraInfo("该手机号已经被使用");
                                 continue columnloop;
                             }
                             if(excelMobiles.contains(cellValue.trim())){ // 当前表格 数据有重复
                                 flag = false;
                                 c.setPassed(0);
                                 c.setExtraInfo("重复的手机号码");
                                 continue columnloop;
                             }
                             user.setLoginName(cellValue);
                         }
                         user.setMobile(cellValue);
                     } else if("phone".equals(key)){ //暂无
                         phone = cellValue;
                         if(!StringUtil.isBlank(cellValue)){
                             //                            if(!Validator.isPhone(cellValue)){
                             //                                flag = false;
                             //                                c.setPassed(0);
                             //                                c.setExtraInfo("不正确的电话号");
                             //                                continue columnloop;
                             //                            }
                         }
                         user.setPhone(cellValue);
                     } else if("email".equals(key)){  // 邮箱相关验证
                         eIndex = j;
                         email = cellValue;
                         if(!StringUtil.isBlank(cellValue)){
                             if(!Validator.isEmail(cellValue)){
                                 flag = false;
                                 c.setPassed(0);
                                 c.setExtraInfo("邮箱格式不正确");
                                 continue columnloop;
                             }
                             if(emails.contains(cellValue.trim())){
                                 flag = false;
                                 c.setPassed(0);
                                 c.setExtraInfo("该邮箱已经被使用");
                                 continue columnloop;
                             }
                             if(excelMobiles.contains(cellValue.trim())){
                                 flag = false;
                                 c.setPassed(0);
                                 c.setExtraInfo("重复的邮箱");
                                 continue columnloop;
                             }
                             user.setLoginName(cellValue);
                         }
                         user.setEmail(cellValue);
                     } else if("QQ".equals(key)){
                         qq = cellValue;
                         user.setQq(cellValue);
                     } else if("weixin".equals(key)){
                         weixin = cellValue;
                         user.setWeixin(cellValue);
                     } else if("job".equals(key)){
                         job = cellValue;
                         orgUser.setPosition(cellValue);
                         //暂无
                     } else if("note".equals(key)){
                         user.setNote(cellValue);
                     } else if("dept".equals(key)) {
                         if(!StringUtil.isBlank(cellValue) && null!=deptMap.get(cellValue.trim())){
                             Dept d = deptMap.get(cellValue.trim());
                             orgUser.setDeptId(d.getDeptId());
                         } else {
                             orgUser.setDeptId(deptId);
                         }
                     } else {
                         //暂无
                     }
                 }
                 //校验手机与邮箱是否同时为空
                 if(StringUtil.isBlank(mobile) && StringUtil.isBlank(email)){
                     flag = false;
                     CellData mobileCell = cells.get(mIndex);//所属的 行和列
                     CellData emailCell = cells.get(eIndex);
                     mobileCell.setPassed(0);  //设置是否通过了校验的标识   注：此标识是对单元格数据进行设置的
                     mobileCell.setExtraInfo("手机与邮箱不能同时为空"); //没有通过校验  进行
                     emailCell.setPassed(0);
                     emailCell.setExtraInfo("手机与邮箱不能同时为空");
                 }
                 if(flag){  //验证通过的话
                     //初始化user 和 orgUser对象
                     user.setDefaultOrgId(orgId);
                     user.setMultiLogin(0);
                     user.setIsDistributor(0);
                     user.setSrcOrg(orgId);
                     user.setMobileBinded(0);
                     user.setEmailBinded(0);
                     user.setUtype(0);
                     user.setUpdateTime(updateTime);
                     user.setCreateTime(createTime);
                     user.setDel(Sys.UN_STOPED);
                     user.setType(2);
                     user.setSource(1);
                     user.setIspremiumuser(true);
                     //                    user.setNote("上传生成用户");
                     user.setPassword("123456");

                     orgUser.setOrgId(orgId);
                     //                    orgUser.setDeptId(deptId);
                     orgUser.setCreateTime(createTime);
                     orgUser.setUpdateTime(updateTime);
                     orgUser.setDel(Sys.UN_STOPED);
                     orgUser.setState(1);
                     orgUser.setIsDataCommissioner(0);
                     orgUser.setIsMarketCommissioner(0);
                     //向通过list里添加数据
                     passedUsers.add(user);  //添加到通过的  数据列表中去
                     passedOrgUsers.add(orgUser);
                     if(!StringUtil.isBlank(mobile)){
                         excelMobiles.add(mobile);  //添加到 准备的 list中去  以防下面重复数据   在上面验证
                     }
                     if(!StringUtil.isBlank(email)){
                         excelEmails.add(email);
                     }
                 } else {
                     offed.add(r);
                 }

             }
         }
         map.put("PASSED_USERS", passedUsers); //
         map.put("PASSED_ORGUSERS", passedOrgUsers);
         map.put("OFFED_ROW", offed);
         return map;
     }

==============================================================================================

//  辅助工具类：

 package com.SS.util;

 import com.SS.util.excel.CellData;
 import com.SS.util.excel.ExcelData;
 import com.SS.util.excel.RowData;
 import com.sun.image.codec.jpeg.JPEGCodec;
 import com.sun.image.codec.jpeg.JPEGEncodeParam;
 import com.sun.image.codec.jpeg.JPEGImageEncoder;
 import org.apache.log4j.Logger;
 import org.apache.poi.hssf.usermodel.HSSFCell;
 import org.apache.poi.hssf.usermodel.HSSFRow;
 import org.apache.poi.hssf.usermodel.HSSFSheet;
 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 import org.apache.poi.ss.usermodel.Cell;
 import org.apache.poi.xssf.usermodel.XSSFCell;
 import org.apache.poi.xssf.usermodel.XSSFRow;
 import org.apache.poi.xssf.usermodel.XSSFSheet;
 import org.apache.poi.xssf.usermodel.XSSFWorkbook;

 import javax.imageio.ImageIO;
 import java.awt.*;
 import java.awt.image.BufferedImage;
 import java.io.*;
 import java.util.ArrayList;
 import java.util.List;

 /**
  * 文件操作工具类
  */
 public class FileUtil {

     private Logger logger = Logger.getLogger(FileUtil.class);

     /**
      * 获取文件的后缀名称
      * @param file
      * @return
      */
     public static String getFileSuffix(File file){
         String suffix = "";
         if(null != file && StringUtil.isBlank(file.getName())){
             String fileName = file.getName();
             suffix = fileName.substring(fileName.lastIndexOf("."));
         }

         return suffix;
     }

     /**
      * 解析excel文件
      * @param file excel文件
      * @param startRow 起始行 0为第一行
      * @param columnKey  每列对应的key值
      * @return
      */
     public static ExcelData parseExcelFile(File file, int startRow, String[] columnKey){
         List<RowData> rows = null;
         ExcelData excelData = new ExcelData();
         try {
             if(null==file || !file.exists() || columnKey.length<1){
                 return excelData;
             }
             String fileName = file.getName();
             excelData.setFileName(fileName);
             if(fileName.endsWith("xls")){
                 rows = parse2003Excel(file, startRow, columnKey);
             } else if(fileName.endsWith("xlsx")){
                 rows = parse2007Excel(file, startRow, columnKey);
             } else {
                 throw new RuntimeException("Unknown file type : "+fileName);
             }
             excelData.setRows(rows);
         } catch (Exception e) {
             e.printStackTrace();
         }
         return excelData;
     }

     /**
      * 解析2003 excel文件
      * @param file excel文件
      * @param startRow 起始行 0为第一行  第一行已经有 头了
      * @param columnKey  每列对应的key值
      * @return
      */
     private static List<RowData> parse2003Excel(File file, int startRow, String[] columnKey){
         List<RowData> rows = new ArrayList<RowData>();
         try {
             String fileName = file.getName();
             BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));//获取输入流
             HSSFWorkbook wk = new HSSFWorkbook(bis); // poi提供的类   工作簿
             HSSFSheet sheet = wk.getSheetAt(0);//获取一片？  工作表
             HSSFCell cell = null;
             for(int rowIndex=startRow; rowIndex<=sheet.getLastRowNum(); rowIndex++){  //getLastRowNum 获取最后一行的行号
                 HSSFRow row = sheet.getRow(rowIndex);  //获取行数据
                 if(null==row){  //如果这行数据为空  继续
                     continue;
                 }
                 RowData rowData = new RowData(rowIndex+1);//起始是2  行数据存储对象初始化
                 List<CellData> cells = new ArrayList<CellData>();//  单元格s 对象存储对象初始化
                 for(int columnIndex=0; columnIndex<columnKey.length; columnIndex++){  // 列个数
                     String key = columnKey[columnIndex];
                     String cellValue = "";
                     cell = row.getCell(columnIndex); //获取独立单元格对象
                     if(null!=cell){
                         cell.setCellType(Cell.CELL_TYPE_STRING);//设置对象数据类型为String
                         cellValue = cell.getStringCellValue(); // 获取数据   是String 因为上面转换了
                     }
                     if(!StringUtil.isBlank(cellValue)){
                         cellValue = cellValue.trim(); //非空进行剪切
                     }
                     CellData cellData = new CellData(columnIndex+1, cellValue, key);//单元格数据对象实例化     参数有： 的列的位置   值   对应的列明
                     cells.add(cellData);  //添加到单元格s对象中去
                 }
                 rowData.setCells(cells);  // 行数据添加   cells  值
                 rows.add(rowData); // 行数据列表 添加 行数据
             }
             //关闭输入流
             bis.close();
         } catch (Exception e) {
             e.printStackTrace();
         }
         return rows;  //rows 可以说是 内存中的转化好的表格格式正确文件内容对象
     }

     /**
      * 解析2007 excel文件
      * @param file excel文件
      * @param startRow 起始行 0为第一行
      * @param columnKey  每列对应的key值
      * @return
      */
     private static List<RowData> parse2007Excel(File file, int startRow, String[] columnKey){
         List<RowData> rows = new ArrayList<RowData>();
         try {
             String fileName = file.getName();
             BufferedInputStream in = new BufferedInputStream(new FileInputStream(file));
             XSSFWorkbook wb = new XSSFWorkbook(in);
             XSSFSheet sheet = wb.getSheetAt(0);
             XSSFCell cell = null;
             for(int rowIndex=startRow; rowIndex<=sheet.getLastRowNum(); rowIndex++) {
                 XSSFRow row = sheet.getRow(rowIndex);
                 if(null==row){
                     continue;
                 }
                 RowData rowData = new RowData(rowIndex+1);
                 List<CellData> cells = new ArrayList<CellData>();
                 for(int columnIndex=0; columnIndex<columnKey.length; columnIndex++){
                     String key = columnKey[columnIndex];
                     String cellValue = "";
                     cell = row.getCell(columnIndex);
                     cell.setCellType(Cell.CELL_TYPE_STRING);
                     cellValue = cell.getStringCellValue();
                     if(!StringUtil.isBlank(cellValue)){
                         cellValue = cellValue.trim();
                     }

                     CellData cellData = new CellData(columnIndex+1, cellValue, key);
                     cells.add(cellData);
                 }
                 rowData.setCells(cells);
                 rows.add(rowData);
             }
             //关闭输入流
             in.close();
         } catch (Exception e) {
             e.printStackTrace();
         }
         return rows;
     }
 }

 public class Validator {

     /*public static void main(String[] args) {
         String mobile = "18412312313";
         String phone = "010-12312312";
         String username = "fdsdfsdj";
         System.out.println(Validator.isUsername(username));
         System.out.println(Validator.isChinese(username));

         String email = "zhangsan@163.com";
         System.out.println("isMobile="+Validator.isMobile(mobile));
         System.out.println("isPhone="+Validator.isPhone(phone));
         String regex = "^zo+$";
         String str = "zozo";
         boolean flag = Validator.testString(regex, str);
         System.out.println(flag);
     }

 */
     public static boolean testString(String regex, String str){
         return Pattern.matches(regex, str);
     }

     /**
      * 正则表达式：验证用户名
      */
     public static final String REGEX_USERNAME = "^[a-zA-Z]\\w{5,17}$";

     /**
      * 正则表达式：验证密码
      */
     public static final String REGEX_PASSWORD = "^[a-zA-Z0-9]{6,16}$";

     /**
      * 正则表达式：验证手机号
      */
     public static final String REGEX_MOBILE = "^((13[0-9])|(14[0-9])|(15[0-9])|(18[0-9])|(17[0-9]))\\d{8}$";

     /**
      * 正则表达式：验证固话
      */
     public static final String REGEX_PHONE = "^(0\\d{2}-\\d{8})|(0\\d{3}-\\d{7})|(0\\d{3}-\\d{8})$";

     /**
      * 正则表达式：验证qq
      */
     public static final String REGEX_QQ = "^[1-9][0-9]{4,} $";

     /**
      * 正则表达式：验证邮箱
      */
     public static final String REGEX_EMAIL = "^[A-Za-z0-9][\\w\\-\\.]{1,12}@([\\w\\\\-]+\\.)+[\\w]{2,3}$";

     /**
      * 正则表达式：验证汉字
      */
     public static final String REGEX_CHINESE = "^[\u4e00-\u9fa5],{0,}$";

     /**
      * 正则表达式：验证身份证
      */
     public static final String REGEX_ID_CARD = "(^\\d{18}$)|(^\\d{15}$)";

     /**
      * 正则表达式：验证URL
      */
 //    public static final String REGEX_URL = "http(s)?://([\\w-]+\\.)+[\\w-]+(/[\\w- ./?%&=]*)?";

     /**
      * 正则表达式：验证IP地址
      */
     public static final String REGEX_IP_ADDR = "(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)";

     /**
      * 校验用户名
      *
      * @param username
      * @return 校验通过返回true，否则返回false
      */
     public static boolean isUsername(String username) {
         return Pattern.matches(REGEX_USERNAME, username);
     }

     /**
      * 校验密码
      *
      * @param password
      * @return 校验通过返回true，否则返回false
      */
     public static boolean isPassword(String password) {
         return Pattern.matches(REGEX_PASSWORD, password);
     }

     /**
      * 校验手机号
      *
      * @param mobile
      * @return 校验通过返回true，否则返回false
      */
     public static boolean isMobile(String mobile) {
         return Pattern.matches(REGEX_MOBILE, mobile);
     }

     /**
      * 校验邮箱
      *
      * @param email
      * @return 校验通过返回true，否则返回false
      */
     public static boolean isEmail(String email) {
         return Pattern.matches(REGEX_EMAIL, email);
     }

     /**
      * 校验固话
      * @param phone
      * @return
      */
     public static boolean isPhone(String phone){
         return Pattern.matches(REGEX_PHONE, phone);
     }

     /**
      * 校验qq
      * @param qq
      * @return
      */
     public static boolean isQQ(String qq){
         return Pattern.matches(REGEX_QQ, qq);
     }

     /**
      * 校验汉字
      *
      * @param chinese
      * @return 校验通过返回true，否则返回false
      */
     public static boolean isChinese(String chinese) {
         return Pattern.matches(REGEX_CHINESE, chinese);
     }

     /**
      * 校验身份证
      *
      * @param idCard
      * @return 校验通过返回true，否则返回false
      */
     public static boolean isIDCard(String idCard) {
         return Pattern.matches(REGEX_ID_CARD, idCard);
     }

     /**
      * 校验URL
      *
      * @param url
      * @return 校验通过返回true，否则返回false
      */
 //    public static boolean isUrl(String url) {
 //        return Pattern.matches(REGEX_URL, url);
 //    }

     /**
      * 校验IP地址
      *
      * @param ipAddr
      * @return
      */
     public static boolean isIPAddr(String ipAddr) {
         return Pattern.matches(REGEX_IP_ADDR, ipAddr);
     }

 }

======================

下面是解析excle文档的  文档与内存对象的对应转换关系：

----ajax请求返回 后进行处理：

success: function (data, status) {//服务器成功响应处理函数
    $('#uploadTxt').text('导入');
    $('#loadingImg').hide();
    if('success'==data.flag){
        $('#btn_upSubmit').show();
        $('#uploading').hide();
        $('#btn_upCancel').trigger('click');
        $("#orgUserTable").trigger("reloadGrid", [{page: 1}]);
        var offedCount = data.OFFED_COUNT;
        var rowCount = data.ROW_COUNT;
        var offedData = data.OFFED_DATA;
        var orgLicense = data.ORG_LICENSE;
        var overLicense = data.OVER_LICENSE;
        var actSize = data.ORG_ACTSIZE;
        if(0<overLicense && 0!=orgLicense){//存在超出数据
            $('#licenseNum').text(orgLicense);
            $('#actNum').text(actSize);
            $('#uploadMsg1').hide();
            $('#uploadMsg2').show();
            //显示错误信息
            $('#showErrData').trigger('click');
        } else {
            if(0 != offedCount){
                $('#totalCount').text(rowCount);
                $('#errCount').text(offedCount);
                $('#uploadMsg2').hide();
                $('#uploadMsg1').show();
                $('#err_body').find('tr').remove();
                var errBody = $('#err_body');
                for(var i=0; i<offedData.length; i++){
                    var tr = createTrObj();
                    var rowData = offedData[i];
                    var rowIndex = rowData.rowIndex;
                    var cells = rowData.cells;
                    $(tr).find('td[role="rowIndex"]').text(rowIndex);
                    for(var j=0; j<cells.length; j++){
                        var cell = cells[j];
                        var cellValue = cell.cellValue;
                        var extraInfo = cell.extraInfo;
                        var td;
                        switch(cell.key){
                            case 'userName':
                                td = $(tr).find('td[role="name"]').text(cellValue);
                                break;
                            case 'mobile':
                                td = $(tr).find('td[role="mobile"]').text(cellValue);
                                break;
                            case 'phone':
                                td = $(tr).find('td[role="phone"]').text(cellValue);
                                break;
                            case 'email':
                                td = $(tr).find('td[role="email"]').text(cellValue);
                                break;
                            case 'QQ':
                                td = $(tr).find('td[role="QQ"]').text(cellValue);
                                break;
                            case 'weixin':
                                td = $(tr).find('td[role="weixin"]').text(cellValue);
                                break;
                            case 'job':
                                td = $(tr).find('td[role="position"]').text(cellValue);
                                break;
                            case 'note':
                                td = $(tr).find('td[role="note"]').text(cellValue);
                                break;
                            default:

                        }
                        if(null!=extraInfo && ''!=extraInfo && 'undefined'!=extraInfo){
                            td.attr('class','font-rb');
                            if('userName'==cell.key){
                                td.attr('class','bggray');
                            }
                            if(('mobile'==cell.key||'email'==cell.key) && ''==cellValue){
                                td.attr('class','bggray');
                            }
                            td.attr('title',extraInfo);
                        }
                    }
                    $(tr).appendTo(errBody);
                }
                //显示错误信息
                $('#showErrData').trigger('click');
            } else {
                swal({
                    title: "上传成功!",
                    //text: "点击下方按钮关闭提示框!",
                    type: "success"
                });
            }
        }

    }
},展示相关错误信息
文件内容为：

上传过程：

上传后返回：

结果为：

//  注明：  应博友提醒发现少了三个文件 源码  现补充

 

　　

 package com.SS.util.excel;

 import java.util.List;

 public class RowData {

     private int rowIndex;

     private List<CellData> cells;

     public RowData(){}

     public RowData(int index){
         this.rowIndex = index;
     }

     public int getRowIndex() {
         return rowIndex;
     }

     public void setRowIndex(int rowIndex) {
         this.rowIndex = rowIndex;
     }

     public List<CellData> getCells() {
         return cells;
     }

     public void setCells(List<CellData> cells) {
         this.cells = cells;
     }
 }

 package com.SS.util.excel;

 import java.util.List;

 /**

  */
 public class RowData {

     private int rowIndex;

     private List<CellData> cells;

     public RowData(){}

     public RowData(int index){
         this.rowIndex = index;
     }

     public int getRowIndex() {
         return rowIndex;
     }

     public void setRowIndex(int rowIndex) {
         this.rowIndex = rowIndex;
     }

     public List<CellData> getCells() {
         return cells;
     }

     public void setCells(List<CellData> cells) {
         this.cells = cells;
     }
 }

 package com.SS.util.excel;

 /**
  *
  * version 1.0
  */
 public class CellData {

     /**
      * 单元格列数
      */
     private int columnIndex;

     /**
      * 单元格数据
      */
     private String cellValue;

     /**
      * 附加信息
      */
     private String extraInfo;

     /**
      * 对应数据的key
      */
     private String key;

     /**
      * 是否通过校验
      * 1 通过
      * 0 未通过
      */
     private int passed=1;

     private boolean mobile = true;

     public CellData(){}

     public CellData(int index, String content, String dataKey){
         this.columnIndex = index;
         this.cellValue = content;
         this.key = dataKey;
     }

     public int getColumnIndex() {
         return columnIndex;
     }

     public void setColumnIndex(int columnIndex) {
         this.columnIndex = columnIndex;
     }

     public String getCellValue() {
         return cellValue;
     }

     public void setCellValue(String cellValue) {
         this.cellValue = cellValue;
     }

     public String getExtraInfo() {
         return extraInfo;
     }

     public void setExtraInfo(String extraInfo) {
         this.extraInfo = extraInfo;
     }

     public String getKey() {
         return key;
     }

     public void setKey(String key) {
         this.key = key;
     }

     public int getPassed() {
         return passed;
     }

     public void setPassed(int passed) {
         this.passed = passed;
     }
 }