httpclient4 实现http协议post、get类型接口调用

最新推荐文章于 2024-05-07 11:32:46 发布
最新推荐文章于 2024-05-07 11:32:46 发布
阅读量453 收藏
点赞数
文章标签： java HttpClient4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuyichao/article/details/88327326
版权

代码如下，不支持https
以下代码不支持https

import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.ParseException;
import org.apache.http.StatusLine;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;
import org.json.JSONObject;
import org.json.JSONTokener;

public class HttpRequest
{
  private static Logger log = Logger.getLogger(HttpRequest.class);
  
  public JSONObject dopost(String url, JSONObject jsonobject)
  {
    HttpClient httpclient = new DefaultHttpClient();
    HttpPost httpost = new HttpPost(url);
    JSONObject response = null;
    try
    {
      StringEntity sEntity = new StringEntity(jsonobject.toString());
      sEntity.setContentEncoding("UTF-8");
      sEntity.setContentType("application/json");
      httpost.setEntity(sEntity);
      HttpResponse httpResponse = httpclient.execute(httpost);
      if (httpResponse.getStatusLine().getStatusCode() == 200)
      {
        response = new JSONObject(new JSONTokener(new InputStreamReader(httpResponse.getEntity().getContent())));
        log.info(response);
      }
      else
      {
        log.info(Integer.valueOf(httpResponse.getStatusLine().getStatusCode()));
      }
    }
    catch (Exception e)
    {
      throw new RuntimeException(e);
    }
    return response;
  }
  
  public JSONObject dopost(String url, JSONObject jsonobject, Map<String, Object> params)
  {
    HttpClient httpclient = new DefaultHttpClient();
    HttpPost httpost = null;
    JSONObject response = null;
    Iterator<Map.Entry<String, Object>> it = params.entrySet().iterator();
    try
    {
      if (params.size() == 0) {
        return response;
      }
      if (params.size() == 1)
      {
        Map.Entry<String, Object> entry = (Map.Entry)it.next();
        url = url + "?" + (String)entry.getKey() + "=" + entry.getValue().toString();
        httpost = new HttpPost(url);
      }
      else
      {
        url = url + "?";
        while (it.hasNext())
        {
          Map.Entry<String, Object> entry = (Map.Entry)it.next();
          url = url + (String)entry.getKey() + "=" + entry.getValue().toString() + "&";
        }
        url = url.substring(0, new StringBuffer(url).length() - 1);
        httpost = new HttpPost(url);
      }
    }
    catch (ParseException e)
    {
      e.printStackTrace();
    }
    try
    {
      StringEntity sEntity = new StringEntity(jsonobject.toString());
      sEntity.setContentEncoding("UTF-8");
      sEntity.setContentType("application/json");
      httpost.setEntity(sEntity);
      HttpResponse httpResponse = httpclient.execute(httpost);
      if (httpResponse.getStatusLine().getStatusCode() == 200)
      {
        response = new JSONObject(new JSONTokener(new InputStreamReader(httpResponse.getEntity().getContent())));
        log.info(response);
      }
      else
      {
        log.info(Integer.valueOf(httpResponse.getStatusLine().getStatusCode()));
      }
    }
    catch (Exception e)
    {
      throw new RuntimeException(e);
    }
    return response;
  }
  
  public JSONObject dopost(String url, Map<String, Object> params)
  {
    HttpClient httpclient = new DefaultHttpClient();
    HttpPost httpost = null;
    JSONObject response = null;
    Iterator<Map.Entry<String, Object>> it = params.entrySet().iterator();
    try
    {
      if (params.size() == 0) {
        return response;
      }
      if (params.size() == 1)
      {
        Map.Entry<String, Object> entry = (Map.Entry)it.next();
        url = url + "?" + (String)entry.getKey() + "=" + entry.getValue().toString();
        httpost = new HttpPost(url);
      }
      else
      {
        url = url + "?";
        while (it.hasNext())
        {
          Map.Entry<String, Object> entry = (Map.Entry)it.next();
          url = url + (String)entry.getKey() + "=" + entry.getValue().toString() + "&";
        }
        url = url.substring(0, new StringBuffer(url).length() - 1);
        httpost = new HttpPost(url);
      }
    }
    catch (ParseException e)
    {
      e.printStackTrace();
    }
    try
    {
      StringEntity sEntity = new StringEntity("");
      sEntity.setContentEncoding("UTF-8");
      sEntity.setContentType("application/json");
      httpost.setEntity(sEntity);
      HttpResponse httpResponse = httpclient.execute(httpost);
      if (httpResponse.getStatusLine().getStatusCode() == 200)
      {
        response = new JSONObject(new JSONTokener(new InputStreamReader(httpResponse.getEntity().getContent())));
        log.info(response);
      }
      else
      {
        log.info(Integer.valueOf(httpResponse.getStatusLine().getStatusCode()));
      }
    }
    catch (Exception e)
    {
      throw new RuntimeException(e);
    }
    return response;
  }
  
