Java web项目从eclipse上移动到tomact服务器上，之路径更改，读取excel，把数据存到数据库

<form action="${pageContext.request.contextPath}/UploadUsingExcelServlet" method="post" enctype="multipart/form-data">
        上传excel<input type="file" name="file1">
         <input type="submit" value="提交">
        </form>
        
//显示数据插入数据库之后的结果的，后台返回一个jsonObject，然后在这里只把失败的显示出来
        <div class="page">
            <div class="conShow" id="res"></div>
            <c:forEach items="${sessionScope.usingexcel.sy}" var="u">
            <c:if test="${u.res==0}">
                <span style="color:red">${u.pronum}>>${u.id}失败</span><br>
            </c:if>
           
            </c:forEach>
            
            <c:remove var="usingexcel" scope="session"/>
        </div>

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //得到上传文件的保存目录，将上传的文件存放于WEB-INF目录下，不允许外界直接访问，保证上传文件的安全
        HttpSession session =request.getSession();
        String fileString = "";
        String savePath = this.getServletContext().getRealPath("/WEB-INF/upload");
         //上传时生成的临时文件保存目录
         String tempPath = this.getServletContext().getRealPath("/WEB-INF/temp");
         File tmpFile = new File(tempPath);
         if (!tmpFile.exists()) {
          //创建临时目录
          tmpFile.mkdir();
         }
         log.info(savePath);
        // System.out.println(tempPath);
         //消息提示
         String message = "";
         try{
          //使用Apache文件上传组件处理文件上传步骤：
          //1、创建一个DiskFileItemFactory工厂
          DiskFileItemFactory factory = new DiskFileItemFactory();
          //设置工厂的缓冲区的大小，当上传的文件大小超过缓冲区的大小时，就会生成一个临时文件存放到指定的临时目录当中。
          factory.setSizeThreshold(1024*100);//设置缓冲区的大小为100KB，如果不指定，那么缓冲区的大小默认是10KB
          //设置上传时生成的临时文件的保存目录
          factory.setRepository(tmpFile);
          //2、创建一个文件上传解析器
          ServletFileUpload upload = new ServletFileUpload(factory);
          //监听文件上传进度
          upload.setProgressListener(new ProgressListener(){
           public void update(long pBytesRead, long pContentLength, int arg2) {
               log.info("文件大小为：" + pContentLength + ",当前已处理：" + pBytesRead);
            /**
            * 文件大小为：14608,当前已处理：4096
             文件大小为：14608,当前已处理：7367
             文件大小为：14608,当前已处理：11419
             文件大小为：14608,当前已处理：14608
            */
           }
          });
          //解决上传文件名的中文乱码
          upload.setHeaderEncoding("UTF-8"); 
          //3、判断提交上来的数据是否是上传表单的数据
          if(!ServletFileUpload.isMultipartContent(request)){
           //按照传统方式获取数据
           return;
          }
           
          //设置上传单个文件的大小的最大值，目前是设置为1024*1024字节，也就是1MB
          upload.setFileSizeMax(1024*1024);
          //设置上传文件总量的最大值，最大值=同时上传的多个文件的大小的最大值的和，目前设置为10MB
          upload.setSizeMax(1024*1024*10);
          //4、使用ServletFileUpload解析器解析上传数据，解析结果返回的是一个List<FileItem>集合，每一个FileItem对应一个Form表单的输入项
          List<FileItem> list = upload.parseRequest(request);
          for(FileItem item : list){
           //如果fileitem中封装的是普通输入项的数据
           if(item.isFormField()){
            String name = item.getFieldName();
            //解决普通输入项的数据的中文乱码问题
            String value = item.getString("UTF-8");
            //value = new String(value.getBytes("iso8859-1"),"UTF-8");
            log.info(name + "=" + value);
           }else{//如果fileitem中封装的是上传文件
            //得到上传的文件名称，
            String filename = item.getName();
            log.info(filename);
            if(filename==null || filename.trim().equals("")){
             continue;
            }
            //注意：不同的浏览器提交的文件名是不一样的，有些浏览器提交上来的文件名是带有路径的，如： c:\a\b\1.txt，而有些只是单纯的文件名，如：1.txt
            //处理获取到的上传文件的文件名的路径部分，只保留文件名部分
            filename = filename.substring(filename.lastIndexOf("\\")+1);
            //得到上传文件的扩展名
            String fileExtName = filename.substring(filename.lastIndexOf(".")+1);
            //如果需要限制上传的文件类型，那么可以通过文件的扩展名来判断上传的文件类型是否合法
            log.info("上传的文件的扩展名是："+fileExtName);
            //获取item中的上传文件的输入流
            InputStream in = item.getInputStream();
            //得到文件保存的名称
            String saveFilename = makeFileName(filename);
            //得到文件的保存目录
            String realSavePath = makePath(saveFilename, savePath);
            //创建一个文件输出流
            FileOutputStream out = new FileOutputStream(realSavePath + "\\" + saveFilename);
            fileString = realSavePath + "\\" + saveFilename;
           //创建一个缓冲区
            byte buffer[] = new byte[1024];
            //判断输入流中的数据是否已经读完的标识      
            int len = 0;
            //循环将输入流读入到缓冲区当中，(len=in.read(buffer))>0就表示in里面还有数据
            while((len=in.read(buffer))>0){
             //使用FileOutputStream输出流将缓冲区的数据写入到指定的目录(savePath + "\\" + filename)当中
             out.write(buffer, 0, len);
            }
            //关闭输入流
            in.close();
            //关闭输出流
            out.close();        //删除处理文件上传时生成的临时文件        //item.delete();        message = "文件上传成功！";
           }
          }
         }catch (FileUploadBase.FileSizeLimitExceededException e) {
          e.printStackTrace();
          session.setAttribute("flag", "单个文件超出最大值！！！"); 
          request.getRequestDispatcher("muju/usingexcel.jsp").forward(request, response);
          return;
         }catch (FileUploadBase.SizeLimitExceededException e) {
          e.printStackTrace();
          session.setAttribute("flag", "上传文件的总的大小超出限制的最大值！！！");
          request.getRequestDispatcher("muju/usingexcel.jsp").forward(request, response);
          return;
         }catch (Exception e) {
          message= "文件上传失败！";
          session.setAttribute("flag",message);
          e.printStackTrace();
         }
       //  session.setAttribute("flag",message);
        // System.out.println(fileString);
       //  request.getRequestDispatcher("UsingExcelServlet?filename="+fileString).forward(request, response);
        // response.setCharacterEncoding("utf-8");
         response.sendRedirect("UsingExcelServlet?filename="+fileString);//读取excel的servlet
    }


