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

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

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

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

 1   <div class="modal-body" style="position: relative;">
 2         <form class="" role="form" id="upload_form">
 3             <select class="form-control m-b" id="upload_dept" name="uploadDept">
 4             </select>
 5             <div class="input-group">
 6                 <input type="text" class="form-control input-sm" name="upload_filename">
 7                     <div class="input-group-btn">
 8                         <button type="button" class="btn btn-sm btn-primary">
 9                         浏览
10                         </button>
11                     </div>
12             </div>
13               <!--  选择上传文件按钮   type类型指定为 file   accept 可以在浏览过程中 进行过滤显示   支持多个用逗号隔开  -->
14                             <!-- 选择文件后显示文件名称  对更改事件绑定了事件监听器 selectUploadFile(this)   此框按钮id为: upload_file    -->
15                 <input type="file" id="upload_file" onchange="selectUploadFile(this)" name="uploadFile" accept=".xls,.xlsx" class="input-fzliulan">
16         </form>
17     </div>
18     <div class="modal-footer">
19         <button type="button" id="btn_upCancel" class="btn btn-white" data-dismiss="modal">关闭</button>
20         <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>
21     </div>

comm.jsp文件定义的变量:

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

页面js：

 1 $(function(){
 2     bindEvent();
 3 })
 4 /** 为页面按钮绑定事件
 5  */
 6 function bindEvent(){
 7     /**
 8      * 显示上传文件名称
 9      * @param fileObj
10      */
11     function selectUploadFile(fileObj){
12         var fullPath = $(fileObj).val();
13         var index = fullPath.lastIndexOf('\\') + 1;
14         var fileName = fullPath.substring(index);
15         $('input[name="upload_filename"]').val(fileName);
16     }
17 
18 
19 
20  $('#downLoadTemplate').click(function(){  //下载模板按钮的监听器   
21         var url = webContext + '/file\\template\\组织用户信息模板.xlsx';
22         downloadFile(url)
23     });
24 
25 /**
26  * 上传文件
27  */
28 
29   $('#btn_upSubmit').click(function(){
30      var valid = uploadValidator.checkForm(); //检测传单内容输入是否有问题
31         if(!valid){ 
32             uploadValidator.showErrors();
33         } else{ //检测成功
34             $('#uploadTxt').text('');  
35             $('#loadingImg').show();  //按钮换成动画效果图片
36 /** 准备参数： */
37             var orgId = loginUser.orgId;  //但钱用户的组织id   
38             var deptId = $('#upload_dept').val();  //  选框中选择的部门id
39             var password = hex_md5('123456');//  默认密码 进行加密 
40             var param = {orgId: orgId, deptId: deptId, password: password};  //ajax传输 携带json详细信息
41             var url = webContext + '/org/uploadOrgUser';  //   /** 使用ajaxFileUpload */
42     $.ajaxFileUpload({
43         url: url, //用于文件上传的服务器端请求地址
44         secureuri: false, //是否需要安全协议，一般设置为false
45         fileElementId: 'upload_file', //文件上传域的ID  就是选定文件的 type=file的input框的id  ajaxFileUpload 会帮我们把他分装到ajax请求的 携带对象域中去
46         dataType: 'json', //返回值类型 一般设置为json
47         type: 'post',
48         data: param,
49         success:function(){
50         //成功的success 回调方法等业务流程结束后再写
51         //先留已空白
52         }
53     })
54         }
55   })
56 }

项目使用SpringMVC ： 

其controller为:

 1 //-----------------------------------MVC 的控制器----------------------
 2 //Controller为：
 3 @Controller
 4 @RequestMapping("/org")
 5 public class OrgController extends BaseController {
 6 
 7     @Autowired
 8     private IOrgService orgService;
 9 
10     @RequestMapping("/uploadOrgUser")
11     @ResponseBody
12     public Map<String, Object> uploadOrgUser(HttpServletRequest request){
13         Map<String, Object> map = new HashMap<String, Object>();
14         String flag = "failure";
15         String msg = "上传成功";
16         MultipartHttpServletRequest mtRequest = (MultipartHttpServletRequest) request;//多部分httpRquest对象    是HttpServletRequest类的一个子类接口   支持文件分段上传对象
17         Integer orgId = RequestUtil.getIntParam(mtRequest, "orgId");  //组织id
18         Integer deptId = RequestUtil.getIntParam(mtRequest, "deptId"); //选取部门id
19         String password = RequestUtil.getStringParam(request, "password"); // 初始密码 已被md5加密
20         MultipartFile upFile = mtRequest.getFile("uploadFile"); // 直接获取文件对象
21         if(null == upFile || upFile.getSize()==0){   //文件不存在的情况
22             msg = "上传文件不存在或为空文件";
23             map.put("flag", flag);
24             map.put("msg", msg);
25             return map;  //返回错误信息
26         }
27         String targetPath = request.getServletContext().getRealPath("/file/upload"); //获取服务器 中file/update 的 url地址
28         map = orgService.uploadOrgUser(targetPath, orgId, deptId, password, upFile);  //调用实现类 返回 界面消息 对象
29         return map;
30     }
31 }

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

 1 public interface IOrgService {
 2     /**
 3      * @param targetPath
 4      * @param orgId
 5      * @param deptId
 6      * @param password
 7      * @param upFile
 8      * @return
 9      */
10     public Map<String, Object> uploadOrgUser(String targetPath, Integer orgId, Integer deptId, String password, MultipartFile upFile);
11 }

