[关闭]
@liter 2015-10-23T07:48:47.000000Z 字数 6215 阅读 5528

Android网络通信框架LiteHttp 第九节：POST方式的多种类型数据传输

litehttp2.x版本系列教程

官网： http://litesuits.com

QQ群： 大群 47357508，二群 42960650

本系列文章面向android开发者，展示开源网络通信框架LiteHttp的主要用法，并讲解其关键功能的运作原理，同时传达了一些框架作者在日常开发中的一些最佳实践和经验。

本系列文章目录总览： https://zybuluo.com/liter/note/186513

第九节：LiteHttp之POST方式的多种类型数据传输

POST方式可以传递大量的数据到服务器，包括图片、音乐、文本等各种多媒体文件，这节主要来说明下lite-http的集中数据传输形式，包括：

  • 字符串上传
  • UrlEncodedForm上传
  • 对象自动转JSON上传
  • 对象序列化后上传
  • 字节上传
  • 单文件上传
  • 单输入流上传
  • 多文件（表单）上传

话不多讲，看代码：

  1. // POST Multi-Form Data
  3. final ProgressDialog postProgress = new ProgressDialog(this);
  4. postProgress.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
  5. postProgress.setIndeterminate(false);
  7. AlertDialog.Builder builder = new AlertDialog.Builder(this);
  8. builder.setTitle("POST DATA TEST");
  9. String[] array = new String[]{
  10.         "字符串上传",
  11.         "UrlEncodedForm上传",
  12.         "对象自动转JSON上传",
  13.         "对象序列化后上传",
  14.         "字节上传",
  15.         "单文件上传",
  16.         "单输入流上传",
  17.         "多文件（表单）上传"
  18. };
  20. final StringRequest postRequest = new StringRequest(uploadUrl)
  21.         .setMethod(HttpMethods.Post)
  22.         .setHttpListener(new HttpListener<String>(true, false, true) {
  23.             @Override
  24.             public void onStart(AbstractRequest<String> request) {
  25.                 super.onStart(request);
  26.                 postProgress.show();
  27.             }
  29.             @Override
  30.             public void onUploading(AbstractRequest<String> request, long total, long len) {
  31.                 postProgress.setMax((int) total);
  32.                 postProgress.setProgress((int) len);
  33.             }
  35.             @Override
  36.             public void onEnd(Response<String> response) {
  37.                 postProgress.dismiss();
  38.                 if (response.isConnectSuccess()) {
  39.                     HttpUtil.showTips(activity, "Upload Success", response.getResult() + "");
  40.                 } else {
  41.                     HttpUtil.showTips(activity, "Upload Failure", response.getException() + "");
  42.                 }
  43.                 response.printInfo();
  44.             }
  45.         });
  47. builder.setItems(array, new DialogInterface.OnClickListener() {
  48.     @Override
  49.     public void onClick(DialogInterface dialog, int which) {
  50.         switch (which) {
  51.             case 0:
  52.                 postRequest.setHttpBody(new StringBody("hello lite: 你好，Lite！"));
  53.                 break;
  54.             case 1:
  55.                 LinkedList<NameValuePair> pList = new LinkedList<NameValuePair>();
  56.                 pList.add(new NameValuePair("key1", "value-haha"));
  57.                 pList.add(new NameValuePair("key2", "value-hehe"));
  58.                 postRequest.setHttpBody(new UrlEncodedFormBody(pList));
  59.                 break;
  60.             case 2:
  61.                 postRequest.setHttpBody(new JsonBody(new UserParam(168, "haha-key")));
  62.                 break;
  63.             case 3:
  64.                 ArrayList<String> list = new ArrayList<String>();
  65.                 list.add("a");
  66.                 list.add("b");
  67.                 list.add("c");
  68.                 postRequest.setHttpBody(new SerializableBody(list));
  69.                 break;
  70.             case 4:
  71.                 postRequest.setHttpBody(new ByteArrayBody(new byte[]{1, 2, 3, 4, 5, 15, 18, 127}));
  72.                 break;
  73.             case 5:
  74.                 postRequest.setHttpBody(new FileBody(new File("/sdcard/litehttp.txt")));
  75.                 break;
  76.             case 6:
  77.                 FileInputStream fis = null;
  78.                 try {
  79.                     fis = new FileInputStream(new File("/sdcard/aaa.jpg"));
  80.                 } catch (Exception e) {
  81.                     e.printStackTrace();
  82.                 }
  83.                 postRequest.setHttpBody(new InputStreamBody(fis));
  84.                 break;
  85.             case 7:
  86.                 fis = null;
  87.                 try {
  88.                     fis = new FileInputStream(new File("/sdcard/litehttp.txt"));
  89.                 } catch (Exception e) {
  90.                     e.printStackTrace();
  91.                 }
  93.                 MultipartBody body = new MultipartBody();
  94.                 body.addPart(new StringPart("key1", "hello"));
  95.                 body.addPart(new StringPart("key2", "很高兴见到你", "utf-8", null));
  96.                 body.addPart(new BytesPart("key3", new byte[]{1, 2, 3}));
  97.                 body.addPart(new FilePart("pic", new File("/sdcard/aaa.jpg"), "image/jpeg"));
  98.                 body.addPart(new InputStreamPart("litehttp", fis, "litehttp.txt", "text/plain"));
  99.                 postRequest.setHttpBody(body);
  100.                 break;
  101.         }
  103.         liteHttp.executeAsync(postRequest);
  104.     }
  105. });
  106. AlertDialog dialog = builder.create();
  107. dialog.setCanceledOnTouchOutside(true);
  108. dialog.show();

