安卓客户端与服务器端交互

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

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 plaincopy

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 plaincopy

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 plaincopy

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 plaincopy

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 plaincopy

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 plaincopy

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 plaincopy

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 plaincopy

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 plaincopy

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