--业务层实现类：

  1 //业务层实现类：
  2 @Service("orgService")
  3 public class OrgServiceImpl extends BaseService implements IOrgService {
  4 
  5     @Autowired
  6     private IOrgDao orgDao;
  7 
  8     @Autowired
  9     private IUserDao userDao;
 10 
 11     @Autowired
 12     private IDeptDao deptDao;
 13 
 14     @Autowired
 15     private IOrgUserDao orgUserDao;
 16 
 17     @Autowired
 18     private IServiceAuthDao authDao;
 19 
 20     /**  批量导入 业务方法  **/
 21     public Map<String, Object> uploadOrgUser(String targetPath, Integer orgId, Integer deptId, String password, MultipartFile upFile) {
 22         Map<String,Object> rm = new HashMap<String,Object>();
 23         String flag ="failure";
 24         String msg = "上传失败";
 25         File f = new File(targetPath) //实例硬盘中文件夹（路径）对象 
 26         if(!f.exists()){//判断此路径/文件夹是否存在
 27             f.mkdirs(); //如果不存在  则创建文件夹/目录
 28         }
 29         String originalName = upFile.getOriginalFilename();//获取文件对象原始文件名
 30         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
 31         String tag = sdf.format(new Date());
 32         String upFileName = targetPath + File.separator+tag+"_"+originalName;// 拼接出文件的要存储的位置（全路径）
 33         File file = new File(upFileName);//创建 内存中的File对象
 34         if(file.exists()){ //判断是否存在
 35             file.delete();//如果有重名文件存在  就删除文件  
 36             // 这个对象对应的硬盘必须删  不能存在  如果已经存在 则会抛出
 37             // IOException异常
 38         }
 39         List<OrgUser> orgUsers = null;  
 40         List<User> users = null;
 41         List<RowData> offedData = null;  //List 集合对象准备
 42         try{
 43             upFile.transferTo(file);//转存文件  写入硬盘  //这个  本质还是一样的打开流传文件  需要注意 file对应的硬盘中的文件不能存在 需要删除  否则会抛出 文件已经存在且不能删除 异常
 44             // 校验上传数据
 45             /**  辅助方法一 **/
 46         Map<String,Object> validData = validUpload(file,orgId,deptId);// 校验数据    分类 返回 map形式
 47         users = (List<User>) validData.get("PASSED_USERS");  //通过的user  是向 m_user 表的 
 48         orgUsers = (List<OrgUser>) validData.get("PASSED_ORGUSERS"); //  是向 m_org_user 表的
 49         offedData = (List<RowData>) validData.get("OFFED_ROW");    //？
 50         int rowNum = (Integer) validData.get("DATA_SIZE");   //  excle 数据总长度
 51         rm.put("ROW_COUNT", rowNum);//业务类的总长度
 52       
 53         List<OrgUser> ous = orgUserDao.getOrgUsers(orgId);//获取组织的所有用户
 54         ServiceAuth sa = new ServiceAuth(); //权限对象
 55         sa.setOrgId(orgId);  //  设置组织id
 56         sa.setServiceCode(Sys.GROUP_ORG); //设置服务编码  多用户版基础服务
 57         sa.setType(Sys.TYPE_BUY); //设置 类型 为购买类型
 58         ServiceAuth nSa = authDao.getOrgServiceAuthInfo(sa); //获取组织服务等级 详细信息
 59         int actSize = ous.size(); // 当前组织已有用户的总长度
 60         int license = nSa.getLicense(); // 组织上限人数
 61         int totalNum = 0;  //设置总数为 0
 62         
 63         Org o = orgDao.getOrgById(orgId);  //获取组织对象
 64         Date duration = DateFormater.stringToDate(o.getDuration(), "yyyy-MM-dd"); //获取服务到期时间
 65         //上数据库插入数据
 66         if(null!=users && !users.isEmpty()){
 67             totalNum = actSize + users.size();  //总数现在等于 添加人数和已有人数
 68             if(totalNum < license){//上传人数和原有人数之和小于组织服务人数上限
 69                 for(int i=0; i<users.size(); i++){
 70                     User u = users.get(i);
 71                     u.setPassword(password);
 72                     OrgUser ou = orgUsers.get(i);
 73                     userDao.addUser(u);
 74                     //添加到微信企业号
 75                     addCpUser(u);
 76                     //添加个人空间
 77                     Org selfOrg = new Org();
 78                     selfOrg.setAdminName(u.getUserName());
 79                     selfOrg.setType(Sys.ORG_TYPE_PER);
 80                     selfOrg.setState(Sys.ORG_VERIFY_1);
 81                     selfOrg.setAdminId(u.getUserId());
 82                     selfOrg.setAdminName(u.getUserName());
 83                     selfOrg.setDuration(duration);
 84                     selfOrg.setDel(Sys.UN_STOPED);
 85                     selfOrg.setCreateTime(new Date());
 86                     selfOrg.setUpdateTime(new Date());
 87                     selfOrg.setIdparent(0);
 88                     orgDao.addOrg(selfOrg);
 89                     Dept d = new Dept();
 90                     d.setDeptId(0);
 91                     addOrgUserRelation(selfOrg, d, u);
 92                     if(null!=u.getUserId() && u.getUserName().equals(ou.getOrgUserName())){
 93                         ou.setUserId(u.getUserId());
 94                         orgUserDao.addOrgUser(ou);
 95                     }
 96                 }
 97                 rm.put("PASSED_COUNT", users.size());//成功数据
 98             } else {
 99                 rm.put("ORG_LICENSE", license);  //上限
100                 rm.put("ORG_ACTSIZE", actSize);  //  
101                 rm.put("OVER_LICENSE", totalNum - license);
102             }
103 
104         }
105         int offedCount = 0;
106         if(null!= offedData && !offedData.isEmpty()){ 
107             offedCount = offedData.size();
108             rm.put("OFFED_DATA", offedData);
109         }
110         rm.put("OFFED_COUNT", offedCount);
111 
112         flag = "success";
113         msg = "上传成功";
114         }  catch (Exception e2) {
115             logger.error("Exception while uploadOrgUser", e2);
116         }
117         rm.put("flag", flag);
118         rm.put("msg", msg);
119 
120         return rm;
121 
122     }
123 }

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

