HttpClient(访问网络) get方式,post方式。返回值有String,InputStream,byte[]

  1. import java.io.ByteArrayOutputStream;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.util.ArrayList;  
  5. import java.util.List;  
  6. import java.util.Map;  
  7.   
  8.   
  9. import org.apache.http.HttpEntity;  
  10. import org.apache.http.HttpResponse;  
  11. import org.apache.http.NameValuePair;  
  12. import org.apache.http.client.HttpClient;  
  13. import org.apache.http.client.entity.UrlEncodedFormEntity;  
  14. import org.apache.http.client.methods.HttpGet;  
  15. import org.apache.http.client.methods.HttpPost;  
  16. import org.apache.http.impl.client.DefaultHttpClient;  
  17. import org.apache.http.message.BasicNameValuePair;  
  18. import org.apache.http.util.EntityUtils;  
  19.   
  20.   
  21. public class HttpClientHelper {  
  22.     /** 
  23.      * 作用:实现网络访问文件,将获取到数据储存在文件流中 
  24.      *  
  25.      * @param url 
  26.      *            :访问网络的url地址 
  27.      * @return inputstream 
  28.      */  
  29.     public static InputStream loadFileFromURL(String url) {  
  30.         // 创建HttpClient对象:通过实例化DefaultHttpClient获得;  
  31.         HttpClient httpClient = new DefaultHttpClient();  
  32.         // 创建HttpGet或HttpPost对象:通过实例化 HttpGet或HttpPost  
  33.         // 获得,而构造方法的参数是urlstring(即需要访问的网络url地址)。也可以通过调用setParams()方法来添加请求参数;  
  34.         HttpGet methodGet = new HttpGet(url);  
  35.         try {  
  36.             // 调用HttpClient对象的execute()方法,参数是刚才创建的 HttpGet或HttpPost对象  
  37.             // ,返回值是HttpResponse对象;  
  38.             HttpResponse response = httpClient.execute(methodGet);  
  39.             // 通过response对象中的getStatusLine()方法和getStatusCode()方法获取服务器响应状态。  
  40.             if (response.getStatusLine().getStatusCode() == 200) {  
  41.                 // response对象的getEntity()方法,返回HttpEntity对象。该对象中包含了服务器页面body体之内的内容。  
  42.                 HttpEntity entity = response.getEntity();  
  43.                 // entity对象的getContent()方法将从服务器中获取到所有内容放到inputstream对象中。  
  44.                 return entity.getContent();  
  45.             }  
  46.         } catch (Exception e) {  
  47.             e.printStackTrace();  
  48.         }  
  49.         return null;  
  50.     }  
  51.   
  52.   
  53.     /** 
  54.      * 作用:实现网络访问文件,返回字符串 
  55.      *  
  56.      * @param url 
  57.      *            :访问网络的url地址 
  58.      * @return String 
  59.      */  
  60.     public static String loadTextFromURL(String url) {  
  61.         HttpClient httpClient = new DefaultHttpClient();  
  62.         HttpGet methodGet = new HttpGet(url);  
  63.         try {  
  64.             HttpResponse response = httpClient.execute(methodGet);  
  65.             if (response.getStatusLine().getStatusCode() == 200) {  
  66.                 HttpEntity entity = response.getEntity();  
  67.                 // 借助EntityUtils的toString()方法对 HttpEntity对象进行处理,返回字符串。  
  68.                 return EntityUtils.toString(entity);  
  69.             }  
  70.         } catch (Exception e) {  
  71.             e.printStackTrace();  
  72.         }  
  73.         return null;  
  74.     }  
  75.   
  76.   
  77.     /** 
  78.      * 作用:实现网络访问文件,将获取到的数据存在字节数组中 
  79.      *  
  80.      * @param url 
  81.      *            :访问网络的url地址 
  82.      * @return byte[] 
  83.      */  
  84.     public static byte[] loadByteFromURL(String url) {  
  85.         HttpClient httpClient = new DefaultHttpClient();  
  86.         HttpGet methodGet = new HttpGet(url);  
  87.         try {  
  88.             HttpResponse response = httpClient.execute(methodGet);  
  89.             if (response.getStatusLine().getStatusCode() == 200) {  
  90.                 HttpEntity entity = response.getEntity();  
  91.                 // 借助EntityUtils的toByteArray()方法对  
  92.                 // HttpEntity对象进行处理,将entity对象中的内容处理成自己数组。  
  93.                 return EntityUtils.toByteArray(entity);  
  94.             }  
  95.         } catch (Exception e) {  
  96.             e.printStackTrace();  
  97.         }  
  98.         return null;  
  99.     }  
  100.   
  101.   
  102.     /** 
  103.      * 作用:实现网络访问文件,先给服务器通过“GET”方式提交数据,再返回相应的数据 
  104.      *  
  105.      * @param url 
  106.      *            :访问网络的url地址 
  107.      * @param params 
  108.      *            :访问url时,需要传递给服务器的参数。格式为:username=wangxiangjun&password=abcde& 
  109.      *            qq=32432432 
  110.      *            为了防止传中文参数时出现编码问题。采用URLEncoder.encode()对含中文的字符串进行编码处理。 
  111.      *            服务器端会自动对进行过编码的字符串进行decode()解码。 
  112.      * @return byte[] 
  113.      */  
  114.     public static byte[] doGetSubmit(String url, String params) {  
  115.         HttpClient httpClient = new DefaultHttpClient();  
  116.         HttpGet methodGet = new HttpGet(url + "?" + params);  
  117.         try {  
  118.             HttpResponse response = httpClient.execute(methodGet);  
  119.             if (response.getStatusLine().getStatusCode() == 200) {  
  120.                 HttpEntity entity = response.getEntity();  
  121.                 // 借助EntityUtils的toByteArray()方法对  
  122.                 // HttpEntity对象进行处理,将entity对象中的内容处理成自己数组。  
  123.                 return EntityUtils.toByteArray(entity);  
  124.             }  
  125.         } catch (Exception e) {  
  126.             e.printStackTrace();  
  127.         }  
  128.         return null;  
  129.     }  
  130.   
  131.   
  132.     /** 
  133.      * 作用:实现网络访问文件,先给服务器通过“POST”方式提交数据,再返回相应的数据 
  134.      *  
  135.      * @param url 
  136.      *            :访问网络的url地址 
  137.      * @param 
  138.      *  
  139.      * @return byte[] 
  140.      */  
  141.     public static byte[] doPostSubmit(String url, List<NameValuePair> params) {  
  142.         HttpClient httpClient = new DefaultHttpClient();  
  143.         HttpPost methodPost = new HttpPost(url);  
  144.         try {  
  145.             methodPost.setEntity(new UrlEncodedFormEntity(params));  
  146.             HttpResponse response = httpClient.execute(methodPost);  
  147.             if (response.getStatusLine().getStatusCode() == 200) {  
  148.                 HttpEntity entity = response.getEntity();  
  149.                 // 借助EntityUtils的toByteArray()方法对  
  150.                 // HttpEntity对象进行处理,将entity对象中的内容处理成自己数组。  
  151.                 return EntityUtils.toByteArray(entity);  
  152.             }  
  153.         } catch (Exception e) {  
  154.             e.printStackTrace();  
  155.         }  
  156.         return null;  
  157.     }  
  158.   
  159.   
  160.     /** 
  161.      * 作用:实现网络访问文件,先给服务器通过“POST”方式提交数据,再返回相应的数据 
  162.      *  
  163.      * @param url 
  164.      *            :访问网络的url地址 
  165.      * @param 
  166.      * @return byte[] 
  167.      */  
  168.     public static byte[] doPostSubmit(String url, Map<String, Object> params) {  
  169.         HttpClient httpClient = new DefaultHttpClient();  
  170.         HttpPost methodPost = new HttpPost(url);  
  171.         // 将map中的数据一一放进List<NameValuePair>对象中。  
  172.         // 之所以要做这一步骤,是因为HttpPost对象的setEntity()方法只接收List<NameValuePair>对象作为参数。  
  173.         List<NameValuePair> list = new ArrayList<NameValuePair>();  
  174.         for (Map.Entry<String, Object> entry : params.entrySet()) {  
  175.             list.add(new BasicNameValuePair(entry.getKey(), entry.getValue()  
  176.                     .toString()));  
  177.         }  
  178.         try {  
  179.             // 将表单中的数据先放进list对象中,然后再被放到UrlEncodedFormEntity对象中,  
  180.             // 最后再通过HttpPost对象的setEntity()方法将这些表单数据传递到服务器中的request对象中。  
  181.             methodPost.setEntity(new UrlEncodedFormEntity(list, "utf-8"));  
  182.             HttpResponse response = httpClient.execute(methodPost);  
  183.             if (response.getStatusLine().getStatusCode() == 200) {  
  184.                 HttpEntity entity = response.getEntity();  
  185.                 // 借助EntityUtils的toByteArray()方法对  
  186.                 // HttpEntity对象进行处理,将entity对象中的内容处理成自己数组。  
  187.                 return EntityUtils.toByteArray(entity);  
  188.             }  
  189.         } catch (Exception e) {  
  190.             e.printStackTrace();  
  191.         }  
  192.         return null;  
  193.     }  
  194.   
  195.   
  196.     /** 
  197.      * 作用:将输入流转成字节数组 
  198.      *  
  199.      * * @return byte[] 
  200.      */  
  201.     public static byte[] inputStreamToByte(InputStream is) {  
  202.         ByteArrayOutputStream baos = null;  
  203.         byte[] buffer = new byte[8 * 1024];  
  204.         int c = 0;  
  205.         try {  
  206.             while ((c = is.read(buffer)) != -1) {  
  207.                 baos.write(buffer, 0, c);  
  208.                 baos.flush();  
  209.             }  
  210.             return baos.toByteArray();  
  211.         } catch (IOException e) {  
  212.             e.printStackTrace();  
  213.         } finally {  
  214.             if (baos != null) {  
  215.                 try {  
  216.                     baos.close();  
  217.                 } catch (IOException e) {  
  218.                     e.printStackTrace();  
  219.                 }  
  220.             }  
  221.         }  
  222.         return null;  
  223.     }  
  224. }  
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值