  public String doget(String url, Map<String, Object> params)
  {
    CloseableHttpClient httpClient = HttpClients.createDefault();
    Iterator<Map.Entry<String, Object>> it = params.entrySet().iterator();
    HttpResponse response = null;
    HttpGet httpGet = null;
    String json = null;
    try
    {
      if (params.size() == 0)
      {
        httpGet = new HttpGet(url);
      }
      else if (params.size() == 1)
      {
        Map.Entry<String, Object> entry = (Entry<String, Object>)it.next();
        url = url + "?" + (String)entry.getKey() + "=" + entry.getValue().toString();
        httpGet = new HttpGet(url);
      }
      else
      {
        url = url + "?";
        while (it.hasNext())
        {
          Map.Entry<String, Object> entry = (Entry<String, Object>)it.next();
          url = url + (String)entry.getKey() + "=" + entry.getValue().toString() + "&";
        }
        url = url.substring(0, new StringBuffer(url).length() - 1);
        httpGet = new HttpGet(url);
      }
      log.info(httpGet.getURI());
      response = httpClient.execute(httpGet);
      HttpEntity entity = response.getEntity();
      if (entity != null)
      {
    	  json=EntityUtils.toString(response.getEntity(), "utf-8");
      }
    }
    catch (ParseException e)
    {
    	log.debug(e.getMessage());
      e.printStackTrace();
    }
    catch (IOException e)
    {
    	log.debug(e.getMessage());
      e.printStackTrace();
    }
    return json;
  }
  
  public String doget(String url, Map<String, Object> params,Map<String, String> headers)
  {
    CloseableHttpClient httpClient = HttpClients.createDefault();
    Iterator<Map.Entry<String, Object>> it = params.entrySet().iterator();
    HttpResponse response = null;
    HttpGet httpGet = null;
    String json = null;
    try
    {
      if (params.size() == 0)
      {
        httpGet = new HttpGet(url);
      }
      else if (params.size() == 1)
      {
        Map.Entry<String, Object> entry = (Entry<String, Object>)it.next();
        url = url + "?" + (String)entry.getKey() + "=" + entry.getValue().toString();
        httpGet = new HttpGet(url);
      }
      else
      {
        url = url + "?";
        while (it.hasNext())
        {
          Map.Entry<String, Object> entry = (Entry<String, Object>)it.next();
          url = url + (String)entry.getKey() + "=" + entry.getValue().toString() + "&";
        }
        url = url.substring(0, new StringBuffer(url).length() - 1);
        httpGet = new HttpGet(url);
      }
      log.info("URL="+httpGet.getURI());
      for(Map.Entry<String, String> e : headers.entrySet()){
      	httpGet.addHeader(e.getKey(),e.getValue());
      }
      response = httpClient.execute(httpGet);
      HttpEntity entity = response.getEntity();
      if (entity != null)
      {
    	  json=EntityUtils.toString(response.getEntity(), "utf-8");
      }
    }
    catch (ParseException e)
    {
    	//log.debug(e.getMessage());
      e.printStackTrace();
    }
    catch (IOException e)
    {
    	//log.debug(e.getMessage());
      e.printStackTrace();
    }
    return json;
  }
  
  public StatusLine getStatus(String flag,String url, Map<String, Object> params,Map<String, String> headers){
    CloseableHttpClient httpClient = HttpClients.createDefault();
    Iterator<Map.Entry<String, Object>> it = params.entrySet().iterator();
    HttpResponse response = null;
    HttpGet httpGet = null;
    HttpPost httpPost=null;
    String json = null;
    StatusLine sl=null;
    if(flag.equals("GET")){
    try
    {
      if (params.size() == 0)
      {
        httpGet = new HttpGet(url);
      }
      else if (params.size() == 1)
      {
        Map.Entry<String, Object> entry = (Entry<String, Object>)it.next();
        url = url + "?" + (String)entry.getKey() + "=" + entry.getValue().toString();
        httpGet = new HttpGet(url);
      }
      else
      {
        url = url + "?";
        while (it.hasNext())
        {
          Map.Entry<String, Object> entry = (Entry<String, Object>)it.next();
          url = url + (String)entry.getKey() + "=" + entry.getValue().toString() + "&";
        }
        url = url.substring(0, new StringBuffer(url).length() - 1);
        httpGet = new HttpGet(url);
      }
      log.info("URL="+httpGet.getURI());
      for(Map.Entry<String, String> e : headers.entrySet()){
      	httpGet.addHeader(e.getKey(),e.getValue());
      }
      response = httpClient.execute(httpGet);
      sl=response.getStatusLine();
    }catch (Exception e){
    	e.printStackTrace();
    }
    }
    else if(flag.equals("POST")){
    	
    }
    return sl;
  }
  public static void main(String[] args) {}
}