//辅助方法清单： 

 1  //*************************** 辅助方法一 *****************************************************************
 2     /**
 3      * 校验上传文件
 4      * 参数：文件对象
 5      *       组织id 
 6      *       部门id
 7      */
 8     private Map<String, Object> validUpload(File uploadFile, Integer orgId, Integer deptId) throws Exception{
 9         Map<String, Object> map = new HashMap<String, Object>();
10         List<User> passed = null;
11         List<User> offed = null;
12         List<String> mobileList = userDao.getAllActiveMobile();//为了防止已注册用户再次注册
13         List<String> emailList = userDao.getAllActiveEmail();//  现在还是查询出所有的     ------需要优化标记
14         //获取上传的excel中的数据
15         //******辅助方法二*********
16         ExcelData uploaddata = getUploadUserData(uploadFile);//获取内存中解析好的excle数据对象   
17         //校验上传数据
18         //******辅助方法三*********
19         Map<String, Object> dataMap = validUploadData(orgId, deptId, uploaddata, mobileList, emailList); //返回的是数据对象
20 
21         return dataMap;
22 }
  //*************************** 辅助方法二 *****************************************************************
    /**
     * 获取上传文件的数据
     * @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;
    }


}
  1   //*************************** 辅助方法三 *****************************************************************
  2     /**
  3      *   方法说明：  
  4      *              校验上传数据
  5      *
  6      *
  7      * @param orgId     其应该所属的组织
  8      * @param deptId    所选的部门id
  9      * @param excelData excel表格数据对象
 10      * @param mobiles   所有的手机号码 集合   用来判断手机是否注册
 11      * @param emails    所有的邮箱号码 集合
 12      * @return
 13      */
 14     private Map<String, Object> validUploadData(Integer orgId, Integer deptId,ExcelData excelData, List<String> mobiles, List<String> emails) {
 15         Map<String, Object> map = new HashMap<String, Object>();
 16         List<RowData> passed = new ArrayList<RowData>();
 17         List<User> passedUsers = new ArrayList<User>();  // 通过验证的  到 m_user
 18         List<OrgUser> passedOrgUsers = new ArrayList<OrgUser>(); //通过验证的   到m_org_user
 19         List<RowData> offed = new ArrayList<RowData>();
 20         List<RowData> rows = null;//  所有数据
 21         Date createTime = new Date();//创建时间
 22         Date updateTime = new Date();  //更新时间
 23         List<Dept> deptList = null;  //当前组织的所有部门的   list集合
 24         Map<String, Dept> deptMap = new HashMap<String, Dept>();
 25         if(null != excelData && null != excelData.getRows() && !excelData.getRows().isEmpty()){  //如果传入对象不为空
 26             rows = excelData.getRows();  //获取对象中的所有数据   类型应该是List集合 每个元素应该是一行数据 即：RowData
 27             map.put("DATA_SIZE", rows.size());// 设置总数据有多少条
 28             List<String> excelMobiles = new ArrayList<String>();  //用于存放excle表格中的电话号码
 29             List<String> excelEmails = new ArrayList<String>(); //用于存放excle表格中的邮箱号码
 30             deptList = deptDao.getDeptsByOrgId(orgId);//获取所有部门？
 31             for(Dept dept:deptList){
 32                 String deptName = dept.getDeptName();
 33                 deptMap.put(deptName, dept);//转成map了
 34             }
 35 rowloop:     //行循环跳出坐标准备
 36             for (int i = 0; i < rows.size(); i++) {//循环便利数据
 37                 OrgUser orgUser = new OrgUser();  //组织用户 实例化对象准备
 38                 User user = new User();  //用户 POJO准备
 39                 //获取行数据
 40                 RowData r = rows.get(i);  //  获取行数据
 41                 int rowIndex = r.getRowIndex();  //  获取当前行是第几行
 42                 List<CellData> cells = r.getCells();  //获取当前行的所有数据  cell 的s  
 43                 boolean flag = true;
 44                 String userName="",mobile="",phone="",email="",qq="",weixin="",job="";
 45                 int mIndex = 0;
 46                 int eIndex = 0;
 47 columnloop: //列循环跳出坐标准备
 48                 for (int j = 0; j < cells.size(); j++) {  // 每一行单元格数据 遍历
 49                     CellData c = cells.get(j);  //获取出当前的 数据独立单元格  
 50                     String key = c.getKey();  //属于哪一列？
 51                     String cellValue = c.getCellValue(); //值 
 52                     if("userName".equals(key)){
 53                         userName = cellValue;
 54                         if(StringUtil.isBlank(cellValue)){
 55                             flag = false;
 56                             c.setPassed(0);
 57                             c.setExtraInfo("用户姓名不能为空");
 58                             continue columnloop;
 59                         }
 60                         user.setUserName(cellValue);
 61                         orgUser.setOrgUserName(cellValue);
 62                     } else if("mobile".equals(key)){  //手机相关验证
 63                         mIndex = j;
 64                         mobile = cellValue;
 65                         if(!StringUtil.isBlank(cellValue)){
 66                             if(!Validator.isMobile(cellValue)){ //校验手机格式
 67                                 flag = false;
 68                                 c.setPassed(0);
 69                                 c.setExtraInfo("不正确的手机号");
 70                                 continue columnloop;
 71                             }
 72 
 73                             if(mobiles.contains(cellValue.trim())){// 比对数据库中的  是否已被注册
 74                                 flag = false;
 75                                 c.setPassed(0);
 76                                 c.setExtraInfo("该手机号已经被使用");
 77                                 continue columnloop;
 78                             }
 79                             if(excelMobiles.contains(cellValue.trim())){ // 当前表格 数据有重复
 80                                 flag = false;
 81                                 c.setPassed(0);
 82                                 c.setExtraInfo("重复的手机号码");
 83                                 continue columnloop;
 84                             }
 85                             user.setLoginName(cellValue);
 86                         }
 87                         user.setMobile(cellValue);
 88                     } else if("phone".equals(key)){ //暂无
 89                         phone = cellValue;
 90                         if(!StringUtil.isBlank(cellValue)){
 91                             //                            if(!Validator.isPhone(cellValue)){
 92                             //                                flag = false;
 93                             //                                c.setPassed(0);
 94                             //                                c.setExtraInfo("不正确的电话号");
 95                             //                                continue columnloop;
 96                             //                            }
 97                         }
 98                         user.setPhone(cellValue);
 99                     } else if("email".equals(key)){  // 邮箱相关验证
100                         eIndex = j;
101                         email = cellValue;
102                         if(!StringUtil.isBlank(cellValue)){
103                             if(!Validator.isEmail(cellValue)){
104                                 flag = false;
105                                 c.setPassed(0);
106                                 c.setExtraInfo("邮箱格式不正确");
107                                 continue columnloop;
108                             }
109                             if(emails.contains(cellValue.trim())){
110                                 flag = false;
111                                 c.setPassed(0);
112                                 c.setExtraInfo("该邮箱已经被使用");
113                                 continue columnloop;
114                             }
115                             if(excelMobiles.contains(cellValue.trim())){
116                                 flag = false;
117                                 c.setPassed(0);
118                                 c.setExtraInfo("重复的邮箱");
119                                 continue columnloop;
120                             }
121                             user.setLoginName(cellValue);
122                         }
123                         user.setEmail(cellValue);
124                     } else if("QQ".equals(key)){
125                         qq = cellValue;
126                         user.setQq(cellValue);
127                     } else if("weixin".equals(key)){
128                         weixin = cellValue;
129                         user.setWeixin(cellValue);
130                     } else if("job".equals(key)){
131                         job = cellValue;
132                         orgUser.setPosition(cellValue);
133                         //暂无
134                     } else if("note".equals(key)){
135                         user.setNote(cellValue);
136                     } else if("dept".equals(key)) {
137                         if(!StringUtil.isBlank(cellValue) && null!=deptMap.get(cellValue.trim())){
138                             Dept d = deptMap.get(cellValue.trim());
139                             orgUser.setDeptId(d.getDeptId());
140                         } else {
141                             orgUser.setDeptId(deptId);
142                         }
143                     } else {
144                         //暂无
145                     }
146                 }
147                 //校验手机与邮箱是否同时为空
148                 if(StringUtil.isBlank(mobile) && StringUtil.isBlank(email)){
149                     flag = false;
150                     CellData mobileCell = cells.get(mIndex);//所属的 行和列
151                     CellData emailCell = cells.get(eIndex);
152                     mobileCell.setPassed(0);  //设置是否通过了校验的标识   注：此标识是对单元格数据进行设置的 
153                     mobileCell.setExtraInfo("手机与邮箱不能同时为空"); //没有通过校验  进行
154                     emailCell.setPassed(0);
155                     emailCell.setExtraInfo("手机与邮箱不能同时为空");
156                 }
157                 if(flag){  //验证通过的话
158                     //初始化user 和 orgUser对象
159                     user.setDefaultOrgId(orgId);
160                     user.setMultiLogin(0);
161                     user.setIsDistributor(0);
162                     user.setSrcOrg(orgId);
163                     user.setMobileBinded(0);
164                     user.setEmailBinded(0);
165                     user.setUtype(0);
166                     user.setUpdateTime(updateTime);
167                     user.setCreateTime(createTime);
168                     user.setDel(Sys.UN_STOPED);
169                     user.setType(2);
170                     user.setSource(1);
171                     user.setIspremiumuser(true);
172                     //                    user.setNote("上传生成用户");
173                     user.setPassword("123456");
174 
175                     orgUser.setOrgId(orgId);
176                     //                    orgUser.setDeptId(deptId);
177                     orgUser.setCreateTime(createTime);
178                     orgUser.setUpdateTime(updateTime);
179                     orgUser.setDel(Sys.UN_STOPED);
180                     orgUser.setState(1);
181                     orgUser.setIsDataCommissioner(0);
182                     orgUser.setIsMarketCommissioner(0);
183                     //向通过list里添加数据
184                     passedUsers.add(user);  //添加到通过的  数据列表中去
185                     passedOrgUsers.add(orgUser);
186                     if(!StringUtil.isBlank(mobile)){
187                         excelMobiles.add(mobile);  //添加到 准备的 list中去  以防下面重复数据   在上面验证
188                     }
189                     if(!StringUtil.isBlank(email)){
190                         excelEmails.add(email);
191                     }
192                 } else {
193                     offed.add(r);
194                 }
195 
196             }
197         }
198         map.put("PASSED_USERS", passedUsers); //
199         map.put("PASSED_ORGUSERS", passedOrgUsers);
200         map.put("OFFED_ROW", offed);
201         return map;
202     }

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

