文件上传和下载（可批量上传）——Spring（二）

　　针对SpringMVC的文件上传和下载。下载用之前“文件上传和下载——基础（一）”的依然可以，但是上传功能要修改，这是因为springMVC 都为我们封装好成自己的文件对象了,转换的过程就在我们所配置的CommonsMultipartResolver里面

原因分析

首先我们来看下Spring mvc 中文件上传的配置

     <bean id="multipartResolver"  class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
         <!-- one of the properties available; the maximum file size in bytes -->
         <!-- 5M -->
         <property name="defaultEncoding" value="utf-8"/>
         <property name="maxUploadSize" value="25474565"/>
     </bean>

再来看看Controller中使用

方法一

public void upload2(HttpServletRequest request) {
    // 转型为MultipartHttpRequest
    try {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        List<MultipartFile> fileList = multipartRequest.getFiles("file");
        for (MultipartFile mf : fileList) {
            if(!mf.isEmpty()){  

            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }  

}  

方法二

public String upload(HttpServletRequest request,  @RequestParam(value = "file") MultipartFile[] files) {
    try {
        for (MultipartFile mf : files) {
            if(!mf.isEmpty()){  

            }
        }  

    } catch (Exception e) {
        e.printStackTrace();
    }
    return "upload";
} 

这里springMVC 都为我们封装好成自己的文件对象了,转换的过程就在我们所配置的CommonsMultipartResolver这个转换器里面下面再来看看它的源码

他的转换器里面就是调用common-fileupload的方式解析,然后再使用parseFileItems()方法封装成自己的文件对象 .

 List<FileItem> fileItems = ((ServletFileUpload) fileUpload).parseRequest(request);

大家应该发现了上面的这句代码,已经使用过fileUpload解析过request了,你在Controller里面接收到的request都已经是解析过的,你再次使用upload进行解析获取到的肯定是空,这个就是问题的所在(大家可以在servlet里面实验,看看第二次解析后能不能获取到数据,当然是不能的)

解决方案

1)删除Spring MVC文件上传配置

 <!--
     <bean id="multipartResolver"
         class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
         <property name="defaultEncoding" value="UTF-8" />  

         <property name="maxUploadSize" value="2000000000" />
     </bean>
      -->  

在控制器里面自己完成request的解析(当然上面spring MVC提供的两种方法是不能用的,所有上传的地方都需要自己做处理)

 public void upload3(HttpServletRequest request) {
         DiskFileItemFactory factory = new DiskFileItemFactory();
         ServletFileUpload upload = new ServletFileUpload(factory);
         try {
             List<FileItem> list = upload.parseRequest(request);
             for(FileItem item : list){
                 if(item.isFormField()){  

                 }else{
                     //item.write(new File(""));
                 }
             }
         } catch (FileUploadException e) {
             e.printStackTrace();
         }  

     }  

2)如果是需要使用的ProgressListener监听器我们可以重写 CommonsMultipartResolver的parseRequest方法

 package com.lwp.spring.ext;  

 import java.util.List;
 import javax.servlet.http.HttpServletRequest;
 import org.apache.commons.fileupload.FileItem;
 import org.apache.commons.fileupload.FileUpload;
 import org.apache.commons.fileupload.FileUploadBase;
 import org.apache.commons.fileupload.FileUploadException;
 import org.apache.commons.fileupload.servlet.ServletFileUpload;
 import org.springframework.web.multipart.MaxUploadSizeExceededException;
 import org.springframework.web.multipart.MultipartException;
 import org.springframework.web.multipart.commons.CommonsMultipartResolver;
 import com.lwp.listener.FileUploadListener;
 public class CommonsMultipartResolverExt extends CommonsMultipartResolver {
     @Override
     protected MultipartParsingResult parseRequest(HttpServletRequest request)
             throws MultipartException {
         FileUploadListener listener = new FileUploadListener();
         String encoding = determineEncoding(request);
         FileUpload fileUpload = prepareFileUpload(encoding);
         fileUpload.setProgressListener(listener);
         try {
             List<FileItem> fileItems = ((ServletFileUpload) fileUpload).parseRequest(request);
             return parseFileItems(fileItems, encoding);
         }
         catch (FileUploadBase.SizeLimitExceededException ex) {
             throw new MaxUploadSizeExceededException(fileUpload.getSizeMax(), ex);
         }
         catch (FileUploadException ex) {
             throw new MultipartException("Could not parse multipart servlet request", ex);
         }
     }
 }  

 

监听器方法

 import org.apache.commons.fileupload.ProgressListener;  

 public class FileUploadListener implements ProgressListener {  

     @Override
     public void update(long arg0, long arg1, int arg2) {
         //arg0 已经上传多少字节
         //arg1 一共多少字节
         //arg2 正在上传第几个文件
         System.out.println(arg0 +"\t" + arg1 +"\t" + arg2);
     }  

 }  

配置文件改为我们自己的(这种方式的缺陷是,所有文件上传都需要使用到Listener)

 <bean id="multipartResolver"
         class="com.lwp.spring.ext.CommonsMultipartResolverExt">
         <property name="defaultEncoding" value="UTF-8" />
         <property name="maxUploadSize" value="2000000000" />
     </bean>  

注: 综上所述,如果只是普通的文件上传spring MVC 完全可以完成,如果需要使用进度条的listener前段可以使用假的进度条或者是上面的两种方式.

以上出自：http://blog.csdn.net/lwphk/article/details/43015829#

看完前辈写过的东西后，我也自己看了一下源代码，有所感想于是进行尝试，结果可行

 package com.tommy.business;

 import org.apache.commons.fileupload.FileItem;
 import org.apache.commons.fileupload.FileUploadException;
 import org.apache.commons.fileupload.disk.DiskFileItemFactory;
 import org.apache.commons.fileupload.servlet.ServletFileUpload;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.multipart.MultipartFile;
 import org.springframework.web.multipart.MultipartHttpServletRequest;
 import org.springframework.web.multipart.commons.CommonsMultipartFile;
 import org.springframework.web.multipart.commons.CommonsMultipartResolver;

 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.*;
 import java.net.URLEncoder;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 /**
  * Created by OnlyOne on 2016/3/4.
  */
 @Controller
 @RequestMapping("/background/uploadAndDownload/")
 public class UploadAndDownloadController {
     /**
      *
      * @param req
      * @param resp
      * @throws ServletException
      * @throws IOException
      * @throws FileUploadException
      */
     @RequestMapping("uploadFile")
     public String uploadFile(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException, FileUploadException {
         /*//防止中文乱码，与页面字符集一致
         req.setCharacterEncoding("UTF-8");*/
         //得到上传文件的保存目录，将上传的文件存放于WEB-INF目录下，不允许外界直接访问，保证上传文件的安全
         String savePath = req.getServletContext().getRealPath("/WEB-INF/upload");
 //                            this.getServletContext().getRealPath("/WEB-INF/upload");
         //创建保存目录的文件
         File saveFile = new File(savePath);
         //判断保存目录文件是否存在,不存在则创建一个文件夹
         if(!saveFile.exists()){
             System.out.println("文件目录创建中。。。");
             saveFile.mkdir();
         }
         //消息提示
         String message = "";
         //将req转换成Spring的request
         MultipartHttpServletRequest multipartHttpServletRequest = (MultipartHttpServletRequest) req;
         //获取上传文件
         List<MultipartFile> list = multipartHttpServletRequest.getFiles("file");
         //获取普通输入项的数据
         String map = multipartHttpServletRequest.getParameter("username");
         System.out.println(map);
         for(MultipartFile multipartFile: list){
             FileItem item = ((CommonsMultipartFile)multipartFile).getFileItem();
             //如果FileItem中封装的是普通输入项的数据
             if(item.isFormField()){
                 String name = item.getFieldName();
                 //解决普通输入项的数据的中文乱码问题
                 String value = item.getString("UTF-8");
 //                    value = new String(value.getBytes("iso8859-1"),"UTF-8");
                 System.out.println(name + "=" + value);
             }else{//如果fileitem中封装的是上传文件
                 //得到上传的文件名称
                 String fileName = item.getName();
                 System.out.println("文件名是："+ fileName);
                 if(fileName == null || fileName.trim().equals("")){
                     continue;
                 }
                 /*注意：不同的浏览器提交的文件名是不一样的，有些浏览器提交上来的文件名是带有路径的，
                  如：  c:\a\b\1.txt，而有些只是单纯的文件名，如：1.txt*/
                 //处理获取到的上传文件的文件名的路径部分，只保留文件名部分.如果传上来的文件名没有带路径，则lastIndexOf返回-1
                 fileName = fileName.substring(fileName.lastIndexOf("\\")+1);
                 //获取item中的上传输入流
                 BufferedInputStream bis = new BufferedInputStream(item.getInputStream());
                 //创建一个文件输出流
                 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(savePath + "\\" + fileName));
                 //创建一个缓冲区
                 byte[] buffer = new byte[1024*8];
                 //循环将缓冲输入流读入到缓冲区当中
                 while(true){
                     //循环将缓冲输入流读入到缓冲区当中
                     int length = bis.read(buffer);
                     //判断是否读取到文件末尾
                     if(length == -1){
                         break;
                     }
                     //使用BufferedOutputStream缓冲输出流将缓冲区的数据写入到指定的目录(savePath + "\\" + filename)当中
                     bos.write(buffer,0,length);
                 }
                 //关闭输入流
                 bis.close();
                 //关闭输出流
                 bos.close();
                 message = "文件上传成功!";
             }
         }
             return "redirect:listFile.html";
     }

     /**
      * @ClassName: ListFileServlet
      * @Description: 列出Web系统中所有下载文件
      * @param req
      * @param resp
      */
     @RequestMapping("listFile")
     public String listFile(HttpServletRequest req, HttpServletResponse resp) {
         String flag = req.getParameter("flag");
         //获取上传文件的目录
         String uploadFilePath = req.getServletContext().getRealPath("/WEB-INF/upload");
         //存储要下载的文件名
         Map<String, String> fileNameMap = new HashMap<String, String>();
         //地鬼遍历filePath目录下的所有文件和目录，将文件的文件名存储到map集合中
         getListfile(new File(uploadFilePath), fileNameMap);
         if(flag != null){
             req.setAttribute("flag",flag);
         }
         req.setAttribute("fileNameMap", fileNameMap);
         return "/background/uploadAndDownload/resourcesList";
     }

     /**
      *
      * @param file 即代表一个文件，也代表一个文件目录
      * @param map  存储文件名的Map集合
      * @Method: listfile
      * @Description: 递归遍历指定目录下的所有文件
      */
     private void getListfile(File file, Map<String, String> map) {
         //如果file代表的不是一个文件，而是一个目录
         if (!file.isFile()) {
             //列出该目录下的所有文件和目录
             File files[] = file.listFiles();
             //遍历files[]数组
             for (File f : files) {
                 //递归
                 getListfile(f, map);
             }
         } else {
             /**
              * 处理文件名，上传后的文件是以uuid_文件名的形式去重新命名的，去除文件名的uuid_部分
              file.getName().indexOf("_")检索字符串中第一次出现"_"字符的位置，如果文件名类似于：9349249849-88343-8344_阿_凡_达.avi
              那么file.getName().substring(file.getName().indexOf("_")+1)处理之后就可以得到阿_凡_达.avi部分
              */
             //String realName = file.getName().substring(file.getName().indexOf("_") + 1);
             //file.getName()得到的是文件的原始名称，这个名称是唯一的，因此可以作为key，realName是处理过后的名称，有可能会重复
             map.put(file.getName(), file.getName());
         }
     }

     /**
      * 下载文件
      * @param req
      * @param resp
      * @throws ServletException
      * @throws IOException
      */
     @RequestMapping("downLoadFile")
     public void downLoadFile(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
         //得到要下载的文件名
         req.setCharacterEncoding("UTF-8");
         String fileName = req.getParameter("fileName");
 //        fileName = new String(fileName.getBytes("iso8859-1"),"UTF-8");
         //上传的文件都是保存在/WEN-INF/upload目录党徽宗
         String fileSavePath = req.getServletContext().getRealPath("/WEB-INF/upload");
         //得到要下载的文件
         File file = new File(fileSavePath + "//" + fileName);
         //如果文件不存在
         if(!file.exists()){
             req.setAttribute("message", "资源已被删除！");
             req.getRequestDispatcher("/message.jsp").forward(req, resp);
         }
         //处理文件名
         String realName = fileName.substring(fileName.indexOf("_")+1);
         //设置响应头，控制浏览器下载该文件
         resp.setHeader("content-disposition", "attachment;filename="+ URLEncoder.encode(realName, "UTF-8"));
         //读取要下载的文件，保存到文件输入流
         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(fileSavePath + "\\" + fileName));
         //创建输出流
         BufferedOutputStream bos = new BufferedOutputStream(resp.getOutputStream());
         //创建一个缓冲区
         byte[] buffer = new byte[1024*8];
         //循环将缓冲输入流读入到缓冲区当中
         while(true){
             //循环将缓冲输入流读入到缓冲区当中
             int length = bis.read(buffer);
             //判断是否读取到文件末尾
             if(length == -1){
                 break;
             }
             //使用BufferedOutputStream缓冲输出流将缓冲区的数据写入到指定的目录(savePath + "\\" + filename)当中
             bos.write(buffer,0,length);
         }
         //关闭文件输入流
         bis.close();
         //刷新此输入流并强制写出所有缓冲的输出字节数
         bos.flush();
         //关闭文件输出流
         bos.close();
     }

 }

