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

JAVA发送GET和POST请求_java get post

作者：我家自动化 | 2024-04-26 10:34:06

赞

踩

java get post

一、介绍
使用Java实现GET和POST请求的方法常用的有两种：HTTPClient和HttpURLConnection。前者是第三方开源框架实现，对HTTP请求的封装很好，使用HTTPClient基本可以满足工作需要，其中HTTPClient3.1是org.apache.commons.httpclient下操作远程url的工具包，HTTPClient4.5.5是org.apache.http.client下操作远程url的工具包。而HttpURLConnection是java的标准请求方式。

二、实现

1.HttpURLConnection原生实现方式：

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

2.java原生HttpClient3.1

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

3.java原生httpClient4.5

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

传入的参数是json或者其他格式需要更改请求头及参数的设置信息，

httpPost.setEntity(new StringEntity("你的json串"));

httpPost.addHeader("Content-Type", "application/json")。

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

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

  

闽ICP备14008679号