//  辅助工具类：

  1 package com.SS.util;
  2 
  3 import com.SS.util.excel.CellData;
  4 import com.SS.util.excel.ExcelData;
  5 import com.SS.util.excel.RowData;
  6 import com.sun.image.codec.jpeg.JPEGCodec;
  7 import com.sun.image.codec.jpeg.JPEGEncodeParam;
  8 import com.sun.image.codec.jpeg.JPEGImageEncoder;
  9 import org.apache.log4j.Logger;
 10 import org.apache.poi.hssf.usermodel.HSSFCell;
 11 import org.apache.poi.hssf.usermodel.HSSFRow;
 12 import org.apache.poi.hssf.usermodel.HSSFSheet;
 13 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 14 import org.apache.poi.ss.usermodel.Cell;
 15 import org.apache.poi.xssf.usermodel.XSSFCell;
 16 import org.apache.poi.xssf.usermodel.XSSFRow;
 17 import org.apache.poi.xssf.usermodel.XSSFSheet;
 18 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
 19 
 20 import javax.imageio.ImageIO;
 21 import java.awt.*;
 22 import java.awt.image.BufferedImage;
 23 import java.io.*;
 24 import java.util.ArrayList;
 25 import java.util.List;
 26 
 27 /**
 28  * 文件操作工具类
 29  */
 30 public class FileUtil {
 31 
 32     private Logger logger = Logger.getLogger(FileUtil.class);
 33 
 34     /**
 35      * 获取文件的后缀名称
 36      * @param file
 37      * @return
 38      */
 39     public static String getFileSuffix(File file){
 40         String suffix = "";
 41         if(null != file && StringUtil.isBlank(file.getName())){
 42             String fileName = file.getName();
 43             suffix = fileName.substring(fileName.lastIndexOf("."));
 44         }
 45 
 46         return suffix;
 47     }
 48 
 49     /**
 50      * 解析excel文件
 51      * @param file excel文件
 52      * @param startRow 起始行 0为第一行
 53      * @param columnKey  每列对应的key值
 54      * @return
 55      */
 56     public static ExcelData parseExcelFile(File file, int startRow, String[] columnKey){
 57         List<RowData> rows = null;
 58         ExcelData excelData = new ExcelData();
 59         try {
 60             if(null==file || !file.exists() || columnKey.length<1){
 61                 return excelData;
 62             }
 63             String fileName = file.getName();
 64             excelData.setFileName(fileName);
 65             if(fileName.endsWith("xls")){
 66                 rows = parse2003Excel(file, startRow, columnKey);
 67             } else if(fileName.endsWith("xlsx")){
 68                 rows = parse2007Excel(file, startRow, columnKey);
 69             } else {
 70                 throw new RuntimeException("Unknown file type : "+fileName);
 71             }
 72             excelData.setRows(rows);
 73         } catch (Exception e) {
 74             e.printStackTrace();
 75         }
 76         return excelData;
 77     }
 78 
 79     /**
 80      * 解析2003 excel文件
 81      * @param file excel文件
 82      * @param startRow 起始行 0为第一行  第一行已经有 头了
 83      * @param columnKey  每列对应的key值
 84      * @return
 85      */
 86     private static List<RowData> parse2003Excel(File file, int startRow, String[] columnKey){
 87         List<RowData> rows = new ArrayList<RowData>();
 88         try {
 89             String fileName = file.getName();
 90             BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));//获取输入流
 91             HSSFWorkbook wk = new HSSFWorkbook(bis); // poi提供的类   工作簿
 92             HSSFSheet sheet = wk.getSheetAt(0);//获取一片？  工作表
 93             HSSFCell cell = null;
 94             for(int rowIndex=startRow; rowIndex<=sheet.getLastRowNum(); rowIndex++){  //getLastRowNum 获取最后一行的行号
 95                 HSSFRow row = sheet.getRow(rowIndex);  //获取行数据     
 96                 if(null==row){  //如果这行数据为空  继续
 97                     continue;
 98                 }
 99                 RowData rowData = new RowData(rowIndex+1);//起始是2  行数据存储对象初始化  
100                 List<CellData> cells = new ArrayList<CellData>();//  单元格s 对象存储对象初始化
101                 for(int columnIndex=0; columnIndex<columnKey.length; columnIndex++){  // 列个数
102                     String key = columnKey[columnIndex]; 
103                     String cellValue = "";
104                     cell = row.getCell(columnIndex); //获取独立单元格对象
105                     if(null!=cell){
106                         cell.setCellType(Cell.CELL_TYPE_STRING);//设置对象数据类型为String
107                         cellValue = cell.getStringCellValue(); // 获取数据   是String 因为上面转换了
108                     }
109                     if(!StringUtil.isBlank(cellValue)){
110                         cellValue = cellValue.trim(); //非空进行剪切
111                     }
112                     CellData cellData = new CellData(columnIndex+1, cellValue, key);//单元格数据对象实例化     参数有： 的列的位置   值   对应的列明  
113                     cells.add(cellData);  //添加到单元格s对象中去
114                 }
115                 rowData.setCells(cells);  // 行数据添加   cells  值
116                 rows.add(rowData); // 行数据列表 添加 行数据 
117             }
118             //关闭输入流
119             bis.close();
120         } catch (Exception e) {
121             e.printStackTrace();
122         }
123         return rows;  //rows 可以说是 内存中的转化好的表格格式正确文件内容对象 
124     }
125 
126     /**
127      * 解析2007 excel文件
128      * @param file excel文件
129      * @param startRow 起始行 0为第一行
130      * @param columnKey  每列对应的key值
131      * @return
132      */
133     private static List<RowData> parse2007Excel(File file, int startRow, String[] columnKey){
134         List<RowData> rows = new ArrayList<RowData>();
135         try {
136             String fileName = file.getName();
137             BufferedInputStream in = new BufferedInputStream(new FileInputStream(file));
138             XSSFWorkbook wb = new XSSFWorkbook(in);
139             XSSFSheet sheet = wb.getSheetAt(0);
140             XSSFCell cell = null;
141             for(int rowIndex=startRow; rowIndex<=sheet.getLastRowNum(); rowIndex++) {
142                 XSSFRow row = sheet.getRow(rowIndex);
143                 if(null==row){
144                     continue;
145                 }
146                 RowData rowData = new RowData(rowIndex+1);
147                 List<CellData> cells = new ArrayList<CellData>();
148                 for(int columnIndex=0; columnIndex<columnKey.length; columnIndex++){
149                     String key = columnKey[columnIndex];
150                     String cellValue = "";
151                     cell = row.getCell(columnIndex);
152                     cell.setCellType(Cell.CELL_TYPE_STRING);
153                     cellValue = cell.getStringCellValue();
154                     if(!StringUtil.isBlank(cellValue)){
155                         cellValue = cellValue.trim();
156                     }
157 
158                     CellData cellData = new CellData(columnIndex+1, cellValue, key);
159                     cells.add(cellData);
160                 }
161                 rowData.setCells(cells);
162                 rows.add(rowData);
163             }
164             //关闭输入流
165             in.close();
166         } catch (Exception e) {
167             e.printStackTrace();
168         }
169         return rows;
170     }
171 }
  1 public class Validator {
  2 
  3 
  4     /*public static void main(String[] args) {
  5         String mobile = "18412312313";
  6         String phone = "010-12312312";
  7         String username = "fdsdfsdj";
  8         System.out.println(Validator.isUsername(username));
  9         System.out.println(Validator.isChinese(username));
 10 
 11         String email = "zhangsan@163.com";
 12         System.out.println("isMobile="+Validator.isMobile(mobile));
 13         System.out.println("isPhone="+Validator.isPhone(phone));
 14         String regex = "^zo+$";
 15         String str = "zozo";
 16         boolean flag = Validator.testString(regex, str);
 17         System.out.println(flag);
 18     }
 19 
 20 */
 21     public static boolean testString(String regex, String str){
 22         return Pattern.matches(regex, str);
 23     }
 24 
 25 
 26     /**
 27      * 正则表达式：验证用户名
 28      */
 29     public static final String REGEX_USERNAME = "^[a-zA-Z]\\w{5,17}$";
 30 
 31     /**
 32      * 正则表达式：验证密码
 33      */
 34     public static final String REGEX_PASSWORD = "^[a-zA-Z0-9]{6,16}$";
 35 
 36     /**
 37      * 正则表达式：验证手机号
 38      */
 39     public static final String REGEX_MOBILE = "^((13[0-9])|(14[0-9])|(15[0-9])|(18[0-9])|(17[0-9]))\\d{8}$";
 40 
 41     /**
 42      * 正则表达式：验证固话
 43      */
 44     public static final String REGEX_PHONE = "^(0\\d{2}-\\d{8})|(0\\d{3}-\\d{7})|(0\\d{3}-\\d{8})$";
 45 
 46     /**
 47      * 正则表达式：验证qq
 48      */
 49     public static final String REGEX_QQ = "^[1-9][0-9]{4,} $";
 50 
 51     /**
 52      * 正则表达式：验证邮箱
 53      */
 54     public static final String REGEX_EMAIL = "^[A-Za-z0-9][\\w\\-\\.]{1,12}@([\\w\\\\-]+\\.)+[\\w]{2,3}$";
 55 
 56     /**
 57      * 正则表达式：验证汉字
 58      */
 59     public static final String REGEX_CHINESE = "^[\u4e00-\u9fa5],{0,}$";
 60 
 61     /**
 62      * 正则表达式：验证身份证
 63      */
 64     public static final String REGEX_ID_CARD = "(^\\d{18}$)|(^\\d{15}$)";
 65 
 66     /**
 67      * 正则表达式：验证URL
 68      */
 69 //    public static final String REGEX_URL = "http(s)?://([\\w-]+\\.)+[\\w-]+(/[\\w- ./?%&=]*)?";
 70 
 71     /**
 72      * 正则表达式：验证IP地址
 73      */
 74     public static final String REGEX_IP_ADDR = "(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)";
 75 
 76     /**
 77      * 校验用户名
 78      *
 79      * @param username
 80      * @return 校验通过返回true，否则返回false
 81      */
 82     public static boolean isUsername(String username) {
 83         return Pattern.matches(REGEX_USERNAME, username);
 84     }
 85 
 86     /**
 87      * 校验密码
 88      *
 89      * @param password
 90      * @return 校验通过返回true，否则返回false
 91      */
 92     public static boolean isPassword(String password) {
 93         return Pattern.matches(REGEX_PASSWORD, password);
 94     }
 95 
 96     /**
 97      * 校验手机号
 98      *
 99      * @param mobile
100      * @return 校验通过返回true，否则返回false
101      */
102     public static boolean isMobile(String mobile) {
103         return Pattern.matches(REGEX_MOBILE, mobile);
104     }
105 
106     /**
107      * 校验邮箱
108      *
109      * @param email
110      * @return 校验通过返回true，否则返回false
111      */
112     public static boolean isEmail(String email) {
113         return Pattern.matches(REGEX_EMAIL, email);
114     }
115 
116     /**
117      * 校验固话
118      * @param phone
119      * @return
120      */
121     public static boolean isPhone(String phone){
122         return Pattern.matches(REGEX_PHONE, phone);
123     }
124 
125     /**
126      * 校验qq
127      * @param qq
128      * @return
129      */
130     public static boolean isQQ(String qq){
131         return Pattern.matches(REGEX_QQ, qq);
132     }
133 
134     /**
135      * 校验汉字
136      *
137      * @param chinese
138      * @return 校验通过返回true，否则返回false
139      */
140     public static boolean isChinese(String chinese) {
141         return Pattern.matches(REGEX_CHINESE, chinese);
142     }
143 
144     /**
145      * 校验身份证
146      *
147      * @param idCard
148      * @return 校验通过返回true，否则返回false
149      */
150     public static boolean isIDCard(String idCard) {
151         return Pattern.matches(REGEX_ID_CARD, idCard);
152     }
153 
154     /**
155      * 校验URL
156      *
157      * @param url
158      * @return 校验通过返回true，否则返回false
159      */
160 //    public static boolean isUrl(String url) {
161 //        return Pattern.matches(REGEX_URL, url);
162 //    }
163 
164     /**
165      * 校验IP地址
166      *
167      * @param ipAddr
168      * @return
169      */
170     public static boolean isIPAddr(String ipAddr) {
171         return Pattern.matches(REGEX_IP_ADDR, ipAddr);
172     }
173 
174 
175 
176 }

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

