封装一个类搞定90%安卓客户端与服务器端交互

Posted 请叫我码农怪蜀黍

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了封装一个类搞定90%安卓客户端与服务器端交互相关的知识,希望对你有一定的参考价值。

本实例封装了一个处理安卓客户端与服务器端交互的几个方法,对于中文乱码问题本实例也找到了解决方案.本例可以处理的场景如下:

1.与服务器端交互json数据.

2.Get方式与服务器端交互数据.

3.Post方式与服务器端交互数据.

4.HttpClient方式与服务器端交互数据.

5.上传文件到服务器端.

6.从服务器端下载文件.

7.从服务器端读取文本文件.

实例截图:

技术分享

本篇文章将实例代码完整贴出,希望以本文作为一个交流的平台,大家集思广益封装出更好的处理类.交流地址: http://blog.csdn.net/lk_blog/article/details/7706348#comments

客户端的封装类NetTool.Java:

 

[java] view plain copy
 
  1. package com.tgb.lk.demo.util;  
  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.FileOutputStream;  
  8. import java.io.IOException;  
  9. import java.io.InputStream;  
  10. import java.io.InputStreamReader;  
  11. import java.io.OutputStream;  
  12. import java.net.HttpURLConnection;  
  13. import java.net.MalformedURLException;  
  14. import java.net.URL;  
  15. import java.net.URLEncoder;  
  16. import java.util.ArrayList;  
  17. import java.util.List;  
  18. import java.util.Map;  
  19.   
  20. import org.apache.http.HttpEntity;  
  21. import org.apache.http.HttpResponse;  
  22. import org.apache.http.NameValuePair;  
  23. import org.apache.http.client.entity.UrlEncodedFormEntity;  
  24. import org.apache.http.client.methods.HttpPost;  
  25. import org.apache.http.impl.client.DefaultHttpClient;  
  26. import org.apache.http.message.BasicNameValuePair;  
  27.   
  28. import android.os.Environment;  
  29.   
  30. /** 
  31.  * NetTool:封装一个类搞定90%安卓客户端与服务器端交互 
  32.  *  
  33.  * @author 李坤 五期信息技术提高班 
  34.  */  
  35. public class NetTool {  
  36.     private static final int TIMEOUT = 10000;// 10秒  
  37.   
  38.     /** 
  39.      * 传送文本,例如Json,xml等 
  40.      */  
  41.     public static String sendTxt(String urlPath, String txt, String encoding)  
  42.             throws Exception {  
  43.         byte[] sendData = txt.getBytes();  
  44.         URL url = new URL(urlPath);  
  45.         HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
  46.         conn.setRequestMethod("POST");  
  47.         conn.setConnectTimeout(TIMEOUT);  
  48.         // 如果通过post提交数据,必须设置允许对外输出数据  
  49.         conn.setDoOutput(true);  
  50.         conn.setRequestProperty("Content-Type", "text/xml");  
  51.         conn.setRequestProperty("Charset", encoding);  
  52.         conn.setRequestProperty("Content-Length", String  
  53.                 .valueOf(sendData.length));  
  54.         OutputStream outStream = conn.getOutputStream();  
  55.         outStream.write(sendData);  
  56.         outStream.flush();  
  57.         outStream.close();  
  58.         if (conn.getResponseCode() == 200) {  
  59.             // 获得服务器响应的数据  
  60.             BufferedReader in = new BufferedReader(new InputStreamReader(conn  
  61.                     .getInputStream(), encoding));  
  62.             // 数据  
  63.             String retData = null;  
  64.             String responseData = "";  
  65.             while ((retData = in.readLine()) != null) {  
  66.                 responseData += retData;  
  67.             }  
  68.             in.close();  
  69.             return responseData;  
  70.         }  
  71.         return "sendText error!";  
  72.     }  
  73.   
  74.     /** 
  75.      * 上传文件 
  76.      */  
  77.     public static String sendFile(String urlPath, String filePath,  
  78.             String newName) throws Exception {  
  79.         String end = "\r\n";  
  80.         String twoHyphens = "--";  
  81.         String boundary = "*****";  
  82.   
  83.         URL url = new URL(urlPath);  
  84.         HttpURLConnection con = (HttpURLConnection) url.openConnection();  
  85.         /* 允许Input、Output,不使用Cache */  
  86.         con.setDoInput(true);  
  87.         con.setDoOutput(true);  
  88.         con.setUseCaches(false);  
  89.         /* 设置传送的method=POST */  
  90.         con.setRequestMethod("POST");  
  91.         /* setRequestProperty */  
  92.   
  93.         con.setRequestProperty("Connection", "Keep-Alive");  
  94.         con.setRequestProperty("Charset", "UTF-8");  
  95.         con.setRequestProperty("Content-Type", "multipart/form-data;boundary="  
  96.                 + boundary);  
  97.         /* 设置DataOutputStream */  
  98.         DataOutputStream ds = new DataOutputStream(con.getOutputStream());  
  99.         ds.writeBytes(twoHyphens + boundary + end);  
  100.         ds.writeBytes("Content-Disposition: form-data; "  
  101.                 + "name=\"file1\";filename=\"" + newName + "\"" + end);  
  102.         ds.writeBytes(end);  
  103.   
  104.         /* 取得文件的FileInputStream */  
  105.         FileInputStream fStream = new FileInputStream(filePath);  
  106.         /* 设置每次写入1024bytes */  
  107.         int bufferSize = 1024;  
  108.         byte[] buffer = new byte[bufferSize];  
  109.   
  110.         int length = -1;  
  111.         /* 从文件读取数据至缓冲区 */  
  112.         while ((length = fStream.read(buffer)) != -1) {  
  113.             /* 将资料写入DataOutputStream中 */  
  114.             ds.write(buffer, 0, length);  
  115.         }  
  116.         ds.writeBytes(end);  
  117.         ds.writeBytes(twoHyphens + boundary + twoHyphens + end);  
  118.   
  119.         /* close streams */  
  120.         fStream.close();  
  121.         ds.flush();  
  122.   
  123.         /* 取得Response内容 */  
  124.         InputStream is = con.getInputStream();  
  125.         int ch;  
  126.         StringBuffer b = new StringBuffer();  
  127.         while ((ch = is.read()) != -1) {  
  128.             b.append((char) ch);  
  129.         }  
  130.         /* 关闭DataOutputStream */  
  131.         ds.close();  
  132.         return b.toString();  
  133.     }  
  134.   
  135.     /** 
  136.      * 通过get方式提交参数给服务器 
  137.      */  
  138.     public static String sendGetRequest(String urlPath,  
  139.             Map<String, String> params, String encoding) throws Exception {  
  140.   
  141.         // 使用StringBuilder对象  
  142.         StringBuilder sb = new StringBuilder(urlPath);  
  143.         sb.append(‘?‘);  
  144.   
  145.         // 迭代Map  
  146.         for (Map.Entry<String, String> entry : params.entrySet()) {  
  147.             sb.append(entry.getKey()).append(‘=‘).append(  
  148.                     URLEncoder.encode(entry.getValue(), encoding)).append(‘&‘);  
  149.         }  
  150.         sb.deleteCharAt(sb.length() - 1);  
  151.         // 打开链接  
  152.         URL url = new URL(sb.toString());  
  153.         HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
  154.         conn.setRequestMethod("GET");  
  155.         conn.setRequestProperty("Content-Type", "text/xml");  
  156.         conn.setRequestProperty("Charset", encoding);  
  157.         conn.setConnectTimeout(TIMEOUT);  
  158.         // 如果请求响应码是200,则表示成功  
  159.         if (conn.getResponseCode() == 200) {  
  160.             // 获得服务器响应的数据  
  161.             BufferedReader in = new BufferedReader(new InputStreamReader(conn  
  162.                     .getInputStream(), encoding));  
  163.             // 数据  
  164.             String retData = null;  
  165.             String responseData = "";  
  166.             while ((retData = in.readLine()) != null) {  
  167.                 responseData += retData;  
  168.             }  
  169.             in.close();  
  170.             return responseData;  
  171.         }  
  172.         return "sendGetRequest error!";  
  173.   
  174.     }  
  175.   
  176.     /** 
  177.      * 通过Post方式提交参数给服务器,也可以用来传送json或xml文件 
  178.      */  
  179.     public static String sendPostRequest(String urlPath,  
  180.             Map<String, String> params, String encoding) throws Exception {  
  181.         StringBuilder sb = new StringBuilder();  
  182.         // 如果参数不为空  
  183.         if (params != null && !params.isEmpty()) {  
  184.             for (Map.Entry<String, String> entry : params.entrySet()) {  
  185.                 // Post方式提交参数的话,不能省略内容类型与长度  
  186.                 sb.append(entry.getKey()).append(‘=‘).append(  
  187.                         URLEncoder.encode(entry.getValue(), encoding)).append(  
  188.                         ‘&‘);  
  189.             }  
  190.             sb.deleteCharAt(sb.length() - 1);  
  191.         }  
  192.         // 得到实体的二进制数据  
  193.         byte[] entitydata = sb.toString().getBytes();  
  194.         URL url = new URL(urlPath);  
  195.         HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
  196.         conn.setRequestMethod("POST");  
  197.         conn.setConnectTimeout(TIMEOUT);  
  198.         // 如果通过post提交数据,必须设置允许对外输出数据  
  199.         conn.setDoOutput(true);  
  200.         // 这里只设置内容类型与内容长度的头字段  
  201.         conn.setRequestProperty("Content-Type",  
  202.                 "application/x-www-form-urlencoded");  
  203.         // conn.setRequestProperty("Content-Type", "text/xml");  
  204.         conn.setRequestProperty("Charset", encoding);  
  205.         conn.setRequestProperty("Content-Length", String  
  206.                 .valueOf(entitydata.length));  
  207.         OutputStream outStream = conn.getOutputStream();  
  208.         // 把实体数据写入是输出流  
  209.         outStream.write(entitydata);  
  210.         // 内存中的数据刷入  
  211.         outStream.flush();  
  212.         outStream.close();  
  213.         // 如果请求响应码是200,则表示成功  
  214.         if (conn.getResponseCode() == 200) {  
  215.             // 获得服务器响应的数据  
  216.             BufferedReader in = new BufferedReader(new InputStreamReader(conn  
  217.                     .getInputStream(), encoding));  
  218.             // 数据  
  219.             String retData = null;  
  220.             String responseData = "";  
  221.             while ((retData = in.readLine()) != null) {  
  222.                 responseData += retData;  
  223.             }  
  224.             in.close();  
  225.             return responseData;  
  226.         }  
  227.         return "sendText error!";  
  228.     }  
  229.   
  230.     /** 
  231.      * 在遇上HTTPS安全模式或者操作cookie的时候使用HTTPclient会方便很多 使用HTTPClient(开源项目)向服务器提交参数 
  232.      */  
  233.     public static String sendHttpClientPost(String urlPath,  
  234.             Map<String, String> params, String encoding) throws Exception {  
  235.         // 需要把参数放到NameValuePair  
  236.         List<NameValuePair> paramPairs = new ArrayList<NameValuePair>();  
  237.         if (params != null && !params.isEmpty()) {  
  238.             for (Map.Entry<String, String> entry : params.entrySet()) {  
  239.                 paramPairs.add(new BasicNameValuePair(entry.getKey(), entry  
  240.                         .getValue()));  
  241.             }  
  242.         }  
  243.         // 对请求参数进行编码,得到实体数据  
  244.         UrlEncodedFormEntity entitydata = new UrlEncodedFormEntity(paramPairs,  
  245.                 encoding);  
  246.         // 构造一个请求路径  
  247.         HttpPost post = new HttpPost(urlPath);  
  248.         // 设置请求实体  
  249.         post.setEntity(entitydata);  
  250.         // 浏览器对象  
  251.         DefaultHttpClient client = new DefaultHttpClient();  
  252.         // 执行post请求  
  253.         HttpResponse response = client.execute(post);  
  254.         // 从状态行中获取状态码,判断响应码是否符合要求  
  255.         if (response.getStatusLine().getStatusCode() == 200) {  
  256.             HttpEntity entity = response.getEntity();  
  257.             InputStream inputStream = entity.getContent();  
  258.             InputStreamReader inputStreamReader = new InputStreamReader(  
  259.                     inputStream, encoding);  
  260.             BufferedReader reader = new BufferedReader(inputStreamReader);// 读字符串用的。  
  261.             String s;  
  262.             String responseData = "";  
  263.             while (((s = reader.readLine()) != null)) {  
  264.                 responseData += s;  
  265.             }  
  266.             reader.close();// 关闭输入流  
  267.             return responseData;  
  268.         }  
  269.         return "sendHttpClientPost error!";  
  270.     }  
  271.   
  272.     /** 
  273.      * 根据URL直接读文件内容,前提是这个文件当中的内容是文本,函数的返回值就是文件当中的内容 
  274.      */  
  275.     public static String readTxtFile(String urlStr, String encoding)  
  276.             throws Exception {  
  277.         StringBuffer sb = new StringBuffer();  
  278.         String line = null;  
  279.         BufferedReader buffer = null;  
  280.         try {  
  281.             // 创建一个URL对象  
  282.             URL url = new URL(urlStr);  
  283.             // 创建一个Http连接  
  284.             HttpURLConnection urlConn = (HttpURLConnection) url  
  285.                     .openConnection();  
  286.             // 使用IO流读取数据  
  287.             buffer = new BufferedReader(new InputStreamReader(urlConn  
  288.                     .getInputStream(), encoding));  
  289.             while ((line = buffer.readLine()) != null) {  
  290.                 sb.append(line);  
  291.             }  
  292.         } catch (Exception e) {  
  293.             throw e;  
  294.         } finally {  
  295.             try {  
  296.                 buffer.close();  
  297.             } catch (Exception e) {  
  298.                 e.printStackTrace();  
  299.             }  
  300.         }  
  301.         return sb.toString();  
  302.     }  
  303.   
  304.     /** 
  305.      * 该函数返回整形 -1:代表下载文件出错 0:代表下载文件成功 1:代表文件已经存在 
  306.      */  
  307.     public static int downloadFile(String urlStr, String path, String fileName)  
  308.             throws Exception {  
  309.         InputStream inputStream = null;  
  310.         try {  
  311.             inputStream = getInputStreamFromUrl(urlStr);  
  312.             File resultFile = write2SDFromInput(path, fileName, inputStream);  
  313.             if (resultFile == null) {  
  314.                 return -1;  
  315.             }  
  316.   
  317.         } catch (Exception e) {  
  318.             return -1;  
  319.         } finally {  
  320.             try {  
  321.                 inputStream.close();  
  322.             } catch (Exception e) {  
  323.                 throw e;  
  324.             }  
  325.         }  
  326.         return 0;  
  327.     }  
  328.   
  329.     /** 
  330.      * 根据URL得到输入流 
  331.      *  
  332.      * @param urlStr 
  333.      * @return 
  334.      * @throws MalformedURLException 
  335.      * @throws IOException 
  336.      */  
  337.     public static InputStream getInputStreamFromUrl(String urlStr)  
  338.             throws MalformedURLException, IOException {  
  339.         URL url = new URL(urlStr);  
  340.         HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();  
  341.         InputStream inputStream = urlConn.getInputStream();  
  342.         return inputStream;  
  343.     }  
  344.   
  345.     /** 
  346.      * 将一个InputStream里面的数据写入到SD卡中 
  347.      */  
  348.     private static File write2SDFromInput(String directory, String fileName,  
  349.             InputStream input) {  
  350.         File file = null;  
  351.         String SDPATH = Environment.getExternalStorageDirectory().toString();  
  352.         FileOutputStream output = null;  
  353.         File dir = new File(SDPATH + directory);  
  354.         if (!dir.exists()) {  
  355.             dir.mkdir();  
  356.         }  
  357.         try {  
  358.             file = new File(dir + File.separator + fileName);  
  359.             file.createNewFile();  
  360.             output = new FileOutputStream(file);  
  361.             byte buffer[] = new byte[1024];  
  362.             while ((input.read(buffer)) != -1) {  
  363.                 output.write(buffer);  
  364.             }  
  365.             output.flush();  
  366.         } catch (IOException e) {  
  367.             e.printStackTrace();  
  368.         } finally {  
  369.             try {  
  370.                 output.close();  
  371.             } catch (IOException e) {  
  372.                 e.printStackTrace();  
  373.             }  
  374.         }  
  375.         return file;  
  376.     }  
  377. }  

 

