zoukankan      html  css  js  c++  java

  • Android 上传文件，图片。以及服务器端接收相关。

    前面一篇文章写了实现照相功能的一个例子，其实那个实现效果是个略缩图。要查看全图就要先指定照片的存放路径。以后我会修改那个文章。今天先说下图片，文件等上传的实现。接着拿照片说事，光照完了不行还得往服务器上传。

    我们做web开发的时候几乎都是通过一个表单来实现上传。并且是post的方式。而且都必须要加个参数enctype = "multipart/form-data".然后再上传后台用各种框架里的插件之类的就可以接收了，并没有关心过这个文件具体是怎么传的。现在用android开发 没有那些框架了，所以不得不关心一下了。

    其实我们这种前后台的交互是用的HTTP协议。而http协议默认是传的字符串。所以我们上传文件的话要加enctype = "multipart/form-data"这个参数来说明我们这传的是文件不是字符串了。而我们做web开发的时候，浏览器是自动解析HTTP协议的。里面传的哪些东西我们不用管。只要记住几个参数就行。而我们要上传的文件报文是保存在请求的头文件里面的。下面就是上传文件头文件的格式：

    POST/logsys/home/uploadIspeedLog!doDefault.html HTTP/1.1 

    　　Accept: text/plain, */* 
    　　Accept-Language: zh-cn 
    　　Host: 192.168.24.56
    　　Content-Type:multipart/form-data;boundary=-----------------------------7db372eb000e2
    　　User-Agent: WinHttpClient 
    　　Content-Length: 3693
    　　Connection: Keep-Alive

    　　-------------------------------7db372eb000e2

    　　Content-Disposition: form-data; name="file"; filename="kn.jpg"

    　　Content-Type: image/jpeg

    　　(此处省略jpeg文件二进制数据...）

    　　-------------------------------7db372eb000e2--

    这就是Http上传发送的文件格式。而我们要发送的时候必然要遵循这种格式来并且不能出一点差错包括每行后面的回车，下面一段文字是网上找的感觉写的比较精彩。（尊重原创：原文地址）

    红色字体部分就是协议的头。给服务器上传数据时，并非协议头每个字段都得说明，其中，content-type是必须的，它包括一个类似标志性质的名为boundary的标志，它可以是随便输入的字符串。对后面的具体内容也是必须的。它用来分辨一段内容的开始。Content-Length: 3693 ，这里的3693是要上传文件的总长度。绿色字体部分就是需要上传的数据，可以是文本，也可以是图片等。数据内容前面需要有Content-Disposition, Content-Type以及Content-Transfer-Encoding等说明字段。最后的紫色部分就是协议的结尾了。
    　　注意这一行：
    　　Content-Type: multipart/form-data; boundary=---------------------------7db372eb000e2　　
    　　根据 rfc1867, multipart/form-data是必须的.
    　　---------------------------7db372eb000e2 是分隔符，分隔多个文件、表单项。其中b372eb000e2 是即时生成的一个数字，用以确保整个分隔符不会在文件或表单项的内容中出现。Form每个部分用分隔符分割，分隔符之前必须加上"--"着两个字符(即--{boundary})才能被http协议认为是Form的分隔符，表示结束的话用在正确的分隔符后面添加"--"表示结束。
    　　前面的 ---------------------------7d 是 IE 特有的标志,Mozila 为---------------------------71.
    　　每个分隔的数据的都可以用Content-Type来表示下面数据的类型，可以参考rfc1341 (http://www.ietf.org/rfc/rfc1341.txt)

    以上对上传文件的头文件格式讲的应该比较清楚了。其实很多参数我们也用不到，也不必刻意去记住，下面就看一个例子。应该能更好的理解：

     
    1. package com.example.photo;  
    2.   
    3. import java.io.BufferedReader;  
    4. import java.io.DataOutputStream;  
    5. import java.io.File;  
    6. import java.io.FileInputStream;  
    7. import java.io.IOException;  
    8. import java.io.InputStream;  
    9. import java.io.InputStreamReader;  
    10. import java.io.OutputStream;  
    11. import java.net.HttpURLConnection;  
    12. import java.net.MalformedURLException;  
    13. import java.net.URL;  
    14. import java.util.UUID;  
    15.   
    16.   
    17. public class HttpAssist {  
    18.     private static final String TAG = "uploadFile";  
    19.     private static final int TIME_OUT = 10 * 10000000; // 超时时间  
    20.     private static final String CHARSET = "utf-8"; // 设置编码  
    21.     public static final String SUCCESS = "1";  
    22.     public static final String FAILURE = "0";  
    23.   
    24.     public static String uploadFile(File file) {  
    25.         String BOUNDARY = UUID.randomUUID().toString(); // 边界标识 随机生成  
    26.         String PREFIX = "--", LINE_END = " ";  
    27.         String CONTENT_TYPE = "multipart/form-data"; // 内容类型  
    28.         String RequestURL = "http://192.168.0.100:7080/YkyPhoneService/Uploadfile1";  
    29.         try {  
    30.             URL url = new URL(RequestURL);  
    31.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
    32.             conn.setReadTimeout(TIME_OUT);  
    33.             conn.setConnectTimeout(TIME_OUT);  
    34.             conn.setDoInput(true); // 允许输入流  
    35.             conn.setDoOutput(true); // 允许输出流  
    36.             conn.setUseCaches(false); // 不允许使用缓存  
    37.             conn.setRequestMethod("POST"); // 请求方式  
    38.             conn.setRequestProperty("Charset", CHARSET); // 设置编码  
    39.             conn.setRequestProperty("connection", "keep-alive");  
    40.             conn.setRequestProperty("Content-Type", CONTENT_TYPE + ";boundary="  
    41.                     + BOUNDARY);  
    42.             if (file != null) {  
    43.                 /** 
    44.                  * 当文件不为空，把文件包装并且上传 
    45.                  */  
    46.                 OutputStream outputSteam = conn.getOutputStream();  
    47.   
    48.                 DataOutputStream dos = new DataOutputStream(outputSteam);  
    49.                 StringBuffer sb = new StringBuffer();  
    50.                 sb.append(PREFIX);  
    51.                 sb.append(BOUNDARY);  
    52.                 sb.append(LINE_END);  
    53.                 /** 
    54.                  * 这里重点注意： name里面的值为服务器端需要key 只有这个key 才可以得到对应的文件 
    55.                  * filename是文件的名字，包含后缀名的 比如:abc.png 
    56.                  */  
    57.   
    58.                 sb.append("Content-Disposition: form-data; name="img"; filename=""  
    59.                         + file.getName() + """ + LINE_END);  
    60.                 sb.append("Content-Type: application/octet-stream; charset="  
    61.                         + CHARSET + LINE_END);  
    62.                 sb.append(LINE_END);  
    63.                 dos.write(sb.toString().getBytes());  
    64.                 InputStream is = new FileInputStream(file);  
    65.                 byte[] bytes = new byte[1024];  
    66.                 int len = 0;  
    67.                 while ((len = is.read(bytes)) != -1) {  
    68.                     dos.write(bytes, 0, len);  
    69.                 }  
    70.                 is.close();  
    71.                 dos.write(LINE_END.getBytes());  
    72.                 byte[] end_data = (PREFIX + BOUNDARY + PREFIX + LINE_END)  
    73.                         .getBytes();  
    74.                 dos.write(end_data);  
    75.                 dos.flush();  
    76.                 /** 
    77.                  * 获取响应码 200=成功 当响应成功，获取响应的流 
    78.                  */  
    79.                 int res = conn.getResponseCode();  
    80.                 if (res == 200) {  
    81.                     return SUCCESS;  
    82.                 }  
    83.             }  
    84.         } catch (MalformedURLException e) {  
    85.             e.printStackTrace();  
    86.         } catch (IOException e) {  
    87.             e.printStackTrace();  
    88.         }  
    89.         return FAILURE;  
    90.     }  
    91. }  

    这是文件上传的客户端代码。 认真读一下代码，应该能够理解上传文件的格式了。同样写好这个头文件之后采用HttpURLConnection向后台发送。也就是浏览器所用的http协议。我们只是把这个协议自己手动调用并且手动填写头文件内容。而不是通过浏览器帮我们写了。看这段代码的时候我发现都是把字符串转化成字节流，然后利用DataOutputStream这个类来想后台传输。图片文件也是利用这个类向后台传。不知道大家有没有跟我想法一样的觉得到后台之后通过Request获取字节流，然后把流写到相应格式的文件或者图片里就收到了。我觉得理论上应该是这样的。而且网上也有一些相应的文件或者代码。但是我拿来用的话却都不成功，以下是一个例子（不能用。）

     
    1. public class UploadFile extends HttpServlet {  
    2.   
    3.     static int i = 0;  
    4.     public void doPost(HttpServletRequest request, HttpServletResponse response)  
    5.             throws IOException {  
    6.         ServletInputStream in = request.getInputStream();  
    7.         byte[] buffer = new byte[1024];  
    8.         File file = new File(request.getSession().getServletContext().getRealPath("/img/"),"img_"+i+".jpg");  
    9.         i++;  
    10.         FileOutputStream out = new FileOutputStream(file);  
    11.         int len = in.read(buffer, 0, 1024);  
    12.         while( len!=-1){  
    13.             out.write(buffer,0,len);  
    14.             len = in.read(buffer, 0, 1024);  
    15.         }  
    16.         out.close();  
    17.         in.close();  
    18.     }  
    19. }  

    我觉得这几行代码跟我的想法很相似，但就是运行不成功。向后台上传一个图片之后也收到了，但就是打不开，提示文件损坏。而且我觉得这种思路是对的，于是就一直在找类似的实现方法或者，按自己的思路修改一下代码，带最终还是不行。所以只好用其他的方法。

    服务器接收上传的文件的方法最后是通过利用apache提供的两个jar包来实现的。commons-fileupload.jar和commons-io.jar这俩jar包。在服务器端添加这俩包之后，写一个Servlet来实现文件接收。直接上代码：

     
    1. public class Uploadfile1 extends HttpServlet {  
    2.   
    3.     @Override  
    4.     public void doPost(HttpServletRequest request, HttpServletResponse response)  
    5.             throws ServletException, IOException {  
    6.         request.setCharacterEncoding("utf-8");  
    7.         //获得磁盘文件条目工厂。  
    8.         DiskFileItemFactory factory = new DiskFileItemFactory();  
    9.         //获取文件上传需要保存的路径，upload文件夹需存在。  
    10.         String path = request.getSession().getServletContext().getRealPath("/upload");  
    11.         //设置暂时存放文件的存储室，这个存储室可以和最终存储文件的文件夹不同。因为当文件很大的话会占用过多内存所以设置存储室。  
    12.         factory.setRepository(new File(path));  
    13.         //设置缓存的大小，当上传文件的容量超过缓存时，就放到暂时存储室。  
    14.         factory.setSizeThreshold(1024*1024);  
    15.         //上传处理工具类（高水平API上传处理？）  
    16.         ServletFileUpload upload = new ServletFileUpload(factory);  
    17.           
    18.         try{  
    19.             //调用 parseRequest（request）方法  获得上传文件 FileItem 的集合list 可实现多文件上传。  
    20.             List<FileItem> list = (List<FileItem>)upload.parseRequest(request);  
    21.             for(FileItem item:list){  
    22.                 //获取表单属性名字。  
    23.                 String name = item.getFieldName();  
    24.                 //如果获取的表单信息是普通的文本信息。即通过页面表单形式传递来的字符串。  
    25.                 if(item.isFormField()){  
    26.                     //获取用户具体输入的字符串，  
    27.                     String value = item.getString();  
    28.                     request.setAttribute(name, value);  
    29.                 }  
    30.                 //如果传入的是非简单字符串，而是图片，音频，视频等二进制文件。  
    31.                 else{   
    32.                     //获取路径名  
    33.                     String value = item.getName();  
    34.                     //取到最后一个反斜杠。  
    35.                     int start = value.lastIndexOf("\");  
    36.                     //截取上传文件的 字符串名字。+1是去掉反斜杠。  
    37.                     String filename = value.substring(start+1);  
    38.                     request.setAttribute(name, filename);  
    39.                       
    40.                     /*第三方提供的方法直接写到文件中。 
    41.                      * item.write(new File(path,filename));*/  
    42.                     //收到写到接收的文件中。  
    43.                     OutputStream out = new FileOutputStream(new File(path,filename));  
    44.                     InputStream in = item.getInputStream();  
    45.                       
    46.                     int length = 0;  
    47.                     byte[] buf = new byte[1024];  
    48.                     System.out.println("获取文件总量的容量:"+ item.getSize());  
    49.                       
    50.                     while((length = in.read(buf))!=-1){  
    51.                         out.write(buf,0,length);  
    52.                     }  
    53.                     in.close();  
    54.                     out.close();  
    55.                 }  
    56.             }  
    57.         }catch(Exception e){  
    58.             e.printStackTrace();  
    59.         }  
    60.           
    61.     }  
    62. }  


    代码同样转自网络，具体地址给忘了，这个真不是故意的。。。

    代码上有相应注释，应该都能看懂。并且这个开源jar包提供的方法挺强大的，支持多文件上传之类的。我猜它的源码同样是获取客户端传过来的字节流。后面的代码跟上面提供的思路一样。只是不知道它的Item究竟是如何获得这个字节流的。按着源码看了看 也没看太明白。以后再慢慢研究吧。有哪位明白的 还请指点。

    这样利用HTTP做到文件的上传和接收都已经正确运行了。先留下个笔记，以后用的时候可以看看。
  • 相关阅读:
    【转载】Highcharts一些属性
    What is assembly?
    用Apache配置Git服务器
    【转】.NET试题总结二
    【转】SVN服务器的快速搭建。
    【转】.NET试题总结一
    【转】国外C#开源系统一览表 ,C# Open Source
    Amazon S3 REST方式获取Object
    Action Filter
    a 标签 name 熟悉因为头部固定,导致置顶遮挡解决方案
  • 原文地址：https://www.cnblogs.com/android100/p/android-file-upload.html
Copyright © 2011-2022 走看看