其实只需要将SpringMVC封装的文件对象转换获得原始的数据对象就好了

aaarticlea/png;base64,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" alt="" />

采用SpringMVC封装的文件对象进行解析

到了这里，发现了将MultipartFile再转换成FileItem不理想，因为MultipartFile没有普通输入项的数据（如："上传用户：<input type="text"name="username"/><br/>")
还有对文件名的处理也是多余的。

aaarticlea/png;base64,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" alt="" />

aaarticlea/png;base64,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*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" alt="" />

如果要获取普通输入项的数据，也可以。如下

aaarticlea/png;base64,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" alt="" />

从这里可以看出，Spring对浏览器提交的文件名已经做了处理，不再需要自己处理上传的文件名。

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAABLMAAAGpCAIAAAD5leNvAAAgAElEQVR4nO3dXW8cx53vcb0N2xcGfIwDq1oPbAbR6AhGxoc7xNoz2BwMtQotm7CYJQTKgnZiYDM7vCGQcRL7IEwWueF4IThAmNwMF6BzoSwF7AK5G10c6jXkreRcVE91dVV1dc9jDdnfDwiEmn6o6u5h0D//q6uvPXjwIFoxj3713n//5/X//s/r//Xn64+ECN2dsnq/f++PPy3obe/37/33f14vXA0AAAAAlunaqiXDR796779+f13+/vc/TX9XZLiSP/+2c/ki1t//tDhAAgAAAMAyrVYyFOL6v/35vV5DaP9My4aicf2Pf05jlfHPy4JkCAAAAGDVrFgy3LmuioSyNqgPKH30KzNTyXDYa4i//2mmkCg/T4ak/uq62lytY4xTFTvatuPfVU8Klorr/zZuyxn59L798afCSIaeXgEAAADAcqxeMvzV9UiOKf3Vdb1maNQPFRUX7RV6v39PDTf9+5++pyJi0pC1NxnS/mtctBQ7mRX8S6OcYqAxINZ4zrBMrwAAAABg0VYxGaqMl0mGjet/tJ45jLJ5TP9dX9+ZKlUKVWQczeubf2nkSobOdj1R1tkrAAAAAFi0VUyG0bjcN1HN0Fjn0a/SgqE+uFT/Maa30Tex+ZdGzmToSrNqtZK9AgAAAIBFW9FkqKcmFbc8zxmqT+Q6RiTLS5WG+SfDyWuGAAAAALB8K5YMG9f/mB+W5FwvarClc25SuYd/s1KcPreNZL8SY+7JMLKeJJSz0aRFzhK9AgAAAIBFW61kGNnvM7Qeuit8n+GjX73nnMdFnyPUGLSpTxA6+1J9QlRjhf/6/XXZDbWCp1cAAAAAsBwrlwwjLfsxUScAAAAALMEqJkMAAAAAwDKRDAEAAACg6kiGAAAAAFB1JEMAAAAAqDqSIQAAAABUHckQAAAAAKqOZAgAAAAAVUcyvPQ6J6Pj7kehe7EqfvfWG399573lb7s4q9krAAAAXDFXIRmKu7de9OLXB+sXz241hfCv41lNbN5+fbB+sXtzwf2dM5KhbqWSoRDv/uWNN/725pt/e/PN+fZqLnsOS+wMhieH+ifbR3yTAQAAgrkKyVB6vBt7kqEkxI3+s9zVFpQMhdjrn49OX746fflqeD7odM/021+xeXicvT++2sR77/z1rXc8K/zurSTw/O3NN//yru9qXiL/+M5bdn47eDs9Uv1noqN27nn1CbHXPz/rbGaOVGweHp8Ptr1/wiV2OxpW6Q8KAABgXq49yArdn+nNngwXQd6q9neS5sTO4PTlK5Jh7qI30vqY8c9LLS+/iXff/tvb7+qfHLz9RhWS4Ub3zJnfZiwbbnTPhkd7M/QLAACguq7p/wiYDLMjQm8+H4/8fHH/hlzh8W7yyfNNIQOevcLFs1tNbdSoWpS2kpMMC8eaCq1LF721/uatF721/t3iO3h7yNzGuGao1xLVj76yjJGnL1/1d4T6Xa2gb27cTMuVh+eD7c3D4/E6Kp2qbozLmGedzWRXxjp5/vGdt5IC1xtv/e69ZFijyjOZUtgbbx+MT6Y+ADL90VLiwdtmDhTvvfPXN9763XsikiFqXFJTv6vNC0dXevrs2TZp6I23D95756/jdfTkJrTP//bmm0bM01ufNBmWHC+at+fcqzDtESUbvvVOUtR9+139ihS2a8gbAi12BsMZyoYb2YI8AAAAyluVZCg93o0vnt1+/uz2YyGicWBTwzvlaM/n4xFocqkRHS962W2zMa9gNGlebty8refMZLWSyTBbM3SsUFQz3D4ajfObiKJI7OwZ983Ou+FkWJ3aavPwWBu8p1dsxObhsbZmoX985600j8kUMQ5vyVIt6oh33zbiQV7NUIh3/+IKEkZcTIJHGhffNTZxJiV/n/3bJglNtaiFVdvB22/8zXV0hcnQOG9ltvUs9V+FqY9Ir+L+7q035D71nRde/eTz7Lex5KIySIYAAABTW71kmE1cehosTIaebZNPJk+Gzg+b99dKJsPIfM7Q9WxVUTL0D5DzJEM9kXZOxilR7PWzZZnyt+N2fsuU9VzpziiL5SbDnM+N5HPw9ht5Ccq5fmGf/duON8+M8PzdW7k5quRRpOur4ufk9ca8pYVXYeoj0n9XiV28985fZUQscfWTD/MLg4X/JcWPZAgAADC1a/oThiuRDI1gpsW/4mSYv23yyTTJ8Obz7E5mIQt0Ez1nuH1UcKOcnwwzN99pMrRadE4H4u6/lXyEePcvmeqTa1YVbZPZa4b+x/AcScnbZ/+2zo7pOcoxRDZ0zbDwKkx9RAXJsMTVT/azgGTI3DMAAAAzumI1w2Qoqb7CzDXDm8+1Ea36ms9LRCk714mdgV4DDJAMl1szNPeQPwON/zlDtc7EyXAONUN3jrKLb9PUDL0lUM+2eUsLr8LURzRFzdDdAUaTAgAArJ7VS4bPbj/fTbKZ8aygnvTUJDTZmuHaC/VQokx083jOsHl/zZjPRn5SMhkaI0iNpKfP1J/UPbJjR+eeDCNrCsfOyYTPGWph5ndvZZ7ZE+++bdSI9Gf8Ii1IRKo8lR3lmP7TNTfpFMmwsM/+bYtylPX8XuhkGBVdhamPyJ8MC9vVMQMNAADAqkmTYfBYGJWYX1SWDbUJQuPXB+v/b0+b13S8gv5mQn0uU/1HhkD/0mQPWpeS1ss9ZLh9NOp30wlCT1++sh8aVNOEGrOMyrln8mYutZeqnacTmZ6fdTaFcxZTffPj7mHJ0aSSPv/kX995xxiZmc4CmjOYUF/BTjV57zN0vP0vO6+pYxyjFro8ffZsmz4H+MZbv3tP2POFZh4UfPPNv7wjp7dJkpK/V8ZSI/FOtK19vHlXYeoj6v2PzIZJB95+15jRp/DqS4t7awXJEAAAYDpJMlyFWBiVeych5q78c4aubd3P7K2yy9jnK2ZBb7rnfYYAAABTuxatTCyMSIaB2C9dnGBbawDh6ruMfb567G/djAXDiHloAAAAZnBtRWKhNVwzM5cM5k7OkjoedDpZoSYzC2W5SUeCu4x9BgAAAJZmVZIhAAAAACAUkiEAAAAAVN3KJcNarRa6CwAAAABQLSRDAAAAAKg6kiEAAAAAVB3JcEk6J7POyL8Iq9krzMvjp6dfb22E7gUAAAAuAZLhkoTKYBvdM/lqitOXr4bWu8WdvZIvhZObkBujKBLiRv9Z/OL+DePzx7vJe1aeb/regSE2b78+WL/YvbmIvtW3Bv/+r/8hf77pDh7fzfTEmQyF2O52T+Um5MZLYRHvfgQAADCQDBN6HBqeDzrdM/3GS2weHl/C12eLzcPjCd9VqNvInoTKEuLm817sjHYy9YVKhuJu5+vul+1pr299azBpMhSNL1UQVT/dRtoBcbfz9dPOdP0JJe+vW/1Xlf6OiIxXgB7tLa97Yq9v/TedGf+0AQAAbCTDKBrHQnn/F0WR2BkY5bJLnAxn6DbJUJoxGS7OjDFsimRYuO1VSobR+P8K9Hrd8ot1G92zoat7lA0BAMB8kQyjyDVYS4UivZaYDsvUVpb3jrKwoH5XK3hGZiY3neeDba0WodKp6oY2EDTZlbGO+4i0faof1YGS40XzkuH2UbrnoVa4KDwio1eq8KLuvzsnI/m5flYL2y04FeNd2T+FZ1KOI5VDRvUfNbI0SYb3b73oOUaWirvp5xfPbjWtDsvNnXsu6NjdztfjEaHqR0W1kuNF89Jd+7NTbYSquyZpb6s3mm6eTYnOPcs65DdPO4+fnv77v/7HN59tq8qkXo308/+l5H5jS/x1D4/29EHXeh5bzvc5byC62Bl4thJi+4P9YevJ6Qd16ooAAKAUkmEUWTVDxwpFxTd5k6ce5BM7e8YdmzNlyXbTrTYPj7VhY3qtQN6D2g8KFhxXUbf9VUHn0o3umT6Uzrg99R+RYftoZBygbK5zMpL71Hfub3ehCmuGF73bj2XI2bx90VvrZx/2k/HSToZGvVHGyJLJcLxJQYHOXxV0Lq1vDb75bDttovGlMxxOUTP07FkGXbnDx09P5ed5Tdv8fymF3xx/zXB4tKcP3fRU6hbxffb8Bfn/uEiGAABgUiTDRPY5Q9dTPUXJ0P/okScZ6om0czLOVGKvb9+/hk6Gdq+i8d1z4RH5u6f/rm6+1R15YbsLVX40qTPd+ZPhRKVCs/V5J0MhtrtWGBONL/VE599zXpf8e9a3an+WRMSST1H6/1LKfHMKk2Gk/YF7kuEivs+e/wJS+N+zAAAAJkIydND/e3/6SVEy9N+i5SfDzG1fmgytFp0TURQfyHyToWuQqjV61n1E46Uj94b+O+midn0nYYbRpONuLyQZRtrspsmIU6veWNCxuSdD1yBVe1CoZ8+5ydC755mSofcvpcw3p0wyVDEsM5p08d9nkiEAAFgakmEUuXJd+apC3h4MEyfDy1Mz9K+QPaKR+djhDDWWpVlcMtQ176/lPY6Y27Gl1Awn2vNENUPnVkuoGZp7KJEMk99PDtMv51K+z1OPJl1rHreenDb3+99n/lIAAFAOyTCK5FCx7D2WkfT0B42SR+my477mngwj60mkzslKPGfonK2nTM3QWJScxnJ30oXtLlQS7cbJUI9/syTDx7uZD535czypT042WMBzhqLxpVEhrG8NJqsZqqcHxXa3e6pGonr2XDIZ5p0N/19K4TfH89dt/BciOaOMlgyX8X2ebgaaezvD5v7xvTvEQgAAUBbJMIpkruu6pxlU9FfG6zdq+gSD9pAwe6naeTqR6flZZ1M45wvVNz/uHpYfTeocQumcqtE+ZP9S41RkRtAVHZHRK3nOh+eDH32a2TCZzieZ+SO9y89rdwlkbEuHfe7ejMaxUE1JmpmJdPdm3rymKg0aQ0mdTxvmZSH/ewX1KUDTcZvjhOZfGkVRfWuQN5S08H2GxuZGenTuWe3zm+7g8V0hu/fNZ9tyAKr80H82oqK/lMJvjvOvW/9Qf6VhOpp0Kd/nKd5aIe50GvvDRnPKV5IAAIBqIhleGlM8ZwhU0BX7S5niTfdrzePmziV7qyQAAAiOZHhp2MPPANiu3l+KfUS85h4AAMwdyXCl6XMYLu31fcClw18KAADAjEiGAAAAAFB1JEMAAAAAqDqSIQAAAABUHckQAAAAAKqOZAgAAAAAVUcyvAQ6J8xQDwAAAGCBSIYpsXn79cH6xe7NvBUe78avD9bVz4v7NyZuIudNaxvdMznh/unLV0PrrdbOZCjEXn88TT+5cXHE3Vsvesl1v3h2q5l9HYJ/acR75wAAAHBJkAxT/mTYvL920Vvr353+PWlC7PWt1Bclr2Kb/g1sG90zsseiCXGj/yx2Zj//0hkvbjT+TwBX7NXtAAAAWDUkw7Ie78YXvduPZ7jF3+ieOe/vxebh8Qz3/STDJZg6GUYzlw03umfDo72pNwcAAADKIBlGUdGYwOb9NX0QqWfooJ89KFRsHh6PR4SqH7VOyfGieclw+2ikjVBNy1ZiZ5B8orXe30mPxeiViiXJhieHnZOR/Fx+Ymye166f2pX9098R/qUFe968LS/Z802hxgM/H1du9U9kwHMOFZ4lGYqdQfnzYCP5AwAAYAlIhin//f2MNUOxeXjsGkoalagZ+rOBc6lRaDLCSTJAcdwfT9+iKNo+SocyytAom+ucjOQ+9Z372w1FhsMXz9aeJ8d7Wx8YLJeqrCj/M8E8k6H39BYiGQIAAGAJSIapxSbD/Iw092QoxF7fakvsDNLqn9jrn4/0alvnJDe66N3Tf1eDJNWjdIXthpIkw3HYM7LfwpOhdbYnQjIEAADAEpAMU1cnGboGqcqBoMkKVoTTk6E+itXc0J8Mi9r1n58FjSaNirLfyiZD5p4BAADA0pAMU1dmNKmzdudfQSVDO8bMWDNcBYGTIaNJAQAAsPJIhqmFJsMo/4X1i3jO0H5xoj4zalEytJ5ILJcMC9sNpSAZ3r31ohcnjyCOJ6FhBhoAAABUCskw0mekdM4+arzgPlma89pDDzsjOQdJqnqdPsmnPVOof6lszj0idNyonIHGngHV6FW/e3h8PhqeD370aWZD2YHh0Z4cRKrms8lrNxQ1N2kyAak+D+34Iqp1Lnpr/c1khYvdm/7vRuE3R5r9rRUkQwAAACwayXB58t50jyts9jfd8z5DAAAALAHJcKnswZa42mYsGEbMQwMAAIClIBkCAAAAQNWRDAEAAACg6kiGAAAAAFB1JMPA7QIAAABAcCTDwO0CAAAAQHAkw8DtAgAAAEBwJMPA7eqEqDXarXrsfvedfykAAAAATI1kGLhdXVxvtRu53fAvnaiVra2tdqs++65sQtQa7fbW1tbW1larHvtXrrfaZVa7pBZ6ngEAAID5IhkGbleZe8FQD2ntdqNeb6kMJuJ6a8GJJdaam321S2oJ5xkAAACYC5Jh4HaV+RYMZSxs1JIkKWoNvTpHMlwOkiEAAAAuC5Jh4Hal+RcMaw1jHGNs1QzlcEdJZch0hbTemDZtjJBM/unqW17k0xtt1eOSyVAm23a7UdM6ZvS51mirPbfbjZrI9Fltkjm0cdjO21Y1nWw7/r3kGFH/edZ7ondG9UeeH/10lVnqP6IyZxIAAAAVRDIM3K409ycMjZqhuTSut9ptFW9EraGnO/Ofcb2llx+tOli9VTYZxvWWnqkmes5QHpHqmJD70iKrforGRy+0bTN5r95Kj8i/rSSDVtp6rWas4O6z9zwb5EL1z7jearXM06XOVeHSorOReyYBAABQTSTDwO1GC5uSNPucYWYP/nRnJz19/amToR3PoiiSx1b+cPSsq9p17ll+5uxP5nBKbCv7OcX0PyXPlXNlI0UbXfUsLTwiz5kEAABAZZEMA7cbLWVKUlm88jxnWJCytA+nT4auh+7KP2foqvvpVa908GQ6ilJrTt9c/qafGf+2xibl+c+VHt3tRp1nRm3uWVp4RJ4zCQAAgMoiGQZud0EFQzvJZKpGl7VmmJMMXXu2Jacy2//y2843GdqFO0fNMPtfBMyaYc7SwiMiGQIAAMBGMgzc7oIKhrVG2xhBahbKPLUsa/Ya/ak8/bE044k1o+fu5wyzIzwnfM4wN884Z9wxx1vG9Va70XBm5qJtF5MMrWf/ssnQmJZGP6X+pf4jKpMMxxPVkBgBAACqgmQYst0FFQwjmWTq7qkv1YSW7bTEZL6bXp/00g5vxmSb+kQy+pSYdtPGCu3xvJ2F6TedFLTdqsel+uycPrTWaNuzy/i3tY+o5MSkhedZHVRyJuv1Vjvtnkx6xunSd+5Z6jmiMmcyIhkCAABUD8kwZLtLeMIQl5T/Ccyr/R5IAAAALB/JMHC7gBPJEAAAAMtEMgzcLmDLDBO16sb+pQAAAMAUSIaB2wUAAACA4EiGgdsFAAAAgOBIhoHbBQAAAIDgSIaB2wUAAACA4EiGgdsFAAAAgOBIhoHbBQAAAIDgSIaB252FEDf6z+IX92+E7khGq/fx068fPvrke6LVfPr1w8+/an4gRMmlAAAAAIIgGQZudxZC3Hzeiy92b4buSMYHTz9++vXDBy0h3t949NXHn/c2yi8FAAAAEATJMHC7s1jNZHjnk/bnX7Vb7wsh7j346uPPn94rvxQAAABAECTDkO0+3o1fH6y/Pli/2L2Z/t67/Xg8wLJ5f01+aHwux5GqRepHjixVu3q+KfQ11bhTT7ti87baVt9P+YO680lbjRFt9T5+9Mn3yi+NokiI7Q/2h60npx/UGWUKAAAALAnJMHC7su6XBjNx83kv1gOeSmXGPyNvzVAGPLWyuHvrRS/zRKKnXbnti2drcnOxefuit9a/u6ScRjIEAAAAlo9kGLjdJN1p9cDkcxnPMlnuRv9ZfPHsVjOtHM6aDO127abtbQEAAABcMSTDwO3mpTt9HKn+kx1TOnMynGpbAAAAAFcMyTBwu3kJzYhnE21rb36JkuFa87j15LS53/8+b7MAAAAAloVkGLjd3GQox45qD/jJhGbPQ6O21SOc/D15UHA8Cc2lSIb3dobN/eN7d4iFAAAAwPKQDIO1q+aAyQ4Wzcz1YowptWeCMXaiJz01y+hFb62/eeuFnG9m96a/XbVVMrXp3WRDY+eLOid3Oo39YaPJSw4BAACApSIZBm4XurXmcXOnE7oXAAAAQOWQDAO3CwAAAADBkQwDtwsAAAAAwZEMA7cLAAAAAMGRDAO3CwAAAADBkQwBAAAAoOpIhgAAAABQdSRDAAAAAKg6kiEAAAAAVB3JEAAAAACqjmSY6pyMhueDbSFCdQAAAAAAgiAZZmwfjfo7JEMAAAAA1UIyzNg+Gh13PwrYAQAAAABYPpJhBskQAAAAQAWRDDNIhgAAAAAqiGRoYh4aAAAAAFVDMsygZggAAACggkiGGSRDAAAAABVEMswgGQIAAACoIJJhBu8zBAAAAFBBJMNU/5y5ZwAAAABUEckQAAAAAKqOZAgAAAAAVUcyBAAAAICqIxkCAAAAQNWRDAEAAACg6kiGAAAAAFB1JEMHIWqNdqseu19f4V+KsOqtdqseh+4FAAAAcMmQDB3ieqvdyO2Gf+lErWxtbbVb9dl3taCdy51I7UsShi9RMhSi1mi35em9FH1e6DcWAAAAYZEMTcssGIq43lrYffaMOxcyAYslpcFao61SaKMmRK2RhtJ55PDFmf0ixvXWSiVDzxEt9BsLAACAgEiGpuUUDKVVT4bLzQCi1jDO7apFJieSIQAAAK4AkmHGIgqG+qDBra2tRj29t5b32fqgzUYts3O9kta2KniePUfaTbzaf8kRoSKut7Td2sMd9RWMfapan173Kzn+0JMM5a7a7UZNa1o/V56RmWqR7KrqvH0+y5yQdrvRaLRl08b5Nw7WaFffT8kA7L/6eeRWrXqsf6/yLp/RGf8RRSW+sQAAALikSIYZcy8Yyrtwdfcs77zbejLU/1lr6EHLaE7UGno88O85ypZ3RK026bjQvOqQ0UmjG5IMJ2kiKte6v2aYHGAmZTmCbl7Kkr1U3Sv/sJwYn3fVSTOU+itsVnK2m3b22X/1/eJ6q9Vq6Q15Hr+0z0bREeV+YwEAAHB5kQxTiygYym1yW7RuweutcfKROckoEmrZyb9ntXM7MZaUFw9UDz1ryhQzcYslkqEeyeyeRN6RmTLF2H3TS3N2Ja3wuvsHWBq5Sz67WdjnwqvvJwNp4Q7z+j/RaFLnVQAAAMClQzJMLeIJw1rDkQQUXzJ0DenUh/b596zvYboHI53xwJ1YrA8L++ZusTgZZlqZNBlGsnI4RUjWpsNxjFb1JkM90OZFO0cyLLr6fs6TkP2PDm3PbkmGAAAAFUQyTCxoStL51gzL7znSJhctXLNk34weetacVzLUez5jMhTjgY/j0a9Thhm7dFk4KYuq4OWFqJI1w/Ls/4qhdlim/yRDAACACiIZJhY0Jan9pFks61aqMJh/n20/k6aPEvTv2dj5FG/58z1naPbZ8ZzhNMnQeKIv+9qMWZKh+UzmJE/H2ZfeOF69n8nYXUcqSyauyWvC0Wfv1S/ss1ErTufyyZ5G52BjzxGRDAEAAK4qkmEULaxgmGxuTAU5vrHWpgxNiznGeEV9Ekj3qD/XntWG8hN9tTL50Bg8aU9BafRK36f9zN5Eozf1k5BJuWqaUzm/qHWuPM8KmtvmzG6axzhY5znMmwVUX8HOov7nG+2my59JmQMzU5vqUxNlr2+jXm+120Yd1XlEZb6xAAAAuKRIhlG03HcYooKW/BVatRckAgAAYPWRDIHFmrHmPAWSIQAAACZFMgQWxRgvupyXwmcGkVLrBgAAQDkkQwAAAACoOpIhAAAAAFQdyRAAAAAAqo5kCAAAAABVRzIEAAAAgKojGWIhOiej4+5HoXuBKhLi3oOv2q33l/eaEAAAgCuAZJgSm7dfH6xf7N6ceENxo/8sfnH/xiJ6tbI2umenL1/Jn+H5WWczcyPuTIZC7PXPR3KTq5Ebr8ARdU5GS+68/5sjiZ3B8ORQ/6TV+/jp1w8fffI90Wo+/frh5181PxDu7Hfnk/bnT++V33b7iP+KAQAAQDLUzJAMbz7vxVNseHmJzcPj88F2zq15oY3u2RW7F1/EEYnNw+NsOkoX7QxUuFI//Z2VuBwyauZ1qcw3R4i9vpUYP3j68dOvHz5oCfH+xqOvPv68t5GzraNg6N92xi8zAADA1UAynIOKJsOc0FIGybCMMid5Lu3Oq/Ni8/D4PK2/Gf9MPyxxUENrnTuftD//qt16Xwhx78FXHxtVwcxq1qLCbSkbAgAAkAyjKIrE3VsvevHrg/XXB+sXz241teqBLCS+Plh/vike78bq92SpuNF/lnyo/5QZWbp9lIzi0wfXOW6jx4MV7XF32aWD/tGoTNXIWW4qX3TSG7W7XXJ0ZV4UkedEHZEq48g+D88H21rrem+NXg2P9jIbnhzKQtbwaE8dvr55XrvlOY8or1fOFfQrqJ/GdHNXoLLbLTxXUXY8p/wG6jvJvQrjXsmvouq8WsfOV2Lz8Hj8vfV/c3TOoch3PmmrUaCt3sePPvmevWHeE4aF24qdgee6C7H9wf6w9eT0gzp1RQAAcGWRDFMy5hnJMBqHwxfP1p4nN7i3L3pr/btaLJm2ZrjRPTs+yZRH9HtisTPQ06C8sVa3+PI2Pf3nzmCW8YSTKqz8+MtQzqUb3TM9Oxk36/J4h5mY4X5ELYqi7aOROqt65apzMpL71Hfub7ekMmU3vVdRiSs4dc3Qf66MipzxnGHh2eicjNQKmfMs9vqu82bExcKD8l9ZP2fBsAx/oyRDAABQBSTDVEEyHJcBZYFRrwrOkgyNQpB+e905cRUJMzfiU95Az27uydCZK8TOIK3+ZXNU5Do/zu7pv6uUoh4tK2y3pDLJ0DhphVdwxmToPFfO401PS7mzIQPh9tEokyFzemv0sDgZTpXMo9mmJLXPGAAAQNWQDFP+ZJiOIJ1rMrRv6+VNvPsePfuhMS605INSM44mTXYy92ToGmqoD7BKyZQAACAASURBVKG0T4ieDO3hl8OSybCo3ZI8Cc2zW/8VnC0Zus+Vc59qJ+XPRudk5PmPGrqJa4bTJsOpC4YRyRAAAIBkqAuSDI1qTPmaodX5pd7aLqdm6F8hWwcb5Y3DnKJmOIWcI8rtVc4BTrB+XrtR8bmarGbo7Kd8OtGIcP7nDEse1HSjSWd8h6G/0bXmcevJaXO//33mLwUAAFcXyTA1QzK80X+WJkN7hTxyIhA9HOo3+vYr3TonaXKwU6W+dNEW8Zyhfbz6aNvyaSd5yq5cMixsV/XN8/I95xH5exWVuIKZTsrNrTGukyZDu135JfR86zJXwXjY1XgUNtvJqecmdc5A4zdLwTAqKlTe2xk294/v3SEWAgCAq4xkmDu/qIyIam5SGQ4zs5hqRUJZNky3LVc/lLf1makgrZvyvNGGxqLyo0ln5H+Tnn4s9pyc/qX2QaWBZNxoMiumNQOq0at+9/D4fDQ8H/zo08yGsgPDoz0ZWlSqyWvXOGo7GfqPKK9XauabwiuYN2+t5yoUniuj28OTQ+O/UJS9Cjlzn+a9z7D8Oxidb63wmLFgGHnfWiHudBr7w0bT/fpEAACAK4NkGNLVe60fMLtJZ1eatWDofdP9WvO4udOZeucAAACXBckwJJIh4GQPal0cXnMPAAAQkQwDyozom/AdCQAAAAAwRyRDAAAAAKg6kiEAAAAAVB3JEAAAAACqjmQIAAAAAFVHMgQAAACAqiMZAgAAAEDVkQxTYvP264P1i92beSs83o1fH6yrnxf3b0zcxBLf0rayxN89FN/9Qnzxvr2IN8sBAAAAQZAMU/5k2Ly/dtFb698V0+9f7PXPzzqb0+/hshMPn9z40y/Fd13xxRNnMhSbh8fng20x40keEb8BAACAiZAMy3q8G1/0bj+eIbRsdM9ILJJ46E6G0cxlw43u2fBob+rNAQAAgGoiGUZRFIm7t170kpGiF89uNbPxr3l/TR9Emrdaoc5JJvNsH41OX7467n600T07fflK/hihSGweHp+P5KKhVW/MLh30j0b9neIuiZ2Bas746e8I/9KJjtfXh/xkKHYGwxnKhhvdM8ajAgAAAJMiGaaEuNF/FudFvhlrhmLz8NiKdhvds+OTTCFRT49iZ6CnQZkDVTyTwybTf+4M5hveFko8fCK+aroXuU5UeSRDAAAAYAokw9Rik6GrFGaPLxVirz9erXPiKhKO11/NpxZlIdT4sYd3+pJhNvFOimQIAAAATIFkmAqSDO0YIwOhHhG1HmY+NEZ+lkxEqzKadN7JkLlnAAAAgKmRDFNBRpMa9bTyNUOr8zOV2paM0aQAAADASiEZphaaDCNrBpooiuTcM3o41ION/fLDzkma/exUqS9dcb5kyAw0AAAAwNKRDJNA6Jl91HjBfbI057WHHvZThTLG6M/m2SvkjRc1FpUfTRqQfMf9jT/9Uv8xJimd/a0Vq38eAAAAgFVDMlwee84YYoxh9jfd8z5DAAAAYAokw6UyBoiSDA0zFgwj5qEBAAAApkIyDCYziJQyFwAAAIBwSIYAAAAAUHUkQwAAAACoOpJh4HYBAAAAIDiSYeB2AQAAACA4kmHgdgEAAAAgOJJh4HZ1QtQa7VY9dr/Nz78Ui1ZvtVv1OHQvAAAAgIUgGQZuVxfXW+1Gbjf8SydqZWtrq92qz76rBe1c7kRqr0wYnj0Z1lvtra2tKxwvhag12m154S7FYS70bwEAAOByIRkGbldZZsFQxPXWwu6GZ9y5kAlYLCkNyrSm4oGI661FZpu43lr9yDT712PVDtNzRAv9WwAAALhESIaB21WWUzCUVj0ZLvFO3dmcqDXmeLZ1qxaZnEiGAAAAFUQyDNyutIiCoT60b2trq1FP74Dl3bA+aLNRy+y81kg3bFsVPM+eI+1WW+2/5IhQvV6n6AFDX8HYp6g11IGo38uMEhQyBQohD0o2pydDzwhJ2VC73ahpHTPOpH6SW/XYiEx5R6QqmWpv6UGpjmW2bTQabaPpkqda39a4ssZpVEtVV9V+jCCdlwz936s8cit59gq/GEZn/EcUlfhbAAAAqAiSYeB2pbkXDOW9cporRK3Rbrf1ZKj/M8lEwtmcqDX0m3j/nqNsEUbUapOOC82r4RidNLohyQiR5pZyrddbrXosRFxvtVoq09rBxvlhcviZpJQ9k9qxGM8Z+o9I9irvzIjxVVG7Kh9pCrctqLBZmdxO4Hkn0PO98pMXxziZeWVJeV7NbvuOKPdvAQAAoDpIhoHbjRZTMJTb5LZo3SirHKJqaJn1tRqaf89q53ZiLCnvJt6flFTfphgFKvc8Lh216nFyCozVPMlQX9l/JvWz5z+iuN6Su623ktMoao00VXq/FXppzq6kFX6j/AMsjdwlnwo11rHPVeH3ys/I2Hk7zOv/RKNJ7esCAABQBSTDwO1Gi3nC0JltFF8ydA3p1Afg+fes72G6R/XcD/45c4X1YWHfnORWej6cMBlm+pA5k/nFtMIjSn6N661W3ZlX1fhSe3RlIf+2/mSoh+G8aOdIhkXfKz/nyc+G8LZntyRDAACAQiTDwO0uaErS+dYMy+850iYXLVyzZN+MHnrWnC4ZxvVWq9Fojety7UbNmQ0mToaz1QyFLBHWW+rpxHor97rYpcvy7G0LJ2VRFby8EFWyZlie/d9HjAdE/f0nGQIAABQiGQZud0FTktrPg8VyVGJOOUu/G7afHNPH8vn3bOx8incA+p4zNPvseM5winQkao1WSy/ltZ3Pv02aDCPr8slpTjLPGXqPqN5qtKxnIJ17trf1KNxWf3FIckIcqSyZuCavCce58n6vCvtsVKHzqq/OYcyeIyIZAgAASCTDkO0u9B2G5oSN2gNsySdaycUYVahP1egem+fas9pwuncDGkMcJT2xGL3S92k/WVf+EUdjChbjOTrPM3vpfKHtVj12n8nMbJzjOTBVLPEcUZQNTkbGNjYseYbLb5s3C2imb9aX0/98o910+WukRvk6tzW+OY16vWXFe+cRlflbAAAAqAiSYch2F1QwBBZtyV/OvNdgAAAAYF5IhoHbBS6dGavZUyAZAgAALBrJMHC7wCVijBddzkvhM4NIqaIDAAAsBskwcLsAAAAAEBzJMHC7AAAAABAcyTBwuwAAAAAQHMkwcLsAAAAAEBzJMHC7AAAAABAcyTBwu1dV52R03P0odC9QCc37axe7N6dbCgAAAIlkGLjdy2uje3b68pX8GZ6fdTYzLzBwJkMh9vrnI7nJ1ciNV+CIOiejJXfe/82RxM5geHKof9Lqffz064ePPvmeaDWffv3w86+aH4hkQyFuPu+t9e+6X6HhX+rfcxRF20f8Nw4AAFAJJMPA7V5SYvPw+HywLaZ8nd1G9+yK3W0v4ojE5uFxNh2li3YGKlypn/7OSlwOGTXzulTmmyPEXt9KjB88/fjp1w8ftIR4f+PRVx9/3tvQl85SNvTvecavOgAAwGVBMgzc7iXlCS1lkAzLKHOS59LuvDovNg+Pz9MKm/HP9MMSBzW01rnzSfvzr9qt94UQ9x589fHnT+9ldjtD2dC/54iyIQAAqAaSYbB2t4+SUXz64DrHbfR4sKI97i67dNA/GpWpGjnLTeWLTnqjdrdLjq7MiyLynKgjUoUa2efh+WBba13vrdGr4dFeZsOTQ1nIGh7tqcPXN89rtzznEeX1yrmCfgX105hu7gpUdruF5yrKjueU30B9J7lXYdwr+VVUnVfr2AlKbB4ej7+3/m+OzjkU+c4nbTXOs9X7+NEn3zNWmLpsWLhnsTPwfCuE2P5gf9h6cvpBnboiAAC4xEiGIdvd6J4dn2TKI/o9sdgZ6GlQ3lirW3x5m57+c2cwy3jCSRVWfvxlKOfSje6Znp2M23F5vMNMzHA/ohZF0fbRSJ1VvXLVORnJfeo797dbUpmym96rqMQVnLpm6D9XRkXOeM6w8Gx0TkZqhcx5Fnt913kz4mLhQfmvrG/D2Z42nLpLJEMAAHA1kAxDtmuPmtNvrzsnriJh5kZ8mhvouZh7MnTmCrEzSKt/2RwVuc6Ps3v67yqlqIfHCtstqUwyNE5a4RWcMRk6z5XzeNPTUu5syEC4fTTKZMic3ho9LE6GUyVzaUGTlNrnEwAA4OohGYZs13lbL2/i3ffo2Q+NcaElH4WacTRpspO5J0PXUEN9CKV9QvRkaA+/HJZMhkXtluRJaJ7d+q/gbMnQfa6c+1Q7KX82Oicjz3/U0E1cM5whGS6obEgyBAAAVUAyDNmuMXIvmqRmaFjyzetyaob+FbJ1sFHeOMwpaoZTyDmi3F7lHOAE6+e1GxWfq8lqhs5+yqcTjQjnf86w5EFNPZpUWkTZ0N+lteZx68lpc7//feYvBQAAlxnJMGS7ciIQPRzqN/r2K906J2lysFOlvnTRFvGcoX28+mjb8mknecquXDIsbFf1zfPyPecR+XsVlbiCmU7Kza0xrpMmQ7td+SX0fOsyV8F42NV4FDbbyannJnXOQFPSIsqG/jLmvZ1hc//43h1iIQAAuNxIhiHblbf1makgrZvyvNGGxqLyo0ln5H+Tnn4s9pyc/qX2QaWBZNxoMiumNQOq0at+9/D4fDQ8H/zo08yGsgPDoz0ZWlSqyWvXOGo7GfqPKK9XauabwiuYN2+t5yoUniuj28OTQ+O/UJS9Cjlzn+a9z7D8Oxidb60ob+5lQ89bK8SdTmN/2GhuOJcCAABcIiTDkO1evdf6AbObcXal+ZYN/W+6X2seN3c60/UTAABgpZAMQ7ZLMgSc7EGtofCaewAAUBEkw2DtZkb0TfiOBAAAAACYI5Jh4HYBAAAAIDiSYeB2AQAAACA4kiEAAAAAVB3JEAAAAACqjmQIAAAAAFVHMgQAAACAqiMZAgAAAEDVkQxTnZPR8HywLUSoDgAAAABAECTDjO2jUX+HZAgAAACgWkiGGdtHo+PuRwE7AAAAAADLRzLMIBkCAAAAqCCSYQbJEAAAAEAFkQxNzEMDAAAAoGpIhhnUDAEAAABUEMkwg2QIAAAAoIJIhhkkQwAAAAAVRDLM4H2GAAAAACqIZJjqnzP3DAAAAIAqIhkCAAAAQNWRDAEAAACg6kiGAAAAAFB1JEMAAAAAqDqSIQAAAABUHckQAAAAAKqOZAgAAAAAVUcyTInN268P1i92b+at8Hg3fn2wrn5e3L8xcRM7g+HJ4WzdnKfto9Hy+yP+7qH47hfii/ed/TnufrTk/gAAAAAgGab8ybB5f+2it9a/K6bfv9jrn591Nqffw9wtORmKh09u/OmX4ruu+OKJMxmKzcPj88G2WNQpEmKvfx4gDAMAAAArjmRY1uPd+KJ3+/EMoWWje7ZqmWT7aDQ82lt+u+KhOxlGCy4bbnTPghwvAAAAsOJIhlEUReLurRe9ZKToxbNbzWz8a95f0weR5q1WqHOSyTzbR6PTl6+Oux9tdM9OX76SP0YoEpuHx+cjuWho1RuzSwf9o1F/Z7Iu2clQ7AxUZ4yfSXfu4UmGYmcwXFjZcKN7xmhVAAAAwEYyTAlxo/8szot8M9YMxebhsRXtNrpnxyeZQqKeHsXOQE+DMgeqeCYHRqb/3BlMEd5C1dDEwyfiq6Z7ketEzQvJEAAAAHAiGaYWmwxdpTB7fKkQe/3xap0TV5FwvP5cnlqcezKUhVDjx27ClwyziXe+SIYAAACAE8kwFSQZ2kFFBkI9Imo9zHxojPycIvPYHVjeaNLlJkPmngEAAAA8SIapIKNJzcf8StcMrc4vsNQ2d4wmBQAAAFYKyTC10GQYWTPQRFEk557Rw6EeXeyXH3ZO0uxnp0p9aRlJGW2Rb4nIbdqTDJmBBgAAAFg6kmESCD2zjxovuE+W5rz20MN+qlAGFf3ZPHuFvPGixqIpRpMuPxnKd9zf+NMv9R9jktJFv7WCZAgAAADYSIbLY88ZQ1AxLPpN97zPEAAAAHAiGS6VMUCUZGhYaMEwYh4aAAAAIAfJMJjMIFIKWQAAAADCIRkCAAAAQNWRDAEAAACg6kiGgdsFAAAAgOBIhoHbBQAAAIDgSIaB2wUAAACA4EiGgdvVCVFrtFv12P02P/9SAAAAAJgayTBwu7q43mo3crvhX4rZxfXW1lg7aAiXPWm36qE6UEFhr3691d7a2mrV42U2CgAAoCMZBm5XoWBYSMT11sLCkpDJWyz1DHuOaKEHu5oCHnKQq2+I6y2SIQAACIhkGLhdhYJhoYUnw6XHEpKhLnAyDH22SYYAACAskmHgdqW5FwxFXG+12+noOC1Vilpja2ur3W7UtHUaNaG11dYH1KldlYymetPtdqPRaKudW0szByU7JjujfpcjKlWvdBMNtvS1mz1XUpl79FojGQGoD0TUN/RdhaIjkllF37N+Gic8XvMqyJ6rpapWNssRRd4rOOPZsI6o7DdnohNVeMh6u8aI3+Sf6q/G+1emb6JaJBkCAICwSIaB25UWXTCsNdqZ1CFqjXY7m/3SW17jn1EUyWRapiG55zRn1hr6DbGQ/cg01DZul2U40e6wayq3TF3YKdPudDuP661Wq6WfHHnunCsbV8HfqOxkGquyh+DnvwrG12m8brp0liOKvFfQv63vbMz2zSmU17S/XXurektb2ftXJv+lbchzhgAAIDCSYeB2o6U8YWjcwhrJIcre0UbWXbt8BqtUQ97eGq3YHUuazonBUyfDMu1OnQzNeCNqjZwn1iZq1J86/DxXwdk9+Zn8fcYjirxX0L+t52zM+M2ZojNl2i2TDJ1/Zc5TKq/ZdP0HAACYHckwcLvRYgqG9vA8q2aYuTE17oD1m1o9NpRqejyczxiY584k1oe1Rm4KnS68lWx3+pqhdTefDQC5V8Hf6CzJMPJcBdfgSWNU5CxHFOVfwanPxuzfnELOpgvbLZEM3X9lzuYYTQoAAMIiGQZudxEFQ7tY4aoZ+pJhpNWOJgok/p6UrPzMNxmWbHf6mqHxrN343BZeBX+jMyZDq0vjnJ9fAJzLEUU5V3DGszHjN6fQwmqGOcmQmiEAAFg9JMPA7S6sYJjedybPO02YDJNb+cZkBUO7w/pIVPt5RXucakEyVOUaeVAlJ8Up0e7UyXArO5mKqvwUXgX/Ec2SDCe9CvoI0hmPKPIlwxnOxmzfnEK+5wzz29UfHTSeKrQPOcpeQeMaydNOMgQAAAGRDEO2u7gnDI3BhI16vdVuy4lG0skb2616LPQxfsaNaVxvTfrKb326xbx95i3VJ8zMG6mYN2fmpB3LTD6ZPVfJGSuXMWRqykz1qSfw/KvgPyL1YVsr1pU/6kmvgt7nWY7IfwWnPhvOPk/6zclTePU97RpLGzWhJpIp81dmnGQ7kwMAACwTyTBku4ueknRGwTuw+q7es2FX74gAAABQBskwcLsray5zol55Vy9HXb0jAgAAQBkkw8DtriBjbN7Uz25deZnRgFeiuHr1jggAAAAlkQwDtwsAAAAAwZEMA7cLAAAAAMFde/DgwfoqqdVqlWoXV9U1aEJfDQAAABQgGQZuF1dV6Cy2WkJfDQAAABQgGQZuF1dV6Cy2WkJfDQAAABQgGQZut5q++MNocPDD0L1YrNBZbFaPvh39dv/mvPYW+moAAACgAMkwcLuziOP4F/8c//lHceiOOHx48N3py1fyZ3j+3RetTCedyTCO939+PpKbXIHcOEuO2vhydPry1RyD2RQWnQzjH38z/MPPln9d5i7+aOfGd7+48S//21706W+u/n8BAQAAVwbJMHC7s4jj+NtefPFPK5cM49bPBufffBpP2bEPD767AvfTM0ap/7l/OlMwu/6T3377kxn7MEfGyYnj/Z9b/70grCm+dfFnT2/86Zfiu3+99S9Pnclwxj8EAACAZSIZBm53FiudDGcoB5EMr131ZPjhwXerVjCc5VsXf+ZOhuuUDQEAwOVBMgzZ7uf/FL8+WH99sH7xT3H6ey/+fFxk+D8/Sj40PpfjSNUi9SNHlqpdfduM9TXVuFNPu3Ez3VbfT8kjils/G4xHhKofdWdccrxo3j36p78ZaSNU01JM/ONvkk+01n/+47TPRq+Gv9nPbPiHn33xh5H8XH5ibJ7Xrl8Sia7/5Lfjpofnv+59Oep9eO3atWv/c//09OWr4Ti8Jf88P310/Zr65Lf7N699+GvVtBkUc/Z87doPe9YlGOopcbzP3ofp79oK6eZmix/+Wra1oTU9bjTt9rhLp4+uJ7vqfWgmQ2M4sTzDg4Mf6oOQje+AfhHt8cnZpd/8/Dcj/QqWsaBkGP/4G893Jo4/3dgftp6cbvzdyv33HQAAUDUkw8DtyrpfGszi+NterAc8lcqMf657a4Yy4KmV4x/Ef+5lnkj0tCu3/fM/x3LzuBlf9OJf/GCCO9fCmqH/Lty59MOD71SiW7duuGXmVIEhbv1skD9Y8dPfjFTBSiYK2dwXfxjJfeo797froVJWmp0+/HUmSlllvUffZpPht6fD819vpEv1B/+8e3bt3CAfZUyz6Ic/3MiukFO0/GHvfJRudf0nv82m2TRhXv/Jb7U19TPjvDofHnw3+EOmkKinx/jH3+hpUF41lf3k1U//+eNvjGxfxozJUPxf97b+ryLJEAAArA6SYeB2k3Sn1QOTz2U8y2a5X/xzfPHP8f/RKoczJkO7Xbtpe9vig5p3Mozj/Z9beSz+8Tdp9S+bDdbX17/4Q/7tuNY9/Xc18E89HlbYrsc4R6XByVSUDIdmtPthLw2K3j27dm7Y+HI0/PKHnhU8yVCPoFqf9e6N++BMhq50bY8v1U++fTUzF3Hapxb1InamxDrhw4G+ZGh9MwEAAFYTyTBwu3npTh9Hqv8YY0pnTYZTbVt8UHNPhq5BqnIg6PhwzAinZwk7AAxLJsOidj2SdKQNBzXHZxbWDK1gpq/g27Nr54aNL0fGQFBDfjLMxL+0S44W0/iauZo5ydD+SsiL6M7n2Q/VMOCp57ZdVM2QZAgAAC4JkmHgdvMSmhHPJtrW3vzSJ0NXNvCvoJKhfWs+Y82wJFfayhbcZqoZevfszmkZ80+G5WuGOaNJjUps+ZqhYbowFmQ06Z1/GLSenDb3f/6/mL8UAACERjIM3G5uMpRjR7UH/GRCs+ehUdvqEU7+njwoOJ6E5vImw3XX6+/08YdFydB6IrFcMixsV/XNnhZFhitjxOajb7PJ8FyPVSNzBppvM+FQf86wYM/JzvWhp+bY0QUkQ7NXj751P2e47nqhpZx7Rg+H+tfAvgpf/CHNfnaq1JeWtKhk6H0w9QefDZv7gx+8TywEAADhkQyDtavmgDEGi+pzvRhjSu2ZYIyd6ElPzTJ60Yt/0Yz/LOeb+afY367aKpna9AfJhsbOcw8qO6jPmOdTn+TTninUv3R9HB4cI0LHjcpsZs+AavTq5wc/G5yPhufffLKb2VB2YPibfTmIVCW9vHaNo3YmQ+NwjKylr9D78Nqjb5MX3Ks33esr6NsW7tlYR18qd543c6m99PTlqyTvqYlMk7znmMVU3/y3+z9xjiZdd6VrGcwy08BaK+SNFzUWLW00afKO+z/9MvOTnaTU89aK+P0vNveHm//w4aRdBQAAWASSYeB2cVX56nFV4X7OcN01Z8zVeImlwf+m+zv/MGh+9sWSuwQAAJCHZBi4XVxVoVPZCvjw16oaaZ8fY4DolUyGvOYeAABcIiTDwO3iqgobyoK5/pPfpm+cT59I9J+rzCDSEm8EAQAAwNyRDAO3i6sqZDxbPaGvBgAAAAqQDAO3i6sqdBZbLaGvBgAAAApce/DgQbRKarVa6C4AAAAAQLWQDAEAAACg6kiGAAAAAFB1JEMAAAAAqDqSIQAAAABUHckw1TkZDc8H20KE6gAAAAAABEEyzNg+GvV3SIYAAAAAqoVkmLF9NDrufhSwAwAAAACwfCTDDJIhAAAAgAoiGWaQDAEAAABUEMnQxDw0AAAAAKqGZJhBzRAAAABABZEMM0iGAAAAACqIZJhBMgQAAABQQSTDDN5nCAAAAKCCSIap/jlzzwAAAACoIpIhAAAAAFQdyRAAAAAAqo5kCAAAAABVRzIEAAAAgKojGQIAAABA1ZEMAQAAAKDqSIYAAAAAUHUkw2Li7q0Xvfj1wfrrg/WLZ7eavPAQAAAAwNVCMixLiBv9Z3GQZCjEXv98NDw5XHK7AAAAACqCZFhWwGS40T0bHu0tuVEAAAAA1UEyTDTvr8nxoq8P1i96tx9b8c+TDMXmbbWt/Hlx/0b5PRfa6J4ddz+a4qAAAAAAoAySYRRF0ePd+PXB+vNN4fynlJcMZSxUK8uHElUyLLPnQiRDAAAAAAtFMkyinV7lc4ZAfzK0S4Xl91yIZAgAAABgoUiGmdGe+o8x8tMT6mQlUNtwrX9XlN+zB3PPAAAAAFgCkqE5HDR3tXLlPpkG5Wol91yImiEAAACAhSIZjiPfuNAXjZ8VLFkzfLyb+VCIm8978cXuzfJ7LkQyBAAAALBQJMOEMfJTxTmZ7hwjQsdp0BhKaj9tmLfn8kiGAAAAABaKZHgJ8D5DAAAAAAtFMrwEmIcGAAAAwEKRDAEAAACg6kiGAAAAAFB1JEMAAAAAqDqSYeB2AQAAACA4kmHgdgEAAAAgOJJh4HYBAAAAIDiSYeB2dULUGu1WPRZTLF2+eqvdqsehewEAAABgDkiGgdvVxfVWu5HbDf/SiQhRa7TbW1tbW1tbU6c7kiEAAABwZZAMA7erBCkYxvUW6Q4AAAAAyTBwu8rSCobGbkmGAAAAAEiGgduV5lswrDXacphoXG9tjTkToDMZirjeGo813draMhKpZySqqDW2trba7UZN20OjVqrbhdvm9SrZsFWvt9ryc/mJsbk8J8m27UZNrMrjmgAAAMAqIBkGbleae8EwrrdarVa7VVefOB8LLFMzrDXa+n7828rc2B7nWBHLZsuFw0m21XslQ6PsTL3VlsFP1BoqARonUF8EAAAAICIZBm83WswTGwTk7QAABotJREFUhjJVWfsx41CZZCjiemvCZKgX6+qtyZJhyW31Xum/y5OVfCgjouvA5WdlegUAAABUAckwcLvRYp4wdMY2O2h50t2WZsKaYSaGTZgMc7f19KogGWaHofoPCgAAAKgmkmHgdhc0JamdJ0vWDO3C3eQ1w/knQ3+vpqgZAgAAANCRDAO3u6ApSeXcM/q2ziCXkwzTHJU8+7cSyTC3V/5kGMmxo9lDsEfbAgAAAFVGMgzZ7uLeYShjW2ZCTi0I6Z/nzfapNOr1VrutpmzxbKs2lLPIeGYxdRxs0bZ5vbpzJ7Oh7F67UZODSNV8Nvo0rQwlBQAAAAwkw5DtLu4dhryoEAAAAEB5JMPA7S4IyRAAAABAeSTDwO0uQmYQKe9mAAAAAFCEZBi4XQAAAAAIjmQYuF0AAAAACI5kGLhdAAAAAAiOZBi4XQAAAAAIjmQYuF0AAAAACI5kGLjdauqcjI67H4XuBQAAAIAEyTBwu7MQ4kb/Wfzi/o3QHXHY6J6dvnwlf4bnZ51NoS91JkMh9vrnI7kJuREAAABYJpJh4HZnIcTN5734Yvdm6I6YxObh8flgW4jiVV02umckQwAAAGCZSIaB253FSifDk8OpNycZAgAAAEtGMgzZ7uPd+PXB+uuD9Yvdm+nvvduPx9W25v01+aHxuRxHqhapHzmyVO3q+abQ11TjTj3tis3balt9PyWPSGweHo9HhKofFfNKjhfNS4bbRyNthGpakxQ7g+QTrfX+Ttpno1fDo73MhieHnZOR/Fx+Ymye1266f7H9wf6w9eT0g/qUZVIAAAAgLJJh4HZl3S8NZuLm816sBzyVyox/Rt6aoQx4amVx99aLXuaJRE+7ctsXz9bk5mLz9kVvrX93gsxTWDP0VwWdSze6ZyrRRVEkdgaZcCj2+ucj9UCj2Dw8th5uVLaPRsNx92RolM11TkZyn/rO/e2OWycZAgAA4HIjGQZuN0l3Wj0w+VzGs0yWu9F/Fl88u9VM49CsydBu127a3rb4oOadDIXY69t5bGeQVv/EXv98pBf6Oie5yVDvnv779lESEdVzkoXtAgAAAFcDyTBwu3npTh9Hqv9kx5TOnAyn2rb4oOaeDF2DVOVA0PHhmBFOT4b6KFZzQ38yLGoXAAAAuBpIhoHbzUtoRjybaFt780ufDF21O/8KKhna5cQZa4a2teZx68lpc7///WmnYwUAAADCIhkGbjc3Gcqxo9oDfjKh2fPQqG31CCd/Tx4UHE9Cc3mTYSTHcGb3udE9K1MzNBYlTySWS4aF7Ur3dobN/eN7d4iFAAAAuKxIhsHaVXPAZAeLZuZ6McaU2jPBGDvRk56aZfSit9bfvPVCzjeze9Pfrtoqmdr0brKhsfPcgxrP7an/qHqdPsmnPVOof2kURRvdM/eI0HGjcgYaewZUo1f97uHx+Wh4PvjRp5kNZQeGR3tyEKmazyav3aT1O53G/rDR3Jjg2gMAAAArhmQYuF1cdmvN4+ZOJ3QvAAAAgJmQDAO3CwAAAADBkQwDtwsAAAAAwZEMA7cLAAAAAMGRDAO3CwAAAADBkQwBAAAAoOpIhgAAAABQdSRDAAAAAKg6kiEAAAAAVB3JEAAAAACqjmSY6pyMhueDbSFCdQAAAAAAgiAZZmwfjfo7JEMAAAAA1UIyzNg+Gh13PwrYAQAAAABYPpJhBskQAAAAQAWRDDNIhgAAAAAqiGRoYh4aAAAAAFVDMsygZggAAACggkiGGSRDAAAAABVEMswgGQIAAACoIJJhBu8zBAAAAFBBJMNU/5y5ZwAAAABUEckQAAAAAKqOZAgAAAAAVUcyBAAAAICqW7lkCAAAAABYMpIhAAAAAFQdyRAAAAAAqo5kCAAAAABVRzIEAAAAgKq7FkXRqoXDzglvnAcAAACA5bkm/2fVwuH20ai/QzIEAAAAgGW4pn5bqXC4fTQ67n4UuhcAAAAAUAnX9H+sTjgkGQIAAADA0pAMAQAAAKDqrj0Yi1YpGUbMQwMAAAAAy0LNEAAAAACqjmQIAAAAAFVHMgQAAACAqkufM1RPG64C3mcIAAAAAEtzbXXSoNI/Z+4ZAAAAAFieVUyGAAAAAIBlIhkCAAAAQNWRDAEAAACg6kiGAAAAAFB1JEMAAAAAqDqSIQAAAABUHckQAAAAAKqOZAgAAAAAVUcyBAAAAICqIxkCAAAAQNWRDAEAAACg6kiGAAAAAFB1JEMAAAAAqDqSIQAAAABU3f8HxnFyixg4DL4AAAAASUVORK5CYII=" alt="" />

