devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java实现HTTP协议发送的三种方式_java 如何使用传输httpentity

作者：weixin_40725706 | 2024-03-24 14:06:52

赞

踩

java 如何使用传输httpentity

Java实现HTTP请求的三种方式

　　目前JAVA实现HTTP请求的方法用的最多的有两种：一种是通过HTTPClient这种第三方的开源框架去实现。HTTPClient对HTTP的封装性比较不错，通过它基本上能够满足我们大部分的需求，HttpClient3.1 是 org.apache.commons.httpclient下操作远程 url的工具包，虽然已不再更新，但实现工作中使用httpClient3.1的代码还是很多，HttpClient4.5是org.apache.http.client下操作远程 url的工具包，最新的；另一种则是通过HttpURLConnection去实现，HttpURLConnection是JAVA的标准类，是JAVA比较原生的一种实现方式。

第一种方式：java原生HttpURLConnection

 

  1. package com.powerX.httpClient;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.io.OutputStream;
  8. import java.net.HttpURLConnection;
  9. import java.net.MalformedURLException;
  10. import java.net.URL;
  11.  
  12. public class HttpClient {
  13.     public static String doGet(String httpurl) {
  14.         HttpURLConnection connection = null;
  15.         InputStream is = null;
  16.         BufferedReader br = null;
  17.         String result = null;// 返回结果字符串
  18.         try {
  19.             // 创建远程url连接对象
  20.             URL url = new URL(httpurl);
  21.             // 通过远程url连接对象打开一个连接，强转成httpURLConnection类
  22.             connection = (HttpURLConnection) url.openConnection();
  23.             // 设置连接方式：get
  24.             connection.setRequestMethod("GET");
  25.             // 设置连接主机服务器的超时时间：15000毫秒
  26.             connection.setConnectTimeout(15000);
  27.             // 设置读取远程返回的数据时间：60000毫秒
  28.             connection.setReadTimeout(60000);
  29.             // 发送请求
  30.             connection.connect();
  31.             // 通过connection连接，获取输入流
  32.             if (connection.getResponseCode() == 200) {
  33.                 is = connection.getInputStream();
  34.                 // 封装输入流is，并指定字符集
  35.                 br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
  36.                 // 存放数据
  37.                 StringBuffer sbf = new StringBuffer();
  38.                 String temp = null;
  39.                 while ((temp = br.readLine()) != null) {
  40.                     sbf.append(temp);
  41.                     sbf.append("\r\n");
  42.                 }
  43.                 result = sbf.toString();
  44.             }
  45.         } catch (MalformedURLException e) {
  46.             e.printStackTrace();
  47.         } catch (IOException e) {
  48.             e.printStackTrace();
  49.         } finally {
  50.             // 关闭资源
  51.             if (null != br) {
  52.                 try {
  53.                     br.close();
  54.                 } catch (IOException e) {
  55.                     e.printStackTrace();
  56.                 }
  57.             }
  58.  
  59.             if (null != is) {
  60.                 try {
  61.                     is.close();
  62.                 } catch (IOException e) {
  63.                     e.printStackTrace();
  64.                 }
  65.             }
  66.  
  67.             connection.disconnect();// 关闭远程连接
  68.         }
  69.  
  70.         return result;
  71.     }
  72.  
  73.     public static String doPost(String httpUrl, String param) {
  74.  
  75.         HttpURLConnection connection = null;
  76.         InputStream is = null;
  77.         OutputStream os = null;
  78.         BufferedReader br = null;
  79.         String result = null;
  80.         try {
  81.             URL url = new URL(httpUrl);
  82.             // 通过远程url连接对象打开连接
  83.             connection = (HttpURLConnection) url.openConnection();
  84.             // 设置连接请求方式
  85.             connection.setRequestMethod("POST");
  86.             // 设置连接主机服务器超时时间：15000毫秒
  87.             connection.setConnectTimeout(15000);
  88.             // 设置读取主机服务器返回数据超时时间：60000毫秒
  89.             connection.setReadTimeout(60000);
  90.  
  91.             // 默认值为：false，当向远程服务器传送数据/写数据时，需要设置为true
  92.             connection.setDoOutput(true);
  93.             // 默认值为：true，当前向远程服务读取数据时，设置为true，该参数可有可无
  94.             connection.setDoInput(true);
  95.             // 设置传入参数的格式:请求参数应该是 name1=value1&name2=value2 的形式。
  96.             connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
  97.             // 设置鉴权信息：Authorization: Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0
  98.             connection.setRequestProperty("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
  99.             // 通过连接对象获取一个输出流
  100.             os = connection.getOutputStream();
  101.             // 通过输出流对象将参数写出去/传输出去,它是通过字节数组写出的
  102.             os.write(param.getBytes());
  103.             // 通过连接对象获取一个输入流，向远程读取
  104.             if (connection.getResponseCode() == 200) {
  105.  
  106.                 is = connection.getInputStream();
  107.                 // 对输入流对象进行包装:charset根据工作项目组的要求来设置
  108.                 br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
  109.  
  110.                 StringBuffer sbf = new StringBuffer();
  111.                 String temp = null;
  112.                 // 循环遍历一行一行读取数据
  113.                 while ((temp = br.readLine()) != null) {
  114.                     sbf.append(temp);
  115.                     sbf.append("\r\n");
  116.                 }
  117.                 result = sbf.toString();
  118.             }
  119.         } catch (MalformedURLException e) {
  120.             e.printStackTrace();
  121.         } catch (IOException e) {
  122.             e.printStackTrace();
  123.         } finally {
  124.             // 关闭资源
  125.             if (null != br) {
  126.                 try {
  127.                     br.close();
  128.                 } catch (IOException e) {
  129.                     e.printStackTrace();
  130.                 }
  131.             }
  132.             if (null != os) {
  133.                 try {
  134.                     os.close();
  135.                 } catch (IOException e) {
  136.                     e.printStackTrace();
  137.                 }
  138.             }
  139.             if (null != is) {
  140.                 try {
  141.                     is.close();
  142.                 } catch (IOException e) {
  143.                     e.printStackTrace();
  144.                 }
  145.             }
  146.             // 断开与远程地址url的连接
  147.             connection.disconnect();
  148.         }
  149.         return result;
  150.     }
  151. }

 

第二种方式：apache HttpClient3.1

 

  1. package com.powerX.httpClient;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.io.UnsupportedEncodingException;
  8. import java.util.Iterator;
  9. import java.util.Map;
  10. import java.util.Map.Entry;
  11. import java.util.Set;
  12.  
  13. import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
  14. import org.apache.commons.httpclient.HttpClient;
  15. import org.apache.commons.httpclient.HttpStatus;
  16. import org.apache.commons.httpclient.NameValuePair;
  17. import org.apache.commons.httpclient.methods.GetMethod;
  18. import org.apache.commons.httpclient.methods.PostMethod;
  19. import org.apache.commons.httpclient.params.HttpMethodParams;
  20.  
  21. public class HttpClient3 {
  22.  
  23.     public static String doGet(String url) {
  24.         // 输入流
  25.         InputStream is = null;
  26.         BufferedReader br = null;
  27.         String result = null;
  28.         // 创建httpClient实例
  29.         HttpClient httpClient = new HttpClient();
  30.         // 设置http连接主机服务超时时间：15000毫秒
  31.         // 先获取连接管理器对象，再获取参数对象,再进行参数的赋值
  32.         httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(15000);
  33.         // 创建一个Get方法实例对象
  34.         GetMethod getMethod = new GetMethod(url);
  35.         // 设置get请求超时为60000毫秒
  36.         getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 60000);
  37.         // 设置请求重试机制，默认重试次数：3次，参数设置为true，重试机制可用，false相反
  38.         getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(3, true));
  39.         try {
  40.             // 执行Get方法
  41.             int statusCode = httpClient.executeMethod(getMethod);
  42.             // 判断返回码
  43.             if (statusCode != HttpStatus.SC_OK) {
  44.                 // 如果状态码返回的不是ok,说明失败了,打印错误信息
  45.                 System.err.println("Method faild: " + getMethod.getStatusLine());
  46.             } else {
  47.                 // 通过getMethod实例，获取远程的一个输入流
  48.                 is = getMethod.getResponseBodyAsStream();
  49.                 // 包装输入流
  50.                 br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
  51.  
  52.                 StringBuffer sbf = new StringBuffer();
  53.                 // 读取封装的输入流
  54.                 String temp = null;
  55.                 while ((temp = br.readLine()) != null) {
  56.                     sbf.append(temp).append("\r\n");
  57.                 }
  58.  
  59.                 result = sbf.toString();
  60.             }
  61.  
  62.         } catch (IOException e) {
  63.             e.printStackTrace();
  64.         } finally {
  65.             // 关闭资源
  66.             if (null != br) {
  67.                 try {
  68.                     br.close();
  69.                 } catch (IOException e) {
  70.                     e.printStackTrace();
  71.                 }
  72.             }
  73.             if (null != is) {
  74.                 try {
  75.                     is.close();
  76.                 } catch (IOException e) {
  77.                     e.printStackTrace();
  78.                 }
  79.             }
  80.             // 释放连接
  81.             getMethod.releaseConnection();
  82.         }
  83.         return result;
  84.     }
  85.  
  86.     public static String doPost(String url, Map<String, Object> paramMap) {
  87.         // 获取输入流
  88.         InputStream is = null;
  89.         BufferedReader br = null;
  90.         String result = null;
  91.         // 创建httpClient实例对象
  92.         HttpClient httpClient = new HttpClient();
  93.         // 设置httpClient连接主机服务器超时时间：15000毫秒
  94.         httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(15000);
  95.         // 创建post请求方法实例对象
  96.         PostMethod postMethod = new PostMethod(url);
  97.         // 设置post请求超时时间
  98.         postMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 60000);
  99.  
  100.         NameValuePair[] nvp = null;
  101.         // 判断参数map集合paramMap是否为空
  102.         if (null != paramMap && paramMap.size() > 0) {// 不为空
  103.             // 创建键值参数对象数组，大小为参数的个数
  104.             nvp = new NameValuePair[paramMap.size()];
  105.             // 循环遍历参数集合map
  106.             Set<Entry<String, Object>> entrySet = paramMap.entrySet();
  107.             // 获取迭代器
  108.             Iterator<Entry<String, Object>> iterator = entrySet.iterator();
  109.  
  110.             int index = 0;
  111.             while (iterator.hasNext()) {
  112.                 Entry<String, Object> mapEntry = iterator.next();
  113.                 // 从mapEntry中获取key和value创建键值对象存放到数组中
  114.                 try {
  115.                     nvp[index] = new NameValuePair(mapEntry.getKey(),
  116.                             new String(mapEntry.getValue().toString().getBytes("UTF-8"), "UTF-8"));
  117.                 } catch (UnsupportedEncodingException e) {
  118.                     e.printStackTrace();
  119.                 }
  120.                 index++;
  121.             }
  122.         }
  123.         // 判断nvp数组是否为空
  124.         if (null != nvp && nvp.length > 0) {
  125.             // 将参数存放到requestBody对象中
  126.             postMethod.setRequestBody(nvp);
  127.         }
  128.         // 执行POST方法
  129.         try {
  130.             int statusCode = httpClient.executeMethod(postMethod);
  131.             // 判断是否成功
  132.             if (statusCode != HttpStatus.SC_OK) {
  133.                 System.err.println("Method faild: " + postMethod.getStatusLine());
  134.             }
  135.             // 获取远程返回的数据
  136.             is = postMethod.getResponseBodyAsStream();
  137.             // 封装输入流
  138.             br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
  139.  
  140.             StringBuffer sbf = new StringBuffer();
  141.             String temp = null;
  142.             while ((temp = br.readLine()) != null) {
  143.                 sbf.append(temp).append("\r\n");
  144.             }
  145.  
  146.             result = sbf.toString();
  147.         } catch (IOException e) {
  148.             e.printStackTrace();
  149.         } finally {
  150.             // 关闭资源
  151.             if (null != br) {
  152.                 try {
  153.                     br.close();
  154.                 } catch (IOException e) {
  155.                     e.printStackTrace();
  156.                 }
  157.             }
  158.             if (null != is) {
  159.                 try {
  160.                     is.close();
  161.                 } catch (IOException e) {
  162.                     e.printStackTrace();
  163.                 }
  164.             }
  165.             // 释放连接
  166.             postMethod.releaseConnection();
  167.         }
  168.         return result;
  169.     }
  170. }

 

