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

客户端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. <TextView
7. android:id="@+id/tvData"
8. android:layout_width="fill_parent"
9. android:layout_height="wrap_content"
10. android:text="数据" />
11. <Button
12. android:id="@+id/btnTxt"
13. android:layout_width="fill_parent"
14. android:layout_height="wrap_content"
15. android:text="与服务器端交互Json数据" />
16. <Button
17. android:id="@+id/btnGet"
18. android:layout_width="fill_parent"
19. android:layout_height="wrap_content"
20. android:text="Get方式与服务器端交互数据" />
21. <Button
22. android:id="@+id/btnPost"
23. android:layout_width="fill_parent"
24. android:layout_height="wrap_content"
25. android:text="Post方式与服务器端交互数据" />
26. <Button
27. android:id="@+id/btnHttpClient"
28. android:layout_width="fill_parent"
29. android:layout_height="wrap_content"
30. android:text="HttpClient方式与服务器端交互数据" />
31. <Button
32. android:id="@+id/btnUploadFile"
33. android:layout_width="fill_parent"
34. android:layout_height="wrap_content"
35. android:text="上传文件到服务器端" />
36. <Button
37. android:id="@+id/btnDownloadFile"
38. android:layout_width="fill_parent"
39. android:layout_height="wrap_content"
40. android:text="从服务器端下载文件" />
41. <Button
42. android:id="@+id/btnReadTxtFile"
43. android:layout_width="fill_parent"
44. android:layout_height="wrap_content"
45. android:text="从服务器端读取文本文件" />
46. </LinearLayout>

客户端AppClientActivity.java:

[java] view plain copy