修改之后的完善版本

 package com.tommy.business;

 import org.apache.commons.fileupload.FileItem;
 import org.apache.commons.fileupload.FileUploadException;
 import org.apache.commons.fileupload.disk.DiskFileItemFactory;
 import org.apache.commons.fileupload.servlet.ServletFileUpload;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.multipart.MultipartFile;
 import org.springframework.web.multipart.MultipartHttpServletRequest;
 import org.springframework.web.multipart.commons.CommonsMultipartFile;
 import org.springframework.web.multipart.commons.CommonsMultipartResolver;

 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.*;
 import java.net.URLEncoder;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 /**
  * Created by OnlyOne on 2016/3/4.
  */
 @Controller
 @RequestMapping("/background/uploadAndDownload/")
 public class UploadAndDownloadController {
     /**
      *
      * @param req
      * @param resp
      * @throws ServletException
      * @throws IOException
      * @throws FileUploadException
      */
     @RequestMapping("uploadFile")
     public String uploadFile(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException, FileUploadException {
         /*//防止中文乱码，与页面字符集一致
         req.setCharacterEncoding("UTF-8");*/
         //得到上传文件的保存目录，将上传的文件存放于WEB-INF目录下，不允许外界直接访问，保证上传文件的安全
         String savePath = req.getServletContext().getRealPath("/WEB-INF/upload");
 //                            this.getServletContext().getRealPath("/WEB-INF/upload");
         //创建保存目录的文件
         File saveFile = new File(savePath);
         //判断保存目录文件是否存在,不存在则创建一个文件夹
         if(!saveFile.exists()){
             System.out.println("文件目录创建中。。。");
             saveFile.mkdir();
         }
         //消息提示
         //将req转换成Spring的request
         MultipartHttpServletRequest multipartHttpServletRequest = (MultipartHttpServletRequest) req;
         //获取上传文件
         List<MultipartFile> list = multipartHttpServletRequest.getFiles("file");
         //获取普通输入项的数据
         String map = multipartHttpServletRequest.getParameter("username");
         System.out.println(map);
         for(MultipartFile multipartFile: list){
             if(!multipartFile.isEmpty()){
                 //得到上传的文件名称
                 String fileName = multipartFile.getOriginalFilename();
                 System.out.println("文件名是："+ fileName);
                 if(fileName == null || fileName.trim().equals("")){
                     continue;
                 }
                 //获取item中的上传输入流
                 BufferedInputStream bis = new BufferedInputStream(multipartFile.getInputStream());
                 //创建一个文件输出流
                 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(savePath + "\\" + fileName));
                 //创建一个缓冲区
                 byte[] buffer = new byte[1024*8];
                 //循环将缓冲输入流读入到缓冲区当中
                 while(true){
                     //循环将缓冲输入流读入到缓冲区当中
                     int length = bis.read(buffer);
                     //判断是否读取到文件末尾
                     if(length == -1){
                         break;
                     }
                     //使用BufferedOutputStream缓冲输出流将缓冲区的数据写入到指定的目录(savePath + "\\" + filename)当中
                     bos.write(buffer,0,length);
                 }
                 //关闭输入流
                 bis.close();
                 //关闭输出流
                 bos.close();
             }
         }
             return "redirect:listFile.html";
     }

     /**
      * @ClassName: ListFileServlet
      * @Description: 列出Web系统中所有下载文件
      * @param req
      * @param resp
      */
     @RequestMapping("listFile")
     public String listFile(HttpServletRequest req, HttpServletResponse resp) {
         String flag = req.getParameter("flag");
         //获取上传文件的目录
         String uploadFilePath = req.getServletContext().getRealPath("/WEB-INF/upload");
         //存储要下载的文件名
         Map<String, String> fileNameMap = new HashMap<String, String>();
         //地鬼遍历filePath目录下的所有文件和目录，将文件的文件名存储到map集合中
         getListfile(new File(uploadFilePath), fileNameMap);
         if(flag != null){
             req.setAttribute("flag",flag);
         }
         req.setAttribute("fileNameMap", fileNameMap);
         return "/background/uploadAndDownload/resourcesList";
     }

     /**
      *
      * @param file 即代表一个文件，也代表一个文件目录
      * @param map  存储文件名的Map集合
      * @Method: listfile
      * @Description: 递归遍历指定目录下的所有文件
      */
     private void getListfile(File file, Map<String, String> map) {
         //如果file代表的不是一个文件，而是一个目录
         if (!file.isFile()) {
             //列出该目录下的所有文件和目录
             File files[] = file.listFiles();
             //遍历files[]数组
             for (File f : files) {
                 //递归
                 getListfile(f, map);
             }
         } else {
             /**
              * 处理文件名，上传后的文件是以uuid_文件名的形式去重新命名的，去除文件名的uuid_部分
              file.getName().indexOf("_")检索字符串中第一次出现"_"字符的位置，如果文件名类似于：9349249849-88343-8344_阿_凡_达.avi
              那么file.getName().substring(file.getName().indexOf("_")+1)处理之后就可以得到阿_凡_达.avi部分
              */
             //String realName = file.getName().substring(file.getName().indexOf("_") + 1);
             //file.getName()得到的是文件的原始名称，这个名称是唯一的，因此可以作为key，realName是处理过后的名称，有可能会重复
             map.put(file.getName(), file.getName());
         }
     }

     /**
      * 下载文件
      * @param req
      * @param resp
      * @throws ServletException
      * @throws IOException
      */
     @RequestMapping("downLoadFile")
     public void downLoadFile(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
         //得到要下载的文件名
         req.setCharacterEncoding("UTF-8");
         String fileName = req.getParameter("fileName");
 //        fileName = new String(fileName.getBytes("iso8859-1"),"UTF-8");
         //上传的文件都是保存在/WEN-INF/upload目录党徽宗
         String fileSavePath = req.getServletContext().getRealPath("/WEB-INF/upload");
         //得到要下载的文件
         File file = new File(fileSavePath + "//" + fileName);
         //如果文件不存在
         if(!file.exists()){
             req.setAttribute("message", "资源已被删除！");
             req.getRequestDispatcher("/message.jsp").forward(req, resp);
         }
         //处理文件名
         String realName = fileName.substring(fileName.indexOf("_")+1);
         //设置响应头，控制浏览器下载该文件
         resp.setHeader("content-disposition", "attachment;filename="+ URLEncoder.encode(realName, "UTF-8"));
         //读取要下载的文件，保存到文件输入流
         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(fileSavePath + "\\" + fileName));
         //创建输出流
         BufferedOutputStream bos = new BufferedOutputStream(resp.getOutputStream());
         //创建一个缓冲区
         byte[] buffer = new byte[1024*8];
         //循环将缓冲输入流读入到缓冲区当中
         while(true){
             //循环将缓冲输入流读入到缓冲区当中
             int length = bis.read(buffer);
             //判断是否读取到文件末尾
             if(length == -1){
                 break;
             }
             //使用BufferedOutputStream缓冲输出流将缓冲区的数据写入到指定的目录(savePath + "\\" + filename)当中
             bos.write(buffer,0,length);
         }
         //关闭文件输入流
         bis.close();
         //刷新此输入流并强制写出所有缓冲的输出字节数
         bos.flush();
         //关闭文件输出流
         bos.close();
     }

 }