/**
 * @Description: 生成上传文件的文件名，文件名以：uuid+"_"+文件的原始名称
 * @param filename 文件的原始名称
 * @return uuid+"_"+文件的原始名称
 */
 private String makeFileName(String filename){ //2.jpg
  //为防止文件覆盖的现象发生，要为上传文件产生一个唯一的文件名
  return UUID.randomUUID().toString() + "_" + filename;
 }  
 /**
 * 为防止一个目录下面出现太多文件，要使用hash算法打散存储
 *
 * @param filename 文件名，要根据文件名生成存储目录
 * @param savePath 文件存储路径
 * @return 新的存储目录
 */
private String makePath(String filename,String savePath){
  //得到文件名的hashCode的值，得到的就是filename这个字符串对象在内存中的地址
  int hashcode = filename.hashCode();
  int dir1 = hashcode&0xf; //0--15
  int dir2 = (hashcode&0xf0)>>4; //0-15
  //构造新的保存目录
  String dir = savePath + "\\" + dir1 + "\\" + dir2; //upload\2\3 upload\3\5
  //File既可以代表文件也可以代表目录  
  File file = new File(dir);
 //如果目录不存在
  if(!file.exists()){
   //创建目录
   file.mkdirs();
 }
  return dir;
}

package com.rfx.servlet;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import jxl.Cell;
import jxl.Sheet;
import jxl.Workbook;

