FileUpload

就是将本地的文件上传到服务器上面去。就是利用请求报文，将文件的二进制数据放在里面，然后传输到服务器，服务器进行解析，获取里面的资源

二进制数据是在哪里？请求体

哪个API是获取请求体的？

request.getInputStream()

文件上传准备

1.form表单 method = post

2.input type=file

Content-Length: 37

该请求头代表了什么意思？

Content-Length: 11

遇到的第一个问题

仅上传文件名，不会上传文件的数据

解决方案：form表单需要设置enctype=multipart/form-data

处理文件的逻辑

  1. package com.cskaoyan.upload;
  3. import javax.servlet.ServletException;
  4. import javax.servlet.ServletInputStream;
  5. import javax.servlet.annotation.WebServlet;
  6. import javax.servlet.http.HttpServlet;
  7. import javax.servlet.http.HttpServletRequest;
  8. import javax.servlet.http.HttpServletResponse;
  9. import java.io.File;
  10. import java.io.FileOutputStream;
  11. import java.io.IOException;
  13. @WebServlet("/upload")
  14. public class UploadServlet extends HttpServlet {
  15.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  16.         //准备工作就绪之后，点击form表单的提交，浏览器会自动帮我们将文件的信息写入到请求体中
  17.         //服务器拿到请求报文，会帮我们进行解析处理，将请求体封装到指定的API中，我们只需要去调用对应的API即可
  18.         ServletInputStream inputStream = request.getInputStream();
  19.         String realPath = getServletContext().getRealPath("upload/1.png");
  20.         File file = new File(realPath);
  21.         if(!file.getParentFile().exists()){
  22.             //当前file文件的父级目录如果不存在
  23.             file.getParentFile().mkdirs();
  24.         }
  25.         FileOutputStream outputStream = new FileOutputStream(file);
  26.         int length = 0;
  27.         byte[] bytes = new byte[1024];
  28.         while ((length = inputStream.read(bytes)) != -1){
  29.             outputStream.write(bytes, 0, length);
  30.         }
  31.         outputStream.close();
  32.         inputStream.close();
  33.     }
  35.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  37.     }
  38. }

FileUpload - 图1

文件经过上传之后，多出了很多内容；如果是文本文件，就会多出了很多东西；如果是二进制数据，这些内容进入到文件内部，会直接导致文件的损坏。

这些东西哪来的？

面临的问题二

是因为如果我们需要进行文件上传，那么就必须要使用enctype=multipart/form-data，但是使用了该enctype之后，请求体里面会多出来很多的字符。对于二进制数据来说，直接导致文件损坏，对于文本数据来说，多出很多分隔符

面临的问题三

之前可以正常获取请求参数的API也不再适用了，无法获取到请求参数，请求参数会和文件一起处理到文件中。

原因在于获取请求参数的API只能够获取key=value&key=value型数据，如果数据结构发生了变化，那么就无法获取到了。

FileUpload - 图2

总结：

目前面临的诸多问题，均和引入了enctype有关，但是又不能不引入，因为如果不引入，那么只会上传文件的名称，不会上传文件的内容；需要手动地将这些分割字符剔除掉。

不要重复造轮子。

commons-fileupload jar包

引入组件之前的这些操作以及遇到的问题，是需要大家掌握的。

文件上传组件的引入（了解使用）