下面是解析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"
                });
            }
        }

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

上传过程：



上传后返回：


结果为：


 


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


 


　　




 1 package com.SS.util.excel;
 2 
 3 import java.util.List;
 4 
 5 
 6 public class RowData {
 7 
 8     private int rowIndex;
 9 
10     private List<CellData> cells;
11 
12     public RowData(){}
13 
14     public RowData(int index){
15         this.rowIndex = index;
16     }
17 
18     public int getRowIndex() {
19         return rowIndex;
20     }
21 
22     public void setRowIndex(int rowIndex) {
23         this.rowIndex = rowIndex;
24     }
25 
26     public List<CellData> getCells() {
27         return cells;
28     }
29 
30     public void setCells(List<CellData> cells) {
31         this.cells = cells;
32     }
33 }




 




 1 package com.SS.util.excel;
 2 
 3 import java.util.List;
 4 
 5 /**
 6 
 7  */
 8 public class RowData {
 9 
10     private int rowIndex;
11 
12     private List<CellData> cells;
13 
14     public RowData(){}
15 
16     public RowData(int index){
17         this.rowIndex = index;
18     }
19 
20     public int getRowIndex() {
21         return rowIndex;
22     }
23 
24     public void setRowIndex(int rowIndex) {
25         this.rowIndex = rowIndex;
26     }
27 
28     public List<CellData> getCells() {
29         return cells;
30     }
31 
32     public void setCells(List<CellData> cells) {
33         this.cells = cells;
34     }
35 }






 1 package com.SS.util.excel;
 2 
 3 /**
 4  *
 5  * version 1.0
 6  */
 7 public class CellData {
 8 
 9     /**
10      * 单元格列数
11      */
12     private int columnIndex;
13 
14     /**
15      * 单元格数据
16      */
17     private String cellValue;
18 
19     /**
20      * 附加信息
21      */
22     private String extraInfo;
23 
24     /**
25      * 对应数据的key
26      */
27     private String key;
28 
29     /**
30      * 是否通过校验
31      * 1 通过
32      * 0 未通过
33      */
34     private int passed=1;
35 
36     private boolean mobile = true;
37 
38 
39     public CellData(){}
40 
41     public CellData(int index, String content, String dataKey){
42         this.columnIndex = index;
43         this.cellValue = content;
44         this.key = dataKey;
45     }
46 
47 
48     public int getColumnIndex() {
49         return columnIndex;
50     }
51 
52     public void setColumnIndex(int columnIndex) {
53         this.columnIndex = columnIndex;
54     }
55 
56     public String getCellValue() {
57         return cellValue;
58     }
59 
60     public void setCellValue(String cellValue) {
61         this.cellValue = cellValue;
62     }
63 
64     public String getExtraInfo() {
65         return extraInfo;
66     }
67 
68     public void setExtraInfo(String extraInfo) {
69         this.extraInfo = extraInfo;
70     }
71 
72     public String getKey() {
73         return key;
74     }
75 
76     public void setKey(String key) {
77         this.key = key;
78     }
79 
80     public int getPassed() {
81         return passed;
82     }
83 
84     public void setPassed(int passed) {
85         this.passed = passed;
86     }
87 }




 







            

            
posted @ 
2016-05-16 17:58 
Seven_OverLoad 
阅读(4095) 
评论(0) 
编辑 
收藏 
举报