public class ReadUsingExcel {
    public static List<Map<String, String>> readExcel(File file) {
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
        try {
            // 判断文件是否存在
            // 创建工作簿
            Workbook workbook = Workbook.getWorkbook(file);
            // 获得第一个工作表sheet1
            Sheet sheet = workbook.getSheet(0);
            // 获得数据
            System.out.println("行数" + sheet.getRows());
            System.out.println("列数" + sheet.getColumns());
            for (int i = 1; i < sheet.getRows(); i++) {// sheet.getRows():获得表格文件行数
                if (sheet.getCell(0, i).getContents().equals("")) {
                    break;
                }
                Map<String, String> map = new HashMap<String, String>();
                for (int j = 0; j < sheet.getColumns(); j++) {// sheet.getColumns():获得表格文件列数
                    Cell cell = sheet.getCell(j, i);
                    map.put(sheet.getCell(j, 0).getContents(),
                            cell.getContents());
                    // (列，行)
                }
                list.add(map);
            }
            // System.out.println("");// 换行
            // 调用方法进行数据库的操作
            // .......
            System.out.println(list);
            workbook.close();// 关闭
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }
}

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    //    request.setCharacterEncoding("utf-8");
        //System.out.println("jinru");
        String filename=request.getParameter("filename");
    //    System.out.println(filename);
        log.info("读取excel的地址"+filename);
        File file = new File(filename);
        JSONObject jsonObject = new JSONObject();
        JSONArray jsonArray = new JSONArray();
        //记录一下文件是否存在
        if (file.exists()) {
            List<Map<String, String>>list=ReadUsingExcel.readExcel(file);
            MuJUService mjService = new MuJUService();
                for (Map<String, String> map : list) {
                    jsonObject  = mjService.addShiYongJiLu(map);
                }
                jsonObject.put("existfile", 1);
        } else {
            log.error("文件不存在");
            jsonObject.put("existfile", 0);
        }
        String str=jsonObject.toJSONString();
    //    System.out.println("结果"+str);
        log.info("使用次数："+str);
        response.setCharacterEncoding("utf-8");
        String string=filename.substring(0, filename.lastIndexOf(‘\\‘));
        string=string.substring(0, string.lastIndexOf(‘\\‘));
        boolean flag = deleteDirectory(string);
        HttpSession session = request.getSession();
        session.setAttribute("usingexcel", jsonObject);
        if (flag) {
            log.info("文件删除成功");
            response.sendRedirect("muju/usingexcel.jsp");
        }else {
            log.info("文件删除失败");
            response.sendRedirect("muju/usingexcel.jsp");
        }
        
        /*
        PrintWriter out= response.getWriter();
        out.write(str);
        out.close();*/
    
    }
     public  boolean delete(String fileName){     
            File file = new File(fileName);     
            if(!file.exists()){     
                log.info("删除文件失败："+fileName+"文件不存在");     
                return false;     
            }else{     
                if(file.isFile()){     
                         
                    return deleteFile(fileName);     
                }else{     
                    return deleteDirectory(fileName);     
                }     
            }     
        }     
             
        /**   
         * 删除单个文件   
         * @param   fileName    被删除文件的文件名   
         * @return 单个文件删除成功返回true,否则返回false   
         */    
        public  boolean deleteFile(String fileName){     
            File file = new File(fileName);     
            if(file.isFile() && file.exists()){     
                file.delete();     
                log.info("删除单个文件"+fileName+"成功！");     
                return true;     
            }else{     
                log.info("删除单个文件"+fileName+"失败！");     
                return false;     
            }     
        }     
    public  boolean deleteDirectory(String dir){  
        //如果dir不以文件分隔符结尾，自动添加文件分隔符     
        if(!dir.endsWith(File.separator)){     
            dir = dir+File.separator;     
        }     
        File dirFile = new File(dir);     
        //如果dir对应的文件不存在，或者不是一个目录，则退出     
        if(!dirFile.exists() || !dirFile.isDirectory()){     
            log.info("删除目录失败"+dir+"目录不存在！");     
            return false;     
        }     
        boolean flag = true;     
        //删除文件夹下的所有文件(包括子目录)     
        File[] files = dirFile.listFiles();     
        for(int i=0;i<files.length;i++){     
            //删除子文件     
            if(files[i].isFile()){     
                flag = deleteFile(files[i].getAbsolutePath());     
                if(!flag){     
                    break;     
                }     
            }     
            //删除子目录     
            else{     
                flag = deleteDirectory(files[i].getAbsolutePath());     
                if(!flag){     
                    break;     
                }     
            }     
        }     
             
        if(!flag){     
            log.info("删除目录失败");     
            return false;     
        }     
             
        //删除当前目录     
        if(dirFile.delete()){     
            log.info("删除目录"+dir+"成功！");     
            return true;     
        }else{     
            log.info("删除目录"+dir+"失败！");     
            return false;     
        }     
    }