看着API文档，来解决你的实际问题即可。

  1. package com.cskaoyan.upload;
  3. import org.apache.commons.fileupload.FileItem;
  4. import org.apache.commons.fileupload.FileUploadException;
  5. import org.apache.commons.fileupload.disk.DiskFileItemFactory;
  6. import org.apache.commons.fileupload.servlet.ServletFileUpload;
  8. import javax.servlet.ServletException;
  9. import javax.servlet.ServletInputStream;
  10. import javax.servlet.annotation.WebServlet;
  11. import javax.servlet.http.HttpServlet;
  12. import javax.servlet.http.HttpServletRequest;
  13. import javax.servlet.http.HttpServletResponse;
  14. import java.io.File;
  15. import java.io.FileOutputStream;
  16. import java.io.IOException;
  17. import java.util.Iterator;
  18. import java.util.List;
  20. @WebServlet("/upload2")
  21. public class UploadServlet2 extends HttpServlet {
  22.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  23.         //看着API文档，一步一步完成我们的功能即可
  24.         //这行代码的含义是判断当前的请求是否是multipart/form-data
  25.         response.setContentType("text/html;charset=utf-8");
  26.         boolean multipartContent = ServletFileUpload.isMultipartContent(request);
  27.         if(!multipartContent){
  28.             response.getWriter().println("当前请求不含上传的文件");
  29.             return;
  30.         }
  31.         DiskFileItemFactory factory = new DiskFileItemFactory();
  32.         File repository = (File) getServletContext().getAttribute("javax.servlet.context.tempdir");
  33.         factory.setRepository(repository);
  35.         ServletFileUpload upload = new ServletFileUpload(factory);
  36.         try {
  37.             //items其实就是对于前端提交过来啊input的封装
  38.             //提交过来多少个input，那么这边items就有多少个
  39.             List<FileItem> items = upload.parseRequest(request);
  40.             Iterator<FileItem> iterator = items.iterator();
  41.             while (iterator.hasNext()){
  42.                 FileItem item = iterator.next();
  43.                 if(item.isFormField()){
  44.                     //当前item是常规的form表单
  45.                     processFormField(item);
  46.                 }else {
  47.                     //当前item是上传的文件
  48.                     processUploadedFile(item);
  49.                 }
  50.             }
  51.         } catch (FileUploadException e) {
  52.             e.printStackTrace();
  53.         }
  54.     }
  56.     /**
  57.      * 处理上传的文件逻辑
  58.      * @param item
  59.      */
  60.     private void processUploadedFile(FileItem item) {
  61.         String fieldName = item.getFieldName();
  62.         String fileName = item.getName();
  63. //        String contentType = item.getContentType();
  64. //        boolean isInMemory = item.isInMemory();
  65. //        long sizeInBytes = item.getSize();
  66. //        System.out.println("File " + fieldName + ":" + fileName + ":" + contentType + ":" + isInMemory + ":" + sizeInBytes);
  67.         String realPath = getServletContext().getRealPath("upload/" + fileName);
  68.         File file = new File(realPath);
  69.         if(!file.getParentFile().exists()){
  70.             file.getParentFile().mkdirs();
  71.         }
  72.         try {
  73.             item.write(file);
  74.         } catch (Exception e) {
  75.             e.printStackTrace();
  76.         }
  77.     }
  79.     /**
  80.      * 处理常规form表单的逻辑
  81.      * @param item
  82.      */
  83.     private void processFormField(FileItem item) {
  84.         String name = item.getFieldName();
  85.         String value = item.getString();
  86.         System.out.println("formField " + name + ":" + value);
  87.     }
  89.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  91.     }
  92. }

中文乱码问题

普通form表单数据乱码

  1. //这行代码针对文件上传时form表单数据乱码也失效了，也不再适用了
  2. request.setCharacterEncoding("utf-8");
  1. String getString(String encoding)
  2.           throws UnsupportedEncodingException

Returns the contents of the file item as a String, using the specified encoding. This method uses get() to retrieve the contents of the item.

  • Parameters:
    encoding - The character encoding to use.
  • Returns:
    The contents of the item, as a string.
  • Throws:
    UnsupportedEncodingException - if the requested character encoding is not available.

上传的文件名有没有可能乱码

  1. //上传的文件名如果有中文的乱码问题
  2. upload.setHeaderEncoding("utf-8");

