Http学习之使用HttpURLConnection发送post和get请求 android

最常用的Http请求无非是get和post，get请求可以获取静态页面，也可以把参数放在URL字串后面，传递给servlet，post与get的不同之处在于post的参数不是放在URL字串里面，而是放在http请求的正文内。
在Java中可以使用HttpURLConnection发起这两种请求，了解此类，对于了解soap，和编写servlet的自动测试代码都有很大的帮助。
下面的代码简单描述了如何使用HttpURLConnection发起这两种请求，以及传递参数的方法：

 

Java代码  

1. package com.android.httpurl;  
2.   
3. import android.app.Activity;  
4.   
5. import android.os.Bundle;  
6. import android.os.Handler;  
7. import android.os.Message;  
8. import android.view.View;  
9. import android.view.View.OnClickListener;  
10. import android.widget.Button;  
11. import android.widget.EditText;  
12. import android.widget.TextView;  
13.   
14. import java.io.BufferedReader;  
15. import java.io.DataOutputStream;  
16. import java.io.InputStreamReader;  
17. import java.net.HttpURLConnection;  
18. import java.net.URL;  
19. import java.net.URLEncoder;  
20.   
21. public class HttpURLConActivity extends Activity {  
22.     final String URL = "http://122.224.144.102:8080/publicback/httpurl?par=ylx";  
23.     final String URL_Post = "http://122.224.144.102:8080/publicback/httpurl";  
24.     private Button submit;      
25.     private TextView result;     
26.     String resultData="";  
27.     URL url = null;  
28.     HttpURLConnection urlConn = null;  
29.     boolean isPost = true;  
30.     /** Called when the activity is first created. */  
31.     @Override  
32.     public void onCreate(Bundle savedInstanceState) {  
33.         super.onCreate(savedInstanceState);  
34.         setContentView(R.layout.main);  
35.           
36.         submit = (Button) this.findViewById(R.id.submit);  
37.         result = (TextView) this.findViewById(R.id.result);  
38.           
39.         submit.setOnClickListener(new OnClickListener(){  
40.   
41.             @Override  
42.             public void onClick(View arg0) {  
43.                 // TODO Auto-generated method stub  
44.                 HttpURL();  
45.             }  
46.   
47.               
48.               
49.         });  
50.           
51.     }  
52.     private void HttpURLConnection_Get(){  
53.         try{  
54.             isPost = false;  
55.             //通过openConnection 连接  
56.             URL url = new java.net.URL(URL);  
57.             urlConn=(HttpURLConnection)url.openConnection();  
58.             //设置输入和输出流   
59.             urlConn.setDoOutput(true);  
60.             urlConn.setDoInput(true);  
61.             //关闭连接  
62.             urlConn.disconnect();  
63.         }catch(Exception e){  
64.             resultData = "连接超时";  
65.             Message mg = Message.obtain();    
66.             mg.obj = resultData;    
67.             handler.sendMessage(mg);   
68.             e.printStackTrace();  
69.         }  
70.     }  
71.     private void HttpURLConnection_Post(){  
72.         try{  
73.             //通过openConnection 连接  
74.             URL url = new java.net.URL(URL_Post);  
75.             urlConn=(HttpURLConnection)url.openConnection();  
76.             //设置输入和输出流   
77.             urlConn.setDoOutput(true);  
78.             urlConn.setDoInput(true);  
79.               
80.             urlConn.setRequestMethod("POST");  
81.             urlConn.setUseCaches(false);  
82.             // 配置本次连接的Content-type，配置为application/x-www-form-urlencoded的    
83.             urlConn.setRequestProperty("Content-Type","application/x-www-form-urlencoded");    
84.             // 连接，从postUrl.openConnection()至此的配置必须要在connect之前完成，  
85.             // 要注意的是connection.getOutputStream会隐含的进行connect。    
86.             urlConn.connect();  
87.             //DataOutputStream流  
88.             DataOutputStream out = new DataOutputStream(urlConn.getOutputStream());  
89.             //要上传的参数  
90.             String content = "par=" + URLEncoder.encode("ylx_Post+中正", "UTF_8");   
91.             //将要上传的内容写入流中  
92.             out.writeBytes(content);     
93.             //刷新、关闭  
94.             out.flush();  
95.             out.close();     
96.               
97.         }catch(Exception e){  
98.             resultData = "连接超时";  
99.             Message mg = Message.obtain();    
100.             mg.obj = resultData;    
101.             handler.sendMessage(mg);   
102.             e.printStackTrace();  
103.         }  
104.     }  
105.     private void HttpURL() {  
106.         new Thread(){  
107.             public void run() {   
108.   
109.                 try{  
110.                     //Get方式  
111.                     //HttpURLConnection_Get();  
112.                     //Post方式  
113.                     HttpURLConnection_Post();   
114.                       
115.                     InputStreamReader in = new InputStreamReader(urlConn.getInputStream());    
116.                     BufferedReader buffer = new BufferedReader(in);    
117.                     String inputLine = null;    
118.                     while (((inputLine = buffer.readLine()) != null)){  
119.                         resultData += inputLine + "\n";    
120.                     }  
121.                     System.out.println(resultData);  
122.                     in.close();   
123.   
124.                 }catch(Exception e){  
125.                     resultData = "连接超时";  
126.                     e.printStackTrace();  
127.                 }finally{  
128.                     try{  
129.                         //关闭连接  
130.                         if(isPost)  
131.                         urlConn.disconnect();  
132.                           
133.                         Message mg = Message.obtain();    
134.                         mg.obj = resultData;    
135.                         handler.sendMessage(mg);    
136.                     }catch(Exception e){  
137.                         e.printStackTrace();  
138.                     }  
139.                 }  
140.             }  
141.         }.start();  
142.     }  
143.     private Handler handler = new Handler() {    
144.         @Override    
145.         public void handleMessage(Message msg) {    
146.             String m = (String) msg.obj;    
147.             result.setText(m);    
148.         }    
149.     };    
150.   
151. }  

 HttpURLConnection.connect函数，实际上只是建立了一个与服务器的tcp连接，并没有实际发送http请求。无论是post还是get，http请求实际上直到HttpURLConnection.getInputStream()这个函数里面才正式发送出去。
对connection对象的一切配置（那一堆set函数）都必须要在connect()函数执行之前完成。而对outputStream的写操作，又必须要在inputStream的读操作之前。这些顺序实际上是由http请求的格式决定的。

http请求实际上由两部分组成，一个是http头，所有关于此次http请求的配置都在http头里面定义，一个是正文content，在connect()函数里面，会根据HttpURLConnection对象的配置值生成http头，因此在调用connect函数之前，就必须把所有的配置准备好。

紧接着http头的是http请求的正文，正文的内容通过outputStream写入，实际上outputStream不是一个网络流，充其量是个字符串流，往里面写入的东西不会立即发送到网络，而是在流关闭后，根据输入的内容生成http正文。

至此，http请求的东西已经准备就绪。在getInputStream()函数调用的时候，就会把准备好的http请求正式发送到服务器了，然后返回一个输入流，用于读取服务器对于此次http请求的返回信息。由于http请求在getInputStream的时候已经发送出去了（包括http头和正文），因此在getInputStream()函数之后对connection对象进行设置（对http头的信息进行修改）或者写入outputStream（对正文进行修改）都是没有意义的了，执行这些操作会导致异常的发生。

 

转：http://zjutsoft.iteye.com/blog/1313754