1. package com.tgb.lk.demo.appclient;
2. import java.util.HashMap;
3. import java.util.Map;
4. import com.google.gson.Gson;
5. import com.tgb.lk.demo.model.Student;
6. import com.tgb.lk.demo.util.NetTool;
7. import android.app.Activity;
8. import android.os.Bundle;
9. import android.view.View;
10. import android.view.View.OnClickListener;
11. import android.widget.Button;
12. import android.widget.TextView;
13. public class AppClientActivity extends Activity {
14. private TextView tvData = null;
15. private Button btnTxt = null;
16. private Button btnGet = null;
17. private Button btnPost = null;
18. private Button btnHttpClient = null;
19. private Button btnUploadFile = null;
20. private Button btnReadTxtFile = null;
21. private Button btnDownloadFile = null;
22. //需要将下面的IP改为服务器端IP
23. private String txtUrl = "http://192.168.1.46:8080/AppServer/SynTxtDataServlet";
24. private String url = "http://192.168.1.46:8080/AppServer/SynDataServlet";
25. private String uploadUrl = "http://192.168.1.46:8080/AppServer/UploadFileServlet";
26. private String fileUrl = "http://192.168.1.46:8080/AppServer/file.jpg";
27. private String txtFileUrl = "http://192.168.1.46:8080/AppServer/txtFile.txt";
28. @Override
29. public void onCreate(Bundle savedInstanceState) {
30. super.onCreate(savedInstanceState);
31. setContentView(R.layout.main);
32. tvData = (TextView) findViewById(R.id.tvData);
33. btnTxt = (Button) findViewById(R.id.btnTxt);
34. btnGet = (Button) findViewById(R.id.btnGet);
35. btnPost = (Button) findViewById(R.id.btnPost);
36. btnHttpClient = (Button) findViewById(R.id.btnHttpClient);
37. btnUploadFile = (Button) findViewById(R.id.btnUploadFile);
38. btnReadTxtFile = (Button) findViewById(R.id.btnReadTxtFile);
39. btnDownloadFile = (Button) findViewById(R.id.btnDownloadFile);
40. btnTxt.setOnClickListener(btnListener);
41. btnGet.setOnClickListener(btnListener);
42. btnPost.setOnClickListener(btnListener);
43. btnHttpClient.setOnClickListener(btnListener);
44. btnUploadFile.setOnClickListener(btnListener);
45. btnReadTxtFile.setOnClickListener(btnListener);
46. btnDownloadFile.setOnClickListener(btnListener);
47. }
48. OnClickListener btnListener = new OnClickListener() {
49. String retStr = "";
50. @Override
51. public void onClick(View v) {
52. switch (v.getId()) {
53. case R.id.btnTxt:
54. Student student = new Student();
55. student.setId(1);
56. student.setName("李坤");
57. student.setClasses("五期信息技术提高班");
58. Gson gson = new Gson();
59. String jsonTxt = gson.toJson(student);
60. try {
61. retStr = NetTool.sendTxt(txtUrl, jsonTxt,"UTF-8");
62. } catch (Exception e2) {
63. e2.printStackTrace();
64. }
65. break;
66. case R.id.btnGet:
67. Map<String, String> map = new HashMap<String, String>();
68. map.put("name", "李坤");
69. map.put("age", "26");
70. map.put("classes", "五期信息技术提高班");
71. try {
72. retStr = NetTool.sendGetRequest(url, map, "utf-8");
73. } catch (Exception e) {
74. e.printStackTrace();
75. }
76. break;
77. case R.id.btnPost:
78. Map<String, String> map2 = new HashMap<String, String>();
79. map2.put("name", "李坤");
80. map2.put("age", "26");
81. map2.put("classes", "五期信息技术提高班");
82. try {
83. retStr = NetTool.sendPostRequest(url, map2, "utf-8");
84. } catch (Exception e) {
85. e.printStackTrace();
86. }
87. break;
88. case R.id.btnHttpClient:
89. Map<String, String> map3 = new HashMap<String, String>();
90. map3.put("name", "李坤");
91. map3.put("age", "26");
92. map3.put("classes", "五期信息技术提高班");
93. try {
94. retStr = NetTool.sendHttpClientPost(url, map3, "utf-8");
95. } catch (Exception e) {
96. e.printStackTrace();
97. }
98. break;
99. case R.id.btnUploadFile:
100. // 需要在sdcard中放一张image.jsp的图片,本例才能正确运行
101. try {
102. retStr = NetTool.sendFile(uploadUrl, "/sdcard/image.jpg",
103. "image1.jpg");
104. } catch (Exception e) {
105. e.printStackTrace();
106. }
107. break;
108. case R.id.btnReadTxtFile:
109. try {
110. //本例中服务器端的文件类型是UTF-8
111. retStr = NetTool.readTxtFile(txtFileUrl, "UTF-8");
112. } catch (Exception e1) {
113. e1.printStackTrace();
114. }
115. break;
116. case R.id.btnDownloadFile:
117. try {
118. NetTool.downloadFile(fileUrl, "/download", "newfile.jpg");
119. } catch (Exception e) {
120. e.printStackTrace();
121. }
122. break;
123. default:
124. break;
125. }
126. tvData.setText(retStr);
127. }
128. };
129. }

客户端Student.java

[java] view plain copy

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

客户端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. <uses-sdk android:minSdkVersion="7" />
7. <application
8. android:icon="@drawable/ic_launcher"
9. android:label="@string/app_name" >
10. <activity
11. android:label="@string/app_name"
12. android:name=".AppClientActivity" >
13. <intent-filter >
14. <action android:name="android.intent.action.MAIN" />
15. <category android:name="android.intent.category.LAUNCHER" />
16. </intent-filter>
17. </activity>
18. </application>
19. <uses-permission android:name="android.permission.INTERNET" />
20. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
21. </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. <servlet-mapping>
19. <servlet-name>SynDataServlet</servlet-name>
20. <url-pattern>/SynDataServlet</url-pattern>
21. </servlet-mapping>
22. <servlet-mapping>
23. <servlet-name>UploadFileServlet</servlet-name>
24. <url-pattern>/UploadFileServlet</url-pattern>
25. </servlet-mapping>
26. <servlet-mapping>
27. <servlet-name>SynTxtDataServlet</servlet-name>
28. <url-pattern>/SynTxtDataServlet</url-pattern>
29. </servlet-mapping>
30. <welcome-file-list>
31. <welcome-file>index.jsp</welcome-file>
32. </welcome-file-list>
33. </web-app>

服务器端SynDataServlet.java

[java] view plain copy

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

服务器端SynTxtDataServlet.java

[java] view plain copy

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

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

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

源码下载地址: http://download.csdn.net/detail/lk_blog/4404383