zoukankan      html  css  js  c++  java

  • 封装一个类搞定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 = " ";  
    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";  
    29.     private String url = "http://192.168.1.46:8080/AppServer/SynDataServlet";  
    30.     private String uploadUrl = "http://192.168.1.46:8080/AppServer/UploadFileServlet";  
    31.     private String fileUrl = "http://192.168.1.46:8080/AppServer/file.jpg";  
    32.     private String txtFileUrl = "http://192.168.1.46:8080/AppServer/txtFile.txt";  
    33.   
    34.     @Override  
    35.     public void onCreate(Bundle savedInstanceState) {  
    36.         super.onCreate(savedInstanceState);  
    37.         setContentView(R.layout.main);  
    38.   
    39.         tvData = (TextView) findViewById(R.id.tvData);  
    40.         btnTxt = (Button) findViewById(R.id.btnTxt);  
    41.         btnGet = (Button) findViewById(R.id.btnGet);  
    42.         btnPost = (Button) findViewById(R.id.btnPost);  
    43.         btnHttpClient = (Button) findViewById(R.id.btnHttpClient);  
    44.         btnUploadFile = (Button) findViewById(R.id.btnUploadFile);  
    45.         btnReadTxtFile = (Button) findViewById(R.id.btnReadTxtFile);  
    46.         btnDownloadFile = (Button) findViewById(R.id.btnDownloadFile);  
    47.   
    48.         btnTxt.setOnClickListener(btnListener);  
    49.         btnGet.setOnClickListener(btnListener);  
    50.         btnPost.setOnClickListener(btnListener);  
    51.         btnHttpClient.setOnClickListener(btnListener);  
    52.         btnUploadFile.setOnClickListener(btnListener);  
    53.         btnReadTxtFile.setOnClickListener(btnListener);  
    54.         btnDownloadFile.setOnClickListener(btnListener);  
    55.   
    56.     }  
    57.   
    58.     OnClickListener btnListener = new OnClickListener() {  
    59.         String retStr = "";  
    60.   
    61.         @Override  
    62.         public void onClick(View v) {  
    63.             switch (v.getId()) {  
    64.             case R.id.btnTxt:  
    65.                 Student student = new Student();  
    66.                 student.setId(1);  
    67.                 student.setName("李坤");  
    68.                 student.setClasses("五期信息技术提高班");  
    69.                 Gson gson = new Gson();  
    70.                 String jsonTxt = gson.toJson(student);  
    71.                 try {  
    72.                     retStr = NetTool.sendTxt(txtUrl, jsonTxt,"UTF-8");  
    73.                 } catch (Exception e2) {  
    74.                     e2.printStackTrace();  
    75.                 }  
    76.                 break;  
    77.             case R.id.btnGet:  
    78.                 Map<String, String> map = new HashMap<String, String>();  
    79.                 map.put("name", "李坤");  
    80.                 map.put("age", "26");  
    81.                 map.put("classes", "五期信息技术提高班");  
    82.                 try {  
    83.                     retStr = NetTool.sendGetRequest(url, map, "utf-8");  
    84.                 } catch (Exception e) {  
    85.                     e.printStackTrace();  
    86.                 }  
    87.                 break;  
    88.             case R.id.btnPost:  
    89.                 Map<String, String> map2 = new HashMap<String, String>();  
    90.                 map2.put("name", "李坤");  
    91.                 map2.put("age", "26");  
    92.                 map2.put("classes", "五期信息技术提高班");  
    93.                 try {  
    94.                     retStr = NetTool.sendPostRequest(url, map2, "utf-8");  
    95.                 } catch (Exception e) {  
    96.                     e.printStackTrace();  
    97.                 }  
    98.                 break;  
    99.             case R.id.btnHttpClient:  
    100.                 Map<String, String> map3 = new HashMap<String, String>();  
    101.                 map3.put("name", "李坤");  
    102.                 map3.put("age", "26");  
    103.                 map3.put("classes", "五期信息技术提高班");  
    104.                 try {  
    105.                     retStr = NetTool.sendHttpClientPost(url, map3, "utf-8");  
    106.                 } catch (Exception e) {  
    107.                     e.printStackTrace();  
    108.                 }  
    109.                 break;  
    110.             case R.id.btnUploadFile:  
    111.                 // 需要在sdcard中放一张image.jsp的图片,本例才能正确运行  
    112.                 try {  
    113.                     retStr = NetTool.sendFile(uploadUrl, "/sdcard/image.jpg",  
    114.                             "image1.jpg");  
    115.                 } catch (Exception e) {  
    116.                     e.printStackTrace();  
    117.                 }  
    118.                 break;  
    119.             case R.id.btnReadTxtFile:  
    120.                 try {  
    121.                     //本例中服务器端的文件类型是UTF-8  
    122.                     retStr = NetTool.readTxtFile(txtFileUrl, "UTF-8");  
    123.                 } catch (Exception e1) {  
    124.                     e1.printStackTrace();  
    125.                 }  
    126.                 break;  
    127.             case R.id.btnDownloadFile:  
    128.                 try {  
    129.                     NetTool.downloadFile(fileUrl, "/download", "newfile.jpg");  
    130.                 } catch (Exception e) {  
    131.                     e.printStackTrace();  
    132.                 }  
    133.                 break;  
    134.             default:  
    135.                 break;  
    136.             }  
    137.             tvData.setText(retStr);  
    138.         }  
    139.     };  
    140. }  


    客户端Student.java

    [java] view plain copy
     
    1. package com.tgb.lk.demo.model;  
    2.   
    3. public class Student {  
    4.     private int id;  
    5.     private String name;  
    6.     private String classes;  
    7.   
    8.     public int getId() {  
    9.         return id;  
    10.     }  
    11.   
    12.     public void setId(int id) {  
    13.         this.id = id;  
    14.     }  
    15.   
    16.     //get set方法略  
    17.   
    18.     @Override  
    19.     public String toString() {  
    20.         return "Student [classes=" + classes + ", id=" + id + ", name=" + name  
    21.                 + "]";  
    22.     }  
    23. }  

    客户端AndroidManifest.xml:

    [html] view plain copy
     
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
    3.     package="com.tgb.lk.demo.appclient"  
    4.     android:versionCode="1"  
    5.     android:versionName="1.0" >  
    6.   
    7.     <uses-sdk android:minSdkVersion="7" />  
    8.   
    9.     <application  
    10.         android:icon="@drawable/ic_launcher"  
    11.         android:label="@string/app_name" >  
    12.         <activity  
    13.             android:label="@string/app_name"  
    14.             android:name=".AppClientActivity" >  
    15.             <intent-filter >  
    16.                 <action android:name="android.intent.action.MAIN" />  
    17.   
    18.                 <category android:name="android.intent.category.LAUNCHER" />  
    19.             </intent-filter>  
    20.         </activity>  
    21.     </application>  
    22.   
    23.     <uses-permission android:name="android.permission.INTERNET" />  
    24.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />  
    25.   
    26. </manifest>  

    服务器端web.xml

    [html] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
    5.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
    6.     <servlet>  
    7.         <servlet-name>SynDataServlet</servlet-name>  
    8.         <servlet-class>com.tgb.lk.demo.appserver.SynDataServlet</servlet-class>  
    9.     </servlet>  
    10.     <servlet>  
    11.         <servlet-name>UploadFileServlet</servlet-name>  
    12.         <servlet-class>com.tgb.lk.demo.appserver.UploadFileServlet</servlet-class>  
    13.     </servlet>  
    14.   <servlet>  
    15.     <servlet-name>SynTxtDataServlet</servlet-name>  
    16.     <servlet-class>com.tgb.lk.demo.appserver.SynTxtDataServlet</servlet-class>  
    17.   </servlet>  
    18.   
    19.   
    20.     <servlet-mapping>  
    21.         <servlet-name>SynDataServlet</servlet-name>  
    22.         <url-pattern>/SynDataServlet</url-pattern>  
    23.     </servlet-mapping>  
    24.     <servlet-mapping>  
    25.         <servlet-name>UploadFileServlet</servlet-name>  
    26.         <url-pattern>/UploadFileServlet</url-pattern>  
    27.     </servlet-mapping>  
    28.   <servlet-mapping>  
    29.     <servlet-name>SynTxtDataServlet</servlet-name>  
    30.     <url-pattern>/SynTxtDataServlet</url-pattern>  
    31.   </servlet-mapping>  
    32.   
    33.     <welcome-file-list>  
    34.         <welcome-file>index.jsp</welcome-file>  
    35.     </welcome-file-list>  
    36. </web-app>  


    服务器端SynDataServlet.java

    [java] view plain copy
     
    1. package com.tgb.lk.demo.appserver;  
    2.   
    3. import java.io.IOException;  
    4. import java.io.PrintWriter;  
    5.   
    6. import javax.servlet.ServletException;  
    7. import javax.servlet.http.HttpServlet;  
    8. import javax.servlet.http.HttpServletRequest;  
    9. import javax.servlet.http.HttpServletResponse;  
    10.   
    11. public class SynDataServlet extends HttpServlet {  
    12.   
    13.     public void doGet(HttpServletRequest request, HttpServletResponse response)  
    14.             throws ServletException, IOException {  
    15.         System.out.println("---------get-------------");  
    16.         // 处理中文乱码问题解决办法  
    17.         String name = new String(request.getParameter("name").getBytes(  
    18.                 "iso-8859-1"), "UTF-8");  
    19.         String age = request.getParameter("age");  
    20.         String classes = new String(request.getParameter("classes").getBytes(  
    21.                 "iso-8859-1"), "UTF-8");  
    22.         System.out.println("-------" + name + age + classes + "--------");  
    23.         response.setContentType("text/xml; charset=UTF-8");  
    24.         PrintWriter out = response.getWriter();  
    25.         out.print("GET method ");  
    26.         out.print("name=" + name + ",age=" + age + ",classes=" + classes);  
    27.         out.flush();  
    28.         out.close();  
    29.     }  
    30.   
    31.     public void doPost(HttpServletRequest request, HttpServletResponse response)  
    32.             throws ServletException, IOException {  
    33.         System.out.println("---------post-------------");  
    34.         String name = new String(request.getParameter("name").getBytes(  
    35.                 "iso-8859-1"), "UTF-8");  
    36.         String age = request.getParameter("age");  
    37.         String classes = new String(request.getParameter("classes").getBytes(  
    38.                 "iso-8859-1"), "UTF-8");  
    39.         System.out.println("--------" + name + age + classes + "---------");  
    40.         response.setContentType("text/xml; charset=UTF-8");  
    41.         PrintWriter out = response.getWriter();  
    42.         out.print("POST method");  
    43.         out.print("name=" + name + ",age=" + age + ",classes=" + classes);  
    44.         out.flush();  
    45.         out.close();  
    46.     }  
    47.   
    48. }  


    服务器端SynTxtDataServlet.java

    [java] view plain copy
     
    1. package com.tgb.lk.demo.appserver;  
    2.   
    3. import java.io.BufferedReader;  
    4. import java.io.IOException;  
    5. import java.io.InputStreamReader;  
    6. import java.io.PrintWriter;  
    7.   
    8. import javax.servlet.ServletException;  
    9. import javax.servlet.http.HttpServlet;  
    10. import javax.servlet.http.HttpServletRequest;  
    11. import javax.servlet.http.HttpServletResponse;  
    12.   
    13. public class SynTxtDataServlet extends HttpServlet {  
    14.   
    15.     public void doPost(HttpServletRequest request, HttpServletResponse response)  
    16.             throws ServletException, IOException {  
    17.   
    18.         BufferedReader in = new BufferedReader(new InputStreamReader(request  
    19.                 .getInputStream(), "UTF-8"));  
    20.         // 数据  
    21.         String retData = null;  
    22.         String responseData = "";  
    23.         while ((retData = in.readLine()) != null) {  
    24.             responseData += retData;  
    25.         }  
    26.         in.close();  
    27.           
    28.         response.setContentType("text/xml; charset=UTF-8");  
    29.         PrintWriter out = response.getWriter();  
    30.         out.print("POST method");  
    31.         out.print(responseData);  
    32.         out.flush();  
    33.         out.close();  
    34.     }  
    35.   
    36. }  


    服务器端UploadFileServlet.java(服务器端需引入commons-fileupload-1.2.2.jar和commons-io-2.3.jar)

    [java] view plain copy
     
    1. package com.tgb.lk.demo.appserver;  
    2.   
    3. import java.io.File;  
    4. import java.io.IOException;  
    5. import java.util.ArrayList;  
    6. import java.util.Iterator;  
    7. import java.util.List;  
    8.   
    9. import javax.servlet.ServletException;  
    10. import javax.servlet.http.HttpServlet;  
    11. import javax.servlet.http.HttpServletRequest;  
    12. import javax.servlet.http.HttpServletResponse;  
    13.   
    14. import org.apache.commons.fileupload.FileUpload;  
    15. import org.apache.commons.fileupload.FileUploadException;  
    16. import org.apache.commons.fileupload.disk.DiskFileItem;  
    17. import org.apache.commons.fileupload.disk.DiskFileItemFactory;  
    18. import org.apache.commons.fileupload.servlet.ServletFileUpload;  
    19. import org.apache.commons.fileupload.servlet.ServletRequestContext;  
    20.   
    21. public class UploadFileServlet extends HttpServlet {  
    22.   
    23.     public void doPost(HttpServletRequest request, HttpServletResponse response)  
    24.             throws ServletException, IOException {  
    25.         // 设置request编码，主要是为了处理普通输入框中的中文问题  
    26.         request.setCharacterEncoding("gbk");  
    27.         // 这里对request进行封装，RequestContext提供了对request多个访问方法  
    28.         org.apache.commons.fileupload.RequestContext requestContext = new ServletRequestContext(  
    29.                 request);  
    30.         // 判断表单是否是Multipart类型的。这里可以直接对request进行判断，不过已经以前的用法了  
    31.         if (FileUpload.isMultipartContent(requestContext)) {  
    32.   
    33.             DiskFileItemFactory factory = new DiskFileItemFactory();  
    34.             // 设置文件的缓存路径  
    35.             factory.setRepository(new File("d:/tmp/"));  
    36.             File dir = new File("d:\download\");  
    37.             if (!dir.exists()) {  
    38.                 dir.mkdirs();  
    39.             }  
    40.             // System.out.print("已经生成临时文件");  
    41.   
    42.             ServletFileUpload upload = new ServletFileUpload(factory);  
    43.             // 设置上传文件大小的上限，-1表示无上限  
    44.             upload.setSizeMax(100000 * 1024 * 1024);  
    45.             List items = new ArrayList();  
    46.             try {  
    47.                 // 上传文件，并解析出所有的表单字段，包括普通字段和文件字段  
    48.                 items = upload.parseRequest(request);  
    49.             } catch (FileUploadException e1) {  
    50.                 System.out.println("文件上传发生错误" + e1.getMessage());  
    51.             }  
    52.             // 下面对每个字段进行处理，分普通字段和文件字段  
    53.             Iterator it = items.iterator();  
    54.             while (it.hasNext()) {  
    55.                 DiskFileItem fileItem = (DiskFileItem) it.next();  
    56.                 // 如果是普通字段  
    57.                 if (fileItem.isFormField()) {  
    58.                     System.out.println(fileItem.getFieldName()  
    59.                             + "   "  
    60.                             + fileItem.getName()  
    61.                             + "   "  
    62.                             + new String(fileItem.getString().getBytes(  
    63.                                     "iso8859-1"), "gbk"));  
    64.                 } else {  
    65.                     System.out.println(fileItem.getFieldName() + "   "  
    66.                             + fileItem.getName() + "   "  
    67.                             + fileItem.isInMemory() + "    "  
    68.                             + fileItem.getContentType() + "   "  
    69.                             + fileItem.getSize());  
    70.                     // 保存文件，其实就是把缓存里的数据写到目标路径下  
    71.                     if (fileItem.getName() != null && fileItem.getSize() != 0) {  
    72.                         File fullFile = new File(fileItem.getName());  
    73.                         File newFile = new File("d:\download\"  
    74.                                 + fullFile.getName());  
    75.                         try {  
    76.                             fileItem.write(newFile);  
    77.                         } catch (Exception e) {  
    78.                             e.printStackTrace();  
    79.                         }  
    80.                     } else {  
    81.                         System.out.println("文件没有选择 或 文件内容为空");  
    82.                     }  
    83.                 }  
    84.   
    85.             }  
    86.         }  
    87.   
    88.     }  
    89.   
    90. }  


    限于本人水平有限,有很多地方写的并不完美,希望大家不吝赐教.

    源码下载地址: http://download.csdn.net/detail/lk_blog/4404383
  • 相关阅读:
    《我也能做CTO之程序员职业规划》之十五： 智商
    《.Net 软件设计新思维：像搭积木一样搭建软件》成书背后的故事
    测试有道：微软测试技术心得
    GTUG 推荐这本书给大家
    测试有道：微软测试技术心得
    独具匠心的好书:评《构建高性能Web站点》
    敏捷软件开发模型SCRUM
    JSP和Servlet性能优化
    软件项目管理的圣经人月神话(中)
    探讨JAR文件无限可能性
  • 原文地址：https://www.cnblogs.com/wangfeng520/p/5609262.html
Copyright © 2011-2022 走看看