封装数据到Bean（掌握）

  1. package com.cskaoyan.upload;
  3. import org.apache.commons.fileupload.FileItem;
  4. import org.apache.commons.fileupload.FileUploadException;
  5. import org.apache.commons.fileupload.disk.DiskFileItemFactory;
  6. import org.apache.commons.fileupload.servlet.ServletFileUpload;
  8. import javax.servlet.ServletException;
  9. import javax.servlet.annotation.WebServlet;
  10. import javax.servlet.http.HttpServlet;
  11. import javax.servlet.http.HttpServletRequest;
  12. import javax.servlet.http.HttpServletResponse;
  13. import java.io.File;
  14. import java.io.IOException;
  15. import java.io.UnsupportedEncodingException;
  16. import java.util.Iterator;
  17. import java.util.List;
  19. @WebServlet("/upload3")
  20. public class UploadServlet3 extends HttpServlet {
  21.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  22.         //看着API文档，一步一步完成我们的功能即可
  23.         //这行代码的含义是判断当前的请求是否是multipart/form-data
  24.         request.setCharacterEncoding("utf-8");
  25.         response.setContentType("text/html;charset=utf-8");
  26.         boolean multipartContent = ServletFileUpload.isMultipartContent(request);
  27.         if(!multipartContent){
  28.             response.getWriter().println("当前请求不含上传的文件");
  29.             return;
  30.         }
  31.         DiskFileItemFactory factory = new DiskFileItemFactory();
  32.         File repository = (File) getServletContext().getAttribute("javax.servlet.context.tempdir");
  33.         factory.setRepository(repository);
  35.         ServletFileUpload upload = new ServletFileUpload(factory);
  36.         //上传的文件名如果有中文的乱码问题
  37.         upload.setHeaderEncoding("utf-8");
  38.         // 1024 bytes
  39.         //upload.setSizeMax(1024);
  40.         try {
  41.             //items其实就是对于前端提交过来啊input的封装
  42.             //提交过来多少个input，那么这边items就有多少个
  43.             List<FileItem> items = upload.parseRequest(request);
  44.             Iterator<FileItem> iterator = items.iterator();
  45.             while (iterator.hasNext()){
  46.                 FileItem item = iterator.next();
  47.                 if(item.isFormField()){
  48.                     //当前item是常规的form表单
  49.                     processFormField(item);
  50.                 }else {
  51.                     //当前item是上传的文件
  52.                     processUploadedFile(item);
  53.                 }
  54.             }
  55.         } catch (FileUploadException e) {
  56.             e.printStackTrace();
  57.         }
  58.     }
  60.     /**
  61.      * 处理上传的文件逻辑
  62.      * ReflectionUtils.toBean(Object o, String key, String value);
  63.      * (user, username, admin)
  64.      * (user, password, admin123)
  65.      * (user, image, upload/1.jpg)
  66.      * 有兴趣的同学可以课后实现它 
  67.      * 反射的代码有难度，能不能反射这部分代码交给BeanUtils来做呢
  68.      * BeanUtils.populate(user, map);
  69.      * @param item
  70.      */
  71.     private void processUploadedFile(FileItem item) {
  72.         String fieldName = item.getFieldName();
  73.         String fileName = item.getName();
  74. //        String contentType = item.getContentType();
  75. //        boolean isInMemory = item.isInMemory();
  76. //        long sizeInBytes = item.getSize();
  77. //        System.out.println("File " + fieldName + ":" + fileName + ":" + contentType + ":" + isInMemory + ":" + sizeInBytes);
  78.         String realPath = getServletContext().getRealPath("upload/" + fileName);
  79.         File file = new File(realPath);
  80.         if(!file.getParentFile().exists()){
  81.             file.getParentFile().mkdirs();
  82.         }
  83.         try {
  84.             item.write(file);
  85.         } catch (Exception e) {
  86.             e.printStackTrace();
  87.         }
  88.     }
  90.     /**
  91.      * 处理常规form表单的逻辑
  92.      * @param item
  93.      */
  94.     private void processFormField(FileItem item) {
  95.         //返回的就是input的name属性
  96.         //根据不同的name属性，判断，根据不同的name属性值，调用不同的set方法，完成赋值，这个方法比较臃肿一些
  97.         String name = item.getFieldName();
  98.         String value = null;
  99.         try {
  100.             value = item.getString("utf-8");
  101.         } catch (UnsupportedEncodingException e) {
  102.             e.printStackTrace();
  103.         }
  104.         System.out.println("formField " + name + ":" + value);
  105.     }
  107.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  109.     }
  110. }