服务器端接受代码大致如下，以Servlet为例，其他语言自行脑补：

  1. /**
  2.  * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
  3.  */
  4. protected void doPost(HttpServletRequest request,
  5.                       HttpServletResponse response) throws ServletException, IOException {
  7.     //String fileDir = "D:\\Downloads";
  8.     //这是我的Mac笔记本上的位置，开发者设置为合适自己的文件夹，尤其windows系统。
  9.     String fileDir = "/Users/Matianyu/Downloads";
  11.     String contentType = request.getContentType();
  13.     // 接受一般参数
  15.     Map<String, String[]> map = request.getParameterMap();
  16.     if (map.size() > 0) {
  17.         for (Entry<String, String[]> en : map.entrySet()) {
  18.             System.out.println(en.getKey() + " : " + Arrays.toString(en.getValue()));
  19.         }
  20.     }
  22.     response.setContentType("text/plain");
  23.     response.setCharacterEncoding("UTF-8");
  24.     // 接受文件和流
  26.     PrintWriter writer = response.getWriter();
  27.     writer.println("contentType:" + contentType);
  29.     if (contentType != null) {
  30.         if (contentType.startsWith("multipart")) {
  31.             //向客户端发送响应正文
  32.             try {
  33.                 //创建一个基于硬盘的FileItem工厂
  34.                 DiskFileItemFactory factory = new DiskFileItemFactory();
  35.                 //设置向硬盘写数据时所用的缓冲区的大小，此处为4K
  36.                 factory.setSizeThreshold(4 * 1024);
  37.                 //设置临时目录
  38.                 factory.setRepository(new File(fileDir));
  39.                 //创建一个文件上传处理器
  40.                 ServletFileUpload upload = new ServletFileUpload(factory);
  42.                 //设置允许上传的文件的最大尺寸，此处为100M
  43.                 upload.setSizeMax(100 * 1024 * 1024);
  44.                 Map<String, List<FileItem>> itemMap = upload.parseParameterMap(request);
  45.                 for (List<FileItem> items : itemMap.values()) {
  46.                     Iterator iter = items.iterator();
  47.                     while (iter.hasNext()) {
  48.                         FileItem item = (FileItem) iter.next();
  49.                         if (item.isFormField()) {
  50.                             processFormField(item, writer); //处理普通的表单域
  51.                         } else {
  52.                             processUploadedFile(fileDir, item, writer); //处理上传文件
  53.                         }
  54.                     }
  55.                 }
  56.             } catch (Exception ex) {
  57.                 ex.printStackTrace();
  58.             }
  59.         } else if (contentType.contains("text")
  60.                    || contentType.contains("json")
  61.                    || contentType.contains("application/x-www-form-urlencoded")
  62.                    || contentType.contains("xml")) {
  63.             processString(request);
  64.         } else {
  65.             processEntity(fileDir, request);
  66.         }
  67.     } else {
  68.         processString(request);
  69.     }
  70.     writer.print("upload over. ");
  71. }
  73. private void processString(HttpServletRequest request) {
  74.     try {
  75.         BufferedReader reader = request.getReader();
  76.         StringBuilder sb = new StringBuilder();
  77.         String line;
  78.         while ((line = reader.readLine()) != null) {
  79.             sb.append(line);
  80.             sb.append("\n\r");
  81.         }
  82.     } catch (IOException e) {
  83.         e.printStackTrace();
  84.     }
  85. }
  87. private void processEntity(String dir, HttpServletRequest request) {
  88.     try {
  89.         File uploadFile = new File(dir + "a-upload");
  90.         InputStream input = request.getInputStream();
  92.         OutputStream output = new FileOutputStream(uploadFile);
  93.         byte[] buffer = new byte[4096];
  94.         int n = -1;
  95.         while ((n = input.read(buffer)) != -1) {
  96.             if (n > 0) {
  97.                 output.write(buffer, 0, n);
  98.             }
  99.         }
  100.         output.close();
  101.     } catch (IOException e) {
  102.         e.printStackTrace();
  103.     }
  104. }
  106. /**
  107.  * 处理表单字符数据
  108.  */
  109. private void processFormField(FileItem item, PrintWriter writer) {
  110.     String name = item.getFieldName();
  111.     String value = item.getString();
  113.     writer.println("Form Part [" + name + "] value :" + value + "\r\n");
  114. }
  116. /**
  117.  * 处理表单文件
  118.  */
  119. private void processUploadedFile(String filePath, FileItem item, PrintWriter writer) throws Exception {
  120.     String filename = item.getName();
  121.     int index = filename.lastIndexOf("\\");
  122.     filename = filename.substring(index + 1, filename.length());
  123.     long fileSize = item.getSize();
  124.     if (filename.equals("") && fileSize == 0)
  125.         return;
  126.     File uploadFile = new File(filePath + "/" + filename);
  127.     item.write(uploadFile);
  128.     writer.println(
  129.             "File Part [" + filename + "] is saved." + " contentType: " + item
  130.                     .getContentType() + " , size: " + fileSize + "\r\n");
  131. }

当然，需要引入 apache的开源项目commons-fileupload等jar包。
此节比较枯燥，满眼是代码。
shut up, just show me the code.

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注