以下代码支持https协议
package UDS.UdsTest.comme;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;

public class HttpUtils {

/**
 * get
 * 
 * @param host
 * @param path
 * @param method
 * @param headers
 * @param querys
 * @return
 * @throws Exception
 */
public static HttpResponse doGet(String host, String path,Map<String, String> headers,Map<String, String> querys){    	
	HttpClient httpClient = wrapClient(host);
	HttpGet request=null;
	HttpResponse response=null;
	try {
		request = new HttpGet(buildUrl(host, path, querys));
		response=httpClient.execute(request);
	} catch (Exception e1) {
		e1.printStackTrace();
	}
    for (Map.Entry<String, String> e : headers.entrySet()) {
    	request.addHeader(e.getKey(), e.getValue());
    }
    
    return response;
}

/**
 * post form
 * 
 * @param host
 * @param path
 * @param method
 * @param headers
 * @param querys
 * @param bodys
 * @return
 * @throws Exception
 */
public static HttpResponse doPost(String host, String path, String method, 
		Map<String, String> headers, 
		Map<String, String> querys, 
		Map<String, String> bodys)
        throws Exception {    	
	HttpClient httpClient = wrapClient(host);

	HttpPost request = new HttpPost(buildUrl(host, path, querys));
    for (Map.Entry<String, String> e : headers.entrySet()) {
    	request.addHeader(e.getKey(), e.getValue());
    }

    if (bodys != null) {
        List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();

        for (String key : bodys.keySet()) {
            nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
        }
        UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
        formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
        request.setEntity(formEntity);
    }

    return httpClient.execute(request);
}	

/**
 * Post String
 * 
 * @param host
 * @param path
 * @param method
 * @param headers
 * @param querys
 * @param body
 * @return
 * @throws Exception
 */
public static HttpResponse doPost(String host, String path, String method, 
		Map<String, String> headers, 
		Map<String, String> querys, 
		String body)
        throws Exception {    	
	HttpClient httpClient = wrapClient(host);

	HttpPost request = new HttpPost(buildUrl(host, path, querys));
    for (Map.Entry<String, String> e : headers.entrySet()) {
    	request.addHeader(e.getKey(), e.getValue());
    }

    if (StringUtils.isNotBlank(body)) {
    	request.setEntity(new StringEntity(body, "utf-8"));
    }

    return httpClient.execute(request);
}

/**
 * Post stream
 * 
 * @param host
 * @param path
 * @param method
 * @param headers
 * @param querys
 * @param body
 * @return
 * @throws Exception
 */
public static HttpResponse doPost(String host, String path, String method, 
		Map<String, String> headers, 
		Map<String, String> querys, 
		byte[] body)
        throws Exception {    	
	HttpClient httpClient = wrapClient(host);

	HttpPost request = new HttpPost(buildUrl(host, path, querys));
    for (Map.Entry<String, String> e : headers.entrySet()) {
    	request.addHeader(e.getKey(), e.getValue());
    }

    if (body != null) {
    	request.setEntity(new ByteArrayEntity(body));
    }

    return httpClient.execute(request);
}

/**
 * Put String
 * @param host
 * @param path
 * @param method
 * @param headers
 * @param querys
 * @param body
 * @return
 * @throws Exception
 */
public static HttpResponse doPut(String host, String path, String method, 
		Map<String, String> headers, 
		Map<String, String> querys, 
		String body)
        throws Exception {    	
	HttpClient httpClient = wrapClient(host);

	HttpPut request = new HttpPut(buildUrl(host, path, querys));
    for (Map.Entry<String, String> e : headers.entrySet()) {
    	request.addHeader(e.getKey(), e.getValue());
    }

    if (StringUtils.isNotBlank(body)) {
    	request.setEntity(new StringEntity(body, "utf-8"));
    }

    return httpClient.execute(request);
}

/**
 * Put stream
 * @param host
 * @param path
 * @param method
 * @param headers
 * @param querys
 * @param body
 * @return
 * @throws Exception
 */
public static HttpResponse doPut(String host, String path, String method, 
		Map<String, String> headers, 
		Map<String, String> querys, 
		byte[] body)
        throws Exception {    	
	HttpClient httpClient = wrapClient(host);

	HttpPut request = new HttpPut(buildUrl(host, path, querys));
    for (Map.Entry<String, String> e : headers.entrySet()) {
    	request.addHeader(e.getKey(), e.getValue());
    }

    if (body != null) {
    	request.setEntity(new ByteArrayEntity(body));
    }

    return httpClient.execute(request);
}

/**
 * Delete
 *  
 * @param host
 * @param path
 * @param method
 * @param headers
 * @param querys
 * @return
 * @throws Exception
 */
public static HttpResponse doDelete(String host, String path, String method, 
		Map<String, String> headers, 
		Map<String, String> querys)
        throws Exception {    	
	HttpClient httpClient = wrapClient(host);

	HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
    for (Map.Entry<String, String> e : headers.entrySet()) {
    	request.addHeader(e.getKey(), e.getValue());
    }
    
    return httpClient.execute(request);
}

private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
	StringBuilder sbUrl = new StringBuilder();
	sbUrl.append(host);
	if (!StringUtils.isBlank(path)) {
		sbUrl.append(path);
    }
	if (null != querys) {
		StringBuilder sbQuery = new StringBuilder();
    	for (Map.Entry<String, String> query : querys.entrySet()) {
    		if (0 < sbQuery.length()) {
    			sbQuery.append("&");
    		}
    		if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
    			sbQuery.append(query.getValue());
            }
    		if (!StringUtils.isBlank(query.getKey())) {
    			sbQuery.append(query.getKey());
    			if (!StringUtils.isBlank(query.getValue())) {
    				sbQuery.append("=");
    				sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
    			}        			
            }
    	}
    	if (0 < sbQuery.length()) {
    		sbUrl.append("?").append(sbQuery);
    	}
    }
	
	return sbUrl.toString();
}