改进

  1. package com.cskaoyan.upload;
  3. import org.apache.commons.beanutils.BeanUtils;
  4. import org.apache.commons.fileupload.FileItem;
  5. import org.apache.commons.fileupload.FileUploadException;
  6. import org.apache.commons.fileupload.disk.DiskFileItemFactory;
  7. import org.apache.commons.fileupload.servlet.ServletFileUpload;
  9. import javax.servlet.ServletException;
  10. import javax.servlet.annotation.WebServlet;
  11. import javax.servlet.http.HttpServlet;
  12. import javax.servlet.http.HttpServletRequest;
  13. import javax.servlet.http.HttpServletResponse;
  14. import java.io.File;
  15. import java.io.IOException;
  16. import java.io.UnsupportedEncodingException;
  17. import java.lang.reflect.InvocationTargetException;
  18. import java.util.HashMap;
  19. import java.util.Iterator;
  20. import java.util.List;
  21. import java.util.Map;
  23. @WebServlet("/upload3")
  24. public class UploadServlet3 extends HttpServlet {
  25.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  26.         //看着API文档，一步一步完成我们的功能即可
  27.         //这行代码的含义是判断当前的请求是否是multipart/form-data
  28.         request.setCharacterEncoding("utf-8");
  29.         response.setContentType("text/html;charset=utf-8");
  30.         boolean multipartContent = ServletFileUpload.isMultipartContent(request);
  31.         if(!multipartContent){
  32.             response.getWriter().println("当前请求不含上传的文件");
  33.             return;
  34.         }
  35.         DiskFileItemFactory factory = new DiskFileItemFactory();
  36.         File repository = (File) getServletContext().getAttribute("javax.servlet.context.tempdir");
  37.         factory.setRepository(repository);
  39.         ServletFileUpload upload = new ServletFileUpload(factory);
  40.         //上传的文件名如果有中文的乱码问题
  41.         upload.setHeaderEncoding("utf-8");
  42.         // 1024 bytes
  43.         //upload.setSizeMax(1024);
  44.         User user = new User();
  45.         Map<String, Object> map = new HashMap<>();
  46.         try {
  47.             //items其实就是对于前端提交过来啊input的封装
  48.             //提交过来多少个input，那么这边items就有多少个
  49.             List<FileItem> items = upload.parseRequest(request);
  50.             Iterator<FileItem> iterator = items.iterator();
  51.             while (iterator.hasNext()){
  52.                 FileItem item = iterator.next();
  53.                 if(item.isFormField()){
  54.                     //当前item是常规的form表单
  55.                     processFormField(item, map);
  56.                 }else {
  57.                     //当前item是上传的文件
  58.                     processUploadedFile(item, map);
  59.                 }
  60.             }
  61.             BeanUtils.populate(user, map);
  62.             System.out.println(user);
  63.         } catch (FileUploadException e) {
  64.             e.printStackTrace();
  65.         } catch (IllegalAccessException e) {
  66.             e.printStackTrace();
  67.         } catch (InvocationTargetException e) {
  68.             e.printStackTrace();
  69.         }
  70.     }
  72.     /**
  73.      * 处理上传的文件逻辑
  74.      * ReflectionUtils.toBean(Object o, String key, String value);
  75.      * (user, username, admin)
  76.      * (user, password, admin123)
  77.      * (user, image, upload/1.jpg)
  78.      * 有兴趣的同学可以课后实现它
  79.      * 反射的代码有难度，能不能反射这部分代码交给BeanUtils来做呢
  80.      * BeanUtils.populate(user, map);
  81.      * @param item
  82.      * @param map
  83.      */
  84.     private void processUploadedFile(FileItem item, Map<String, Object> map) {
  85.         String fieldName = item.getFieldName();
  86.         String fileName = item.getName();
  87. //        String contentType = item.getContentType();
  88. //        boolean isInMemory = item.isInMemory();
  89. //        long sizeInBytes = item.getSize();
  90. //        System.out.println("File " + fieldName + ":" + fileName + ":" + contentType + ":" + isInMemory + ":" + sizeInBytes);
  91.         String uploadPath = "upload/" + fileName;
  92.         String realPath = getServletContext().getRealPath(uploadPath);
  93.         File file = new File(realPath);
  94.         if(!file.getParentFile().exists()){
  95.             file.getParentFile().mkdirs();
  96.         }
  97.         try {
  98.             item.write(file);
  99.             map.put(fieldName, uploadPath);
  100.         } catch (Exception e) {
  101.             e.printStackTrace();
  102.         }
  103.     }
  105.     /**
  106.      * 处理常规form表单的逻辑
  107.      * @param item
  108.      * @param map
  109.      */
  110.     private void processFormField(FileItem item, Map<String, Object> map) {
  111.         //返回的就是input的name属性
  112.         String name = item.getFieldName();
  113.         String value = null;
  114.         try {
  115.             value = item.getString("utf-8");
  116.             map.put(name, value);
  117.         } catch (UnsupportedEncodingException e) {
  118.             e.printStackTrace();
  119.         }
  120.         System.out.println("formField " + name + ":" + value);
  121.     }
  123.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  125.     }
  126. }