第三种方式：apache  httpClient4.5

 

  1. package com.powerX.httpClient;
  2.  
  3. import java.io.IOException;
  4. import java.io.UnsupportedEncodingException;
  5. import java.util.ArrayList;
  6. import java.util.Iterator;
  7. import java.util.List;
  8. import java.util.Map;
  9. import java.util.Map.Entry;
  10. import java.util.Set;
  11.  
  12. import org.apache.http.HttpEntity;
  13. import org.apache.http.NameValuePair;
  14. import org.apache.http.client.ClientProtocolException;
  15. import org.apache.http.client.config.RequestConfig;
  16. import org.apache.http.client.entity.UrlEncodedFormEntity;
  17. import org.apache.http.client.methods.CloseableHttpResponse;
  18. import org.apache.http.client.methods.HttpGet;
  19. import org.apache.http.client.methods.HttpPost;
  20. import org.apache.http.impl.client.CloseableHttpClient;
  21. import org.apache.http.impl.client.HttpClients;
  22. import org.apache.http.message.BasicNameValuePair;
  23. import org.apache.http.util.EntityUtils;
  24.  
  25. public class HttpClient4 {
  26.  
  27.     public static String doGet(String url) {
  28.         CloseableHttpClient httpClient = null;
  29.         CloseableHttpResponse response = null;
  30.         String result = "";
  31.         try {
  32.             // 通过址默认配置创建一个httpClient实例
  33.             httpClient = HttpClients.createDefault();
  34.             // 创建httpGet远程连接实例
  35.             HttpGet httpGet = new HttpGet(url);
  36.             // 设置请求头信息，鉴权
  37.             httpGet.setHeader("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
  38.             // 设置配置请求参数
  39.             RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(35000)// 连接主机服务超时时间
  40.                     .setConnectionRequestTimeout(35000)// 请求超时时间
  41.                     .setSocketTimeout(60000)// 数据读取超时时间
  42.                     .build();
  43.             // 为httpGet实例设置配置
  44.             httpGet.setConfig(requestConfig);
  45.             // 执行get请求得到返回对象
  46.             response = httpClient.execute(httpGet);
  47.             // 通过返回对象获取返回数据
  48.             HttpEntity entity = response.getEntity();
  49.             // 通过EntityUtils中的toString方法将结果转换为字符串
  50.             result = EntityUtils.toString(entity);
  51.         } catch (ClientProtocolException e) {
  52.             e.printStackTrace();
  53.         } catch (IOException e) {
  54.             e.printStackTrace();
  55.         } finally {
  56.             // 关闭资源
  57.             if (null != response) {
  58.                 try {
  59.                     response.close();
  60.                 } catch (IOException e) {
  61.                     e.printStackTrace();
  62.                 }
  63.             }
  64.             if (null != httpClient) {
  65.                 try {
  66.                     httpClient.close();
  67.                 } catch (IOException e) {
  68.                     e.printStackTrace();
  69.                 }
  70.             }
  71.         }
  72.         return result;
  73.     }
  74.  
  75.     public static String doPost(String url, Map<String, Object> paramMap) {
  76.         CloseableHttpClient httpClient = null;
  77.         CloseableHttpResponse httpResponse = null;
  78.         String result = "";
  79.         // 创建httpClient实例
  80.         httpClient = HttpClients.createDefault();
  81.         // 创建httpPost远程连接实例
  82.         HttpPost httpPost = new HttpPost(url);
  83.         // 配置请求参数实例
  84.         RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(35000)// 设置连接主机服务超时时间
  85.                 .setConnectionRequestTimeout(35000)// 设置连接请求超时时间
  86.                 .setSocketTimeout(60000)// 设置读取数据连接超时时间
  87.                 .build();
  88.         // 为httpPost实例设置配置
  89.         httpPost.setConfig(requestConfig);
  90.         // 设置请求头
  91.         httpPost.addHeader("Content-Type", "application/x-www-form-urlencoded");
  92.         // 封装post请求参数
  93.         if (null != paramMap && paramMap.size() > 0) {
  94.             List<NameValuePair> nvps = new ArrayList<NameValuePair>();
  95.             // 通过map集成entrySet方法获取entity
  96.             Set<Entry<String, Object>> entrySet = paramMap.entrySet();
  97.             // 循环遍历，获取迭代器
  98.             Iterator<Entry<String, Object>> iterator = entrySet.iterator();
  99.             while (iterator.hasNext()) {
  100.                 Entry<String, Object> mapEntry = iterator.next();
  101.                 nvps.add(new BasicNameValuePair(mapEntry.getKey(), mapEntry.getValue().toString()));
  102.             }
  103.  
  104.             // 为httpPost设置封装好的请求参数
  105.             try {
  106.                 httpPost.setEntity(new UrlEncodedFormEntity(nvps, "UTF-8"));
  107.             } catch (UnsupportedEncodingException e) {
  108.                 e.printStackTrace();
  109.             }
  110.         }
  111.         try {
  112.             // httpClient对象执行post请求,并返回响应参数对象
  113.             httpResponse = httpClient.execute(httpPost);
  114.             // 从响应对象中获取响应内容
  115.             HttpEntity entity = httpResponse.getEntity();
  116.             result = EntityUtils.toString(entity);
  117.         } catch (ClientProtocolException e) {
  118.             e.printStackTrace();
  119.         } catch (IOException e) {
  120.             e.printStackTrace();
  121.         } finally {
  122.             // 关闭资源
  123.             if (null != httpResponse) {
  124.                 try {
  125.                     httpResponse.close();
  126.                 } catch (IOException e) {
  127.                     e.printStackTrace();
  128.                 }
  129.             }
  130.             if (null != httpClient) {
  131.                 try {
  132.                     httpClient.close();
  133.                 } catch (IOException e) {
  134.                     e.printStackTrace();
  135.                 }
  136.             }
  137.         }
  138.         return result;
  139.     }
  140. }

 

有时候我们在使用post请求时，可能传入的参数是json或者其他格式，此时我们则需要更改请求头及参数的设置信息，以httpClient4.5为例，更改下面两列配置：httpPost.setEntity(new StringEntity("你的json串"));      httpPost.addHeader("Content-Type", "application/json")。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/302831
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号