private static HttpClient wrapClient(String host) {
	HttpClient httpClient = new DefaultHttpClient();
	if (host.startsWith("https://")) {
		sslClient(httpClient);
	}		
	return httpClient;
}

private static void sslClient(HttpClient httpClient) {
    try {
        SSLContext ctx = SSLContext.getInstance("TLS");
        X509TrustManager tm = new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
            public void checkClientTrusted(X509Certificate[] xcs, String str) {
            	
            }
            public void checkServerTrusted(X509Certificate[] xcs, String str) {
            	
            }
        };
        ctx.init(null, new TrustManager[] { tm }, null);
        SSLSocketFactory ssf = new SSLSocketFactory(ctx);
        ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
        ClientConnectionManager ccm = httpClient.getConnectionManager();
        SchemeRegistry registry = ccm.getSchemeRegistry();
        registry.register(new Scheme("https", 443, ssf));
    } catch (KeyManagementException ex) {
        throw new RuntimeException(ex);
    } catch (NoSuchAlgorithmException ex) {
    	throw new RuntimeException(ex);
    }
}

}

哈希哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
JavaHTTP请求工具类HTTPUtils
weixin_42077074的博客
03-17 3340
其中涉及 HTTP 请求相关的各种操作，关于这些方法详细的介绍可以查看这些博客。博客文章《Java发起HTTP请求并解析JSON返回数据》博客文章《JavaJSON处理工具类JSONUtils》博客文章《Java发起同异步HTTP请求和处理数据》HTTP 请求工具类。HTTP 请求工具类。
HttpUtils
weixin_41619409的博客
04-16 361
转载自 原文链接 link. 居中的图片: import com.alibaba.fastjson.JSONObject; import com.google.gson.JsonObject; import lombok.extern.slf4j.Slf4j; import org.apache.commons.io.IOUtils; import org.apache.http.HttpEnt...
使用http请求来调用webService接口
最新发布
qq_57418843的博客
05-07 1522
使用http来调用webservice接口，soap1.1版本，soap1.2版本,以及跳过ssl证书？应有尽有快来瞧一瞧看一看
HttpUtils——助力高效网络通信
weixin_45817985的博客
12-19 237
HttpUtils——助力高效网络通信
HttpUtil万能工具类，直接搬用
qq_44982110的博客
03-03 7853
请求方式POST/GET。请求头有可能是加密后的密文。往往校验这种接口，需要有apiKey，secretKey。这里分享一下我对接遇到的奇奇怪怪的请求。接下来就需要用Java代码模拟用postman发送请求。情况4：最为复杂的，发送方式POST。请求头+表单形式发送请求体+文件。4.拿到申请的资料之后，先在postman跑一下，拿到token令牌。情况2：发送方式POST，请求体JSON。情况1：请求方式POST，请求体JSON。情况3：发送方式POST。情况2：GET请求方式，参数+请求头。
HttpUtils实用工具类,兼容http和https两种请求类型
summer的博客
01-03 1908
HttpUtils实用工具类,兼容http和https两种请求类型，首选需要引入maven包 <dependency> <groupId>org.jsoup</groupId> <artifactId>jsoup</artifactId> <version>1.11.3</version> </de...
JAVA利用HttpClient进行HTTPS接口调用的方法
08-29
"JAVA利用HttpClient进行HTTPS接口调用的方法" 知识点1：HttpClient的基本概念 HttpClient是一个开放源代码的Java库，用于提供高效、灵活和可扩展的HTTP客户端解决方案。HttpClient支持HTTP/1.1和HTTP/2.0协议，...
HttpClient实现调用外部项目接口工具类的示例
08-29
HttpClient实现调用外部项目接口工具类的示例 HttpClient是Apache Jakarta Commons子项目中的一种开源的Http客户端实现，它提供了一个实现了Http/1.1和Http/2.0协议的客户端工具库，用于发送Http请求和接收Http...
C++ 实现 HTTP HTTPS POST GET(包含curl版本和winhttp两种实现)
04-25
玩过抓包，网络协议分析的朋友肯定都知道http https post get，web端和用户的交互主要是通过post get完成的。 我这里有两种实现： 1：libcurl实现的CHttpClient类，该类实现了Htpp和Https的get post方法。 2：...
HttpClientUtil工具类，调用第三方接口
10-25
该工具类是java 调用第三方接口时需要使用到的。HttpClientUtil 包含get和post方法。
使用HttpClient调用接口的实例讲解
08-29
HttpClient支持多种HTTP方法，包括GET、POST、PUT、DELETE等，同时也支持HTTPS协议。 二、使用HttpClient调用接口的步骤 使用HttpClient调用接口主要分为以下几个步骤： 1. 创建HttpClient实例 首先，我们需要...
HttpClient 4.5 封装的工具类 HttpUtil 可用于爬虫和模拟登陆
06-26
基于Apache HttpClient 4.5.2 封装的工具类 HttpUtil 可用于爬虫和模拟登陆。使用新的语法后比3.*版本的速度感觉有提升。使用后注意资源的释放 pom 部分，应该不全，需要用的根据代码的import去找maven资源即可。 org.apache.httpcomponents httpclient 4.5.2 org.apache.httpcomponents httpmime 4.5.1
HttpUtil工具类
12-05
HttpClient远程调用工具类 get 和post 调用用访问别的系统接口 用http方式请求，包括调用时用的工具类
import org.apache.http.util.EncodingUtils找不到
chenhuakang的博客
08-09 8955
安卓6.0找不到EncodingUtils import org.apache.http.util.EncodingUtils问题 错误提示:出现的问题是： Cant resolve symbol ‘EncodingUtils’ 提示是：错误：程序包org.apache.http.util不存在 错误：找不到符号 符号：变量 EncodingUtils  注：某些输入文件使用或
基于ApacheHttpclient封装的请求工具类（记笔记）
qq_17805707的博客
08-01 535
其实最开始我是想基于hutool封装的，但是表单上传的那个方法试了，文件传不上去，没找到问题，就放弃了。
http工具类
WUZHICAICHAN的博客
03-17 949
http工具类
Java通过HttpClient4实现Https Get/Post请求
Alderaan的博客
03-04 1083
Java通过HttpClient4实现Https Get/Post请求
HttpClient使用详解与实战一：普通的GET和POST请求
weixin_30673611的博客
05-08 622
简介 HttpClient是Apache Jakarta Common下的子项目，用来提供高效的、最新的、功能丰富的支持HTTP协议的客户端编程工具包，并且它支持HTTP协议最新的版本和建议。 HttpClient最新版本是HttpClient 4.5.3 (GA)。 官方下载：http://hc.apache.org/downloads.cgi 主要特性 基于标准、纯净的Jav...
MyHttpUtils 工具类（Apache HTTP工具类封装）
鱼皮小刘博客
06-20 288
Apache HTTP工具类封装
springboot通过http协议调用get接口和post接口
06-07
在Spring Boot中，可以使用Java原生的HttpURLConnection或者第三方库如Apache HttpClient、OkHttp等来进行HTTP调用。下面分别介绍如何通过GET方法和POST方法调用RESTful API。 GET方法调用： ```java public ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哈希哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值