客户端main.xml:

 

[html] view plain copy
 
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:layout_width="fill_parent"  
  4.     android:layout_height="fill_parent"  
  5.     android:orientation="vertical" >  
  6.   
  7.     <TextView  
  8.         android:id="@+id/tvData"  
  9.         android:layout_width="fill_parent"  
  10.         android:layout_height="wrap_content"  
  11.         android:text="数据" />  
  12.   
  13.     <Button  
  14.         android:id="@+id/btnTxt"  
  15.         android:layout_width="fill_parent"  
  16.         android:layout_height="wrap_content"  
  17.         android:text="与服务器端交互Json数据" />  
  18.   
  19.     <Button  
  20.         android:id="@+id/btnGet"  
  21.         android:layout_width="fill_parent"  
  22.         android:layout_height="wrap_content"  
  23.         android:text="Get方式与服务器端交互数据" />  
  24.   
  25.     <Button  
  26.         android:id="@+id/btnPost"  
  27.         android:layout_width="fill_parent"  
  28.         android:layout_height="wrap_content"  
  29.         android:text="Post方式与服务器端交互数据" />  
  30.   
  31.     <Button  
  32.         android:id="@+id/btnHttpClient"  
  33.         android:layout_width="fill_parent"  
  34.         android:layout_height="wrap_content"  
  35.         android:text="HttpClient方式与服务器端交互数据" />  
  36.   
  37.     <Button  
  38.         android:id="@+id/btnUploadFile"  
  39.         android:layout_width="fill_parent"  
  40.         android:layout_height="wrap_content"  
  41.         android:text="上传文件到服务器端" />  
  42.   
  43.     <Button  
  44.         android:id="@+id/btnDownloadFile"  
  45.         android:layout_width="fill_parent"  
  46.         android:layout_height="wrap_content"  
  47.         android:text="从服务器端下载文件" />  
  48.   
  49.     <Button  
  50.         android:id="@+id/btnReadTxtFile"  
  51.         android:layout_width="fill_parent"  
  52.         android:layout_height="wrap_content"  
  53.         android:text="从服务器端读取文本文件" />  
  54.   
  55. </LinearLayout>  



 