FileUpload - 图3

进一步优化

假如今后我们还需要进行商品发布、用户注册等其他行为，这个时候也需要使用文件上传。需要写在其他servlet中，再写一遍把

能不呢将一些代码抽提出来，形成一个工具类，后面的话可以复用。

  1. package com.cskaoyan.upload.utils;
  3. import org.apache.commons.fileupload.FileItem;
  4. import org.apache.commons.fileupload.FileUploadException;
  5. import org.apache.commons.fileupload.disk.DiskFileItemFactory;
  6. import org.apache.commons.fileupload.servlet.ServletFileUpload;
  8. import javax.servlet.http.HttpServletRequest;
  9. import java.io.File;
  10. import java.io.UnsupportedEncodingException;
  11. import java.util.HashMap;
  12. import java.util.Iterator;
  13. import java.util.List;
  14. import java.util.Map;
  16. public class FileUploadUtils {
  18.     public static Map<String, Object> parseRequest(HttpServletRequest request){
  19.         DiskFileItemFactory factory = new DiskFileItemFactory();
  20.         File repository = (File) request.getServletContext().getAttribute("javax.servlet.context.tempdir");
  21.         factory.setRepository(repository);
  22.         Map<String, Object> map = new HashMap<>();
  23.         ServletFileUpload upload = new ServletFileUpload(factory);
  24.         //上传的文件名如果有中文的乱码问题
  25.         upload.setHeaderEncoding("utf-8");
  26.         // 1024 bytes
  27.         //upload.setSizeMax(1024);
  28.         try {
  29.             //items其实就是对于前端提交过来啊input的封装
  30.             //提交过来多少个input，那么这边items就有多少个
  31.             List<FileItem> items = upload.parseRequest(request);
  32.             Iterator<FileItem> iterator = items.iterator();
  33.             while (iterator.hasNext()){
  34.                 FileItem item = iterator.next();
  35.                 if(item.isFormField()){
  36.                     //当前item是常规的form表单
  37.                     processFormField(item, map);
  38.                 }else {
  39.                     //当前item是上传的文件
  40.                     processUploadedFile(item, map, request);
  41.                 }
  42.             }
  43.         } catch (FileUploadException e) {
  44.             e.printStackTrace();
  45.         }
  46.         return map;
  47.     }
  49.     private static void processUploadedFile(FileItem item, Map<String, Object> map, HttpServletRequest request) {
  50.         String fieldName = item.getFieldName();
  51.         String fileName = item.getName();
  52. //        String contentType = item.getContentType();
  53. //        boolean isInMemory = item.isInMemory();
  54. //        long sizeInBytes = item.getSize();
  55. //        System.out.println("File " + fieldName + ":" + fileName + ":" + contentType + ":" + isInMemory + ":" + sizeInBytes);
  56.         String uploadPath = "upload/" + fileName;
  57.         String realPath = request.getServletContext().getRealPath(uploadPath);
  58.         File file = new File(realPath);
  59.         if(!file.getParentFile().exists()){
  60.             file.getParentFile().mkdirs();
  61.         }
  62.         try {
  63.             item.write(file);
  64.             map.put(fieldName, uploadPath);
  65.         } catch (Exception e) {
  66.             e.printStackTrace();
  67.         }
  68.     }
  70.     /**
  71.      * 处理常规form表单的逻辑
  72.      * @param item
  73.      * @param map
  74.      */
  75.     private static void processFormField(FileItem item, Map<String, Object> map) {
  76.         //返回的就是input的name属性
  77.         String name = item.getFieldName();
  78.         String value = null;
  79.         try {
  80.             value = item.getString("utf-8");
  81.             map.put(name, value);
  82.         } catch (UnsupportedEncodingException e) {
  83.             e.printStackTrace();
  84.         }
  85.         System.out.println("formField " + name + ":" + value);
  86.     }
  87. }
  1. package com.cskaoyan.upload;
  3. import com.cskaoyan.upload.utils.FileUploadUtils;
  4. import org.apache.commons.beanutils.BeanUtils;
  5. import org.apache.commons.fileupload.FileItem;
  6. import org.apache.commons.fileupload.FileUploadException;
  7. import org.apache.commons.fileupload.disk.DiskFileItemFactory;
  8. import org.apache.commons.fileupload.servlet.ServletFileUpload;
  10. import javax.servlet.ServletException;
  11. import javax.servlet.annotation.WebServlet;
  12. import javax.servlet.http.HttpServlet;
  13. import javax.servlet.http.HttpServletRequest;
  14. import javax.servlet.http.HttpServletResponse;
  15. import java.io.File;
  16. import java.io.IOException;
  17. import java.io.UnsupportedEncodingException;
  18. import java.lang.reflect.InvocationTargetException;
  19. import java.util.HashMap;
  20. import java.util.Iterator;
  21. import java.util.List;
  22. import java.util.Map;
  24. @WebServlet("/upload4")
  25. public class UploadServlet4 extends HttpServlet {
  26.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  27.         response.setContentType("text/html;charset=utf-8");
  28.         boolean multipartContent = ServletFileUpload.isMultipartContent(request);
  29.         if(!multipartContent){
  30.             response.getWriter().println("当前请求不含上传的文件");
  31.             return;
  32.         }
  33.         User user = new User();
  34.         Map<String, Object> map = FileUploadUtils.parseRequest(request);
  35.         try {
  36.             BeanUtils.populate(user, map);
  37.         } catch (IllegalAccessException e) {
  38.             e.printStackTrace();
  39.         } catch (InvocationTargetException e) {
  40.             e.printStackTrace();
  41.         }
  42.     }
  43.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  44.     }
  45. }

文件重名

文件改名问题。 wxid

利用时间戳 + username + 文件名

随机字符串重命名

  1. String uuid = UUID.randomUUID().toString();
  2. String fileName = item.getName();
  3. //文件有后缀名的
  4. fileName = uuid + fileName;

目录内文件数过多

hash散列

hashcode：尽可能散列的开，均匀。

文件名———hashcode———-int 数字——-16进制 8位 0x 1 2 3 4 5 6 a f

利用时间来划分—-年度、月份、日期，概率问题，如果出现某些大促，很可能需要进一步细分。

微信头像加国旗。去年 70周年

加上国旗的头像上传——-服务器

自己看自己的头像时改成功的，但是别人看起来，依然是之前的头像。经过了半天左右，头像终于同步了，别人看到你的头像也是新的了。

案例

写一个注册页面，包含图片上传，然后将上传的资源进行回显，回显图片