客户端AppClientActivity.java:

 

[java] view plain copy
 
  1. package com.tgb.lk.demo.appclient;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.Map;  
  5.   
  6. import com.google.gson.Gson;  
  7. import com.tgb.lk.demo.model.Student;  
  8. import com.tgb.lk.demo.util.NetTool;  
  9.   
  10. import android.app.Activity;  
  11. import android.os.Bundle;  
  12. import android.view.View;  
  13. import android.view.View.OnClickListener;  
  14. import android.widget.Button;  
  15. import android.widget.TextView;  
  16.   
  17. public class AppClientActivity extends Activity {  
  18.     private TextView tvData = null;  
  19.     private Button btnTxt = null;  
  20.     private Button btnGet = null;  
  21.     private Button btnPost = null;  
  22.     private Button btnHttpClient = null;  
  23.     private Button btnUploadFile = null;  
  24.     private Button btnReadTxtFile = null;  
  25.     private Button btnDownloadFile = null;  
  26.       
  27.     //需要将下面的IP改为服务器端IP  
  28.     private String txtUrl = "http://192.168.1.46:8080/AppServer/SynTxtDataServlet";  

以上是关于封装一个类搞定90%安卓客户端与服务器端交互的主要内容,如果未能解决你的问题,请参考以下文章

Android上实现TCP服务端

CSDN日报20170220——《从安卓调整到服务端后的思考》

安卓程序与服务器端交互总结

前端与后端交互返回当前时间

Android 客户端与服务器端进行数据交互(一登录服务器端)

Android 客户端与服务器端进行数据交互(一登录服务器端)