HttpClient发起http请求

最新推荐文章于 2023-06-20 12:01:52 发布
最新推荐文章于 2023-06-20 12:01:52 发布
阅读量415 收藏
点赞数
分类专栏： 网络请求 文章标签： http java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45617480/article/details/108394270
版权
  • Java发http请求
    收到添加依赖
<dependency>
	<groupId>org.apache.httpcomponents</groupId>
	<artifactId>httpclient</artifactId>
</dependency>

HttpGet请求测试代码

public class HttpGetTest{
    public static void main(String[] args) throws IOException {
        //实例化HttpClient实例
        CloseableHttpClient client = HttpClients.createDefault();
        //请求url
        String url = "https://www.baidu.com";
        HttpGet httpGet = new HttpGet(url);
        //添加请求头
        httpGet.addHeader("Content-Type", "application/json");
        httpGet.addHeader("Accept", "application/json");

        //发起请求
        CloseableHttpResponse response = client.execute(httpGet);
        //获得请求状态码
        int statusCode = response.getStatusLine().getStatusCode();
        if (statusCode == 200) {
            //获得请求实体
            HttpEntity entity = response.getEntity();
            String result = EntityUtils.toString(entity, "utf-8");
            System.out.println(result);
            //获得所有请求头
            Header[] allHeaders = response.getAllHeaders();
            for (Header header : allHeaders) {
                //请求头名称
                String name = header.getName();
                //请求头值
                String value = header.getValue();
                System.out.println(name + ":" + value);
            }
        }
    }
}

HttpPost请求

package fmx.test.httptest;

import net.sf.json.JSONObject;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
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.HttpClients;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;

/**
 * @author fmx
 * @version 1.0
 * @date 2020/9/3 22:40
 */
public class HttpPostTest {
    public static void main(String[] args) throws IOException {
        //实例化HttpClient实例
        CloseableHttpClient client = HttpClients.createDefault();
        //请求url
        String url = "https://www.baidu.com";
        HttpPost httpPost = new HttpPost(url);
        //添加请求头
        httpPost.addHeader("Content-Type", "application/json");
        httpPost.addHeader("Accept", "application/json");
        //请求数据
        Map<String, Object> map = new HashMap<>();
        JSONObject x = JSONObject.fromObject(map);
        String body = x.toString();
        StringEntity strEntity = new StringEntity(body, Charset.forName("UTF-8"));
        strEntity.setContentType("application/json");
        httpPost.setEntity(strEntity);
        //设置超时时间按
        RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(80000).setConnectTimeout(80000).build();
        httpPost.setConfig(requestConfig);
        //发起请求
        CloseableHttpResponse response = client.execute(httpPost);
        //获得请求状态码
        int statusCode = response.getStatusLine().getStatusCode();
        if (statusCode == 200) {
            //获得请求实体
            HttpEntity entity = response.getEntity();
            String result = EntityUtils.toString(entity, "utf-8");
            System.out.println(result);
            //获得所有请求头
            Header[] allHeaders = response.getAllHeaders();
            for (Header header : allHeaders) {
                //请求头名称
                String name = header.getName();
                //请求头值
                String value = header.getValue();
                System.out.println(name + ":" + value);
            }
        }
    }
}
  • 接收请求（以微信支付回调为例）
@PostMapping("/payNotify")
    public JSONObject wxNotify(HttpServletRequest request, HttpServletResponse response, @RequestHeader HttpHeaders headers) {

        //返回通知的应答报文，code(32)：SUCCESS为清算机构接收成功；message(64)：错误原因
        JSONObject responseJson = new JSONObject();
        responseJson.put("code", "FAIL");
        //支付通知http应答码为200或204才会当作正常接收，当回调处理异常时，应答的HTTP状态码应为500，或者4xx。
        response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        if (!headers.containsKey("Wechatpay-Serial") || !headers.containsKey("Wechatpay-Timestamp")
                || !headers.containsKey("Wechatpay-Nonce") || !headers.containsKey("Wechatpay-Signature")) {
            log.info("请求头丢失");
            responseJson.put("message", "回调请求header缺失");
            return responseJson;
        }
        String wechatpaySerial = headers.getFirst("Wechatpay-Serial");//平台证书序列号
        String wechatpayTimestamp = headers.getFirst("Wechatpay-Timestamp");//应答时间戳
        String wechatpayNonce = headers.getFirst("Wechatpay-Nonce");//应答随机串
        String wechatpaySignature = headers.getFirst("Wechatpay-Signature"); //应答签名
        if (!MyWxPayConfig.WECHAT_CERTIFICATR_SERIAL_NO.equals(wechatpaySerial)) {
            responseJson.put("message", "回调请求证书序列化不一致");
            return responseJson;
        }
        log.info("WechatpaySignature{}", wechatpaySerial);
        log.info("WechatpayTimestamp{}", wechatpayTimestamp);
        log.info("WechatpayNonce{}", wechatpayNonce);
        log.info("WechatpaySignature{}", wechatpaySignature);


        try {
            //获取微信POST过来反馈信息
            Map<String, String> params = new HashMap<String, String>();
            // post请求的密文数据
            ServletInputStream in = request.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(in));
            String sReqData = "";
            String itemStr = "";//作为输出字符串的临时串，用于判断是否读取完毕
            while (null != (itemStr = reader.readLine())) {
                sReqData += itemStr;
            }
            log.info("resultData{}", sReqData);
            //验签
            byte[] signature = null;
            try {
                signature = Base64.getDecoder().decode(wechatpaySignature);
            } catch (Exception e) {
                e.printStackTrace();
                log.info("响应签名Base64解码失败");
                responseJson.put("message", "响应签名Base64解码失败");
                return responseJson;
            }
            boolean verify = WxPayUtils.verify(wechatpayTimestamp, wechatpayNonce, sReqData, signature);
            if (!verify) {
                log.info("回调信息签名验证失败");
                responseJson.put("message", "回调信息签名验证失败");
                return responseJson;
            }

            JSONObject jsonObject = JSONObject.fromObject(sReqData);
            Map<String, Object> m = (Map) jsonObject;
            if (m.get("event_type") == null || !m.get("event_type").equals("TRANSACTION.SUCCESS")) {
                //补充处理部分
                response.setStatus(HttpServletResponse.SC_OK);
                responseJson.put("code", "SUCCESS");
                responseJson.put("message", "微信支付失败，商户处理成功");
            }

            String resource = m.get("resource").toString();
            JSONObject resourcejso = JSONObject.fromObject(resource);
            Map<Object, Object> mm = (Map) resourcejso;
            String nonce = mm.get("nonce").toString();
            String ciphertext = mm.get("ciphertext").toString();
            String assc = mm.get("associated_data").toString();

            String APIv3Key = MyWxPayConfig.API_V3_KEY;
            //解密回调信息
            byte[] key = APIv3Key.getBytes("UTF-8");
            WxAPIV3AesUtil aesUtil = new WxAPIV3AesUtil(key);
            String decryptToString = aesUtil.decryptToString(assc.getBytes("UTF-8"), nonce.getBytes("UTF-8"), ciphertext);
            JSONObject decryption = JSONObject.fromObject(decryptToString);
            Map<String, Object> decryptionMap = (Map) decryption;
            System.out.println(decryptionMap);

            if (decryptionMap.get("transaction_id") == null) {
                log.info("未接受到微信订单号");
                responseJson.put("message", "微信支付成功，未接受到微信订单号");
                return responseJson;
            }
            if (decryptionMap.get("out_trade_no") == null) {
                log.info("未接收到商家订单号");
                responseJson.put("message", "微信支付成功，未接收到商家订单号");
                return responseJson;
            }

            String outTradeNo = decryptionMap.get("out_trade_no").toString();
            List<Integer> status = partyPaymentRecordService.getPaymentStatusByoutTradeNo(outTradeNo);
            boolean flag = false;
            if (status != null) {
                for (Integer sta : status) {
                    if (sta != null && sta != 0) {
                        flag = true;
                        break;
                    }
                }
            }
            if (flag) {
                response.setStatus(HttpServletResponse.SC_OK);
                responseJson.put("code", "SUCCESS");
                responseJson.put("message", "微信支付成功");
                return responseJson;
            }
//            statusCode
            decryptionMap.put("statusCode", "200");
            partyPaymentRecordService.trackOrder(decryptionMap, null);

            System.out.println(decryptToString);

        } catch (Exception e) {
            e.printStackTrace();
        }
        log.info("微信支付成功");
        response.setStatus(HttpServletResponse.SC_OK);
        responseJson.put("code", "SUCCESS");
        responseJson.put("message", "微信支付成功");
        return responseJson;
    }
}
  • 若在开发环境中，则需交给spring管理
import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@PropertySource(value = "classpath:/properties/httpClient.properties")
public class HttpClientConfig {
    @Value("${http.maxTotal}")
    private Integer maxTotal;                        //最大连接数

    @Value("${http.defaultMaxPerRoute}")
    private Integer defaultMaxPerRoute;                //最大并发链接数

    @Value("${http.connectTimeout}")
    private Integer connectTimeout;                    //创建链接的最大时间

    @Value("${http.connectionRequestTimeout}")
    private Integer connectionRequestTimeout;        //链接获取超时时间

    @Value("${http.socketTimeout}")
    private Integer socketTimeout;                    //数据传输最长时间

    @Value("${http.staleConnectionCheckEnabled}")
    private boolean staleConnectionCheckEnabled;    //提交时检查链接是否可用

    //定义httpClient链接池
    @Bean(name = "httpClientConnectionManager")
    public PoolingHttpClientConnectionManager getPoolingHttpClientConnectionManager() {
        PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager();
        manager.setMaxTotal(maxTotal);  //设定最大链接数
        manager.setDefaultMaxPerRoute(defaultMaxPerRoute);  //设定并发链接数
        return manager;
    }

    //定义HttpClient

    /**
     * 实例化连接池，设置连接池管理器。
     * 这里需要以参数形式注入上面实例化的连接池管理器
     *
     * @Qualifier 指定bean标签进行注入
     */
    @Bean(name = "httpClientBuilder")
    public HttpClientBuilder getHttpClientBuilder(@Qualifier("httpClientConnectionManager") PoolingHttpClientConnectionManager httpClientConnectionManager) {

        //HttpClientBuilder中的构造方法被protected修饰，所以这里不能直接使用new来实例化一个HttpClientBuilder,可以使用HttpClientBuilder提供的静态方法create()来获取HttpClientBuilder对象
        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
        httpClientBuilder.setConnectionManager(httpClientConnectionManager);
        return httpClientBuilder;
    }

    /**
     * 注入连接池，用于获取httpClient
     *
     * @param httpClientBuilder
     * @return
     */
    @Bean
    public CloseableHttpClient getCloseableHttpClient(@Qualifier("httpClientBuilder") HttpClientBuilder httpClientBuilder) {

        return httpClientBuilder.build();
    }

    /**
     * Builder是RequestConfig的一个内部类
     * 通过RequestConfig的custom方法来获取到一个Builder对象
     * 设置builder的连接信息
     *
     * @return
     */
    @Bean(name = "builder")
    public RequestConfig.Builder getBuilder() {
        RequestConfig.Builder builder = RequestConfig.custom();
        return builder.setConnectTimeout(connectTimeout)
                .setConnectionRequestTimeout(connectionRequestTimeout)
                .setSocketTimeout(socketTimeout)
                .setStaleConnectionCheckEnabled(staleConnectionCheckEnabled);
    }

    /**
     * 使用builder构建一个RequestConfig对象
     *
     * @param builder
     * @return
     */
    @Bean
    public RequestConfig getRequestConfig(@Qualifier("builder") RequestConfig.Builder builder) {
        return builder.build();
    }
}


import javax.annotation.PreDestroy;

import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.pool.PoolStats;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component    //交给spring容器管理
public class HttpClientClose extends Thread {
    @Autowired
    private PoolingHttpClientConnectionManager manage;
    private volatile boolean shutdown;    //开关 volatitle表示多线程可变数据,一个线程修改,其他线程立即修改

    public HttpClientClose() {
        ///System.out.println("执行构造方法,实例化对象");
        //线程开启启动
        this.start();
    }


    @Override
    public void run() {
        try {
            //如果服务没有关闭,执行线程
            while (!shutdown) {
                synchronized (this) {
                    wait(5000);            //等待5秒
                    //System.out.println("线程开始执行,关闭超时链接");
                    //关闭超时的链接
                    PoolStats stats = manage.getTotalStats();
                    int av = stats.getAvailable();    //获取可用的线程数量
                    int pend = stats.getPending();    //获取阻塞的线程数量
                    int lea = stats.getLeased();    //获取当前正在使用的链接数量
                    int max = stats.getMax();
                    //System.out.println("max/"+max+":	av/"+av+":  pend/"+pend+":   lea/"+lea);
                    manage.closeExpiredConnections();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }

        super.run();
    }

    //关闭清理无效连接的线程
    @PreDestroy    //容器关闭时执行该方法.
    public void shutdown() {
        shutdown = true;
        synchronized (this) {
            //System.out.println("关闭全部链接!!");
            notifyAll(); //全部从等待中唤醒.执行关闭操作;
        }
    }
}

httpClient.properties

#最大连接数
http.maxTotal = 1000
#并发数
http.defaultMaxPerRoute = 20
#创建连接的最长时间
http.connectTimeout=5000
#从连接池中获取到连接的最长时间
http.connectionRequestTimeout=500
#数据传输的最长时间
http.socketTimeout=5000
#提交请求前测试连接是否可用
http.staleConnectionCheckEnabled=true
  • 调用API
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

@Service
public class HttpClientService {
	@Autowired
	private CloseableHttpClient httpClient;
	@Autowired
	private RequestConfig requestConfig;

	/**
	 * 	编辑工具API的目的简化代码，实现松耦合 
	 * 	作用：帮助用户发起http请求，获取正确的结果返回给用户 参数设计：
	 * 1.用户url地址
	 * 2.Map<参数名，参数值 > 3.字符集
	 * 
	 * get请求方式： 1.无参数时：http://www.baidu.com 
	 * 2.有参数时：http://www.baidu.com?key=--
	 * 
	 * @param url
	 * @param params
	 * @param charset
	 * @return
	 */

	// 实现httpClient GET提交
	public String doGet(String url, Map<String, String> params, String charset) {
		String result = null;
		// 1.判断字符集编码是否为空 如果为空则给定默认值utf-8
		if (StringUtils.isEmpty(charset)) {

			charset = "UTF-8";
		}
		// 2.判断用户是否需要传递参数
		if (params != null) {
			try {
				URIBuilder uriBuilder = new URIBuilder(url);
				for (Map.Entry<String, String> entry : params.entrySet()) {

					uriBuilder.addParameter(entry.getKey(), entry.getValue());
				}
				// url?id=1&name=tom
				url = uriBuilder.build().toString();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		// 3.定义参数提交对象
		HttpGet get = new HttpGet(url);

		// 4.为请求设定超时时间
		get.setConfig(requestConfig);

		// 5.通过httpClient发送请求
		try {
			CloseableHttpResponse response = httpClient.execute(get);
			if (response.getStatusLine().getStatusCode() == 200) {
				// 表示程序调用成功
				result = EntityUtils.toString(response.getEntity(), charset);
			} else {
				System.out.println("调用异常:状态信息:" + response.getStatusLine().getStatusCode());
				throw new RuntimeException();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}

		return result;
	}

	public String doGet(String url) {

		return doGet(url, null, null);
	}

	public String doGet(String url, Map<String, String> params) {

		return doGet(url, params, null);
	}

	public String doGet(String url, String charset) {

		return doGet(url, null, charset);
	}

	// 实现httpClient POST提交
	public String doPost(String url, Map<String, String> params, String charset) {
		String result = null;

		// 1.定义请求类型
		HttpPost post = new HttpPost(url);
		post.setConfig(requestConfig); // 定义超时时间

		// 2.判断字符集是否为null
		if (StringUtils.isEmpty(charset)) {

			charset = "UTF-8";
		}

		// 3.判断用户是否传递参数
		if (params != null) {
			// 3.2准备List集合信息
			List<NameValuePair> parameters = new ArrayList<>();

			// 3.3将数据封装到List集合中
			for (Map.Entry<String, String> entry : params.entrySet()) {

				parameters.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
			}

			// 3.1模拟表单提交
			try {
				UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(parameters, charset); // 采用u8编码

				// 3.4将实体对象封装到请求对象中
				post.setEntity(formEntity);
			} catch (UnsupportedEncodingException e) {

				e.printStackTrace();
			}
		}

		// 4.发送请求
		try {
			CloseableHttpResponse response = httpClient.execute(post);

			// 4.1判断返回值状态
			if (response.getStatusLine().getStatusCode() == 200) {

				// 4.2表示请求成功
				result = EntityUtils.toString(response.getEntity(), charset);
			} else {
				System.out.println("获取状态码信息:" + response.getStatusLine().getStatusCode());
				throw new RuntimeException();
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		return result;
	}

	public String doPost(String url) {

		return doPost(url, null, null);
	}

	public String doPost(String url, Map<String, String> params) {

		return doPost(url, params, null);
	}

	public String doPost(String url, String charset) {

		return doPost(url, null, charset);
	}
}
学习啷个办
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HttpClient发起HTTPs请求.rar
07-25
在Java编程环境中，HttpClient是一个非常常用的库，用于发送HTTP请求并接收响应。在这个"HttpClient发起HTTPs请求.rar"压缩包中，我们主要关注的是如何利用HttpClient处理HTTPS协议的GET和POST请求，以及如何处理...
如何在项目中使用HttpClient工具包发送http请求
weixin_44879791的博客
05-05 578
在讲解如何使用HttpClient工具包之前，先简单介绍一下：HttpClient 是Apache Jakarta Common 下的子项目，是一个支持http协议的客户端编程工具包，使用它可以高效便捷的快速访问不同的网址，发送http请求。在搭建spring项目时，难免会使用到其他第三方已经实现的API服务，比如搭建微信小程序可能会使用到的微信支付功能，地图的定位功能等。这是我们就需要向其他服务器发送HTTP请求来获取我们需要的数据信息。下面将详细讲述一下如何发送最简单的http请求。
使用HttpClient发送Http请求详细示例
swadian2008的博客
04-01 8058
HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。 HTTP和浏览器有点像，但却不是浏览器。很多人觉得既然HttpClient是一个HTTP客户端编程工具，很多人把他当做浏览器来理解，但是其实HttpClient不是浏览器，它是一个HTTP通信库，...
使用HttpClient进行HTTP请求的简易指南
BASK2312的博客
05-18 1358
引言： 在现代的网络应用程序中，进行HTTP请求是一项常见的任务。Apache HttpClient是一个功能强大且广泛使用的Java库，它提供了方便的方法来执行HTTP请求并处理响应。本文将介绍如何使用HttpClient库进行HTTP请求，包括GET请求、POST请求、添加参数和请求体、设置请求头等操作。HttpClient简介： HttpClient是一个开源的Java库，用于处理HTTP通信。它提供了各种类和方法，使得执行HTTP请求变得简单而直观。
Java 调用第三方接口方法
qq_41128049的博客
04-25 3万+
Java 调用第三方接口方法 一、 通过JDK网络类Java.net.HttpURLConnection 1.java.net包下的原生java api提供的http请求 使用步骤： 1、通过统一资源定位器（java.net.URL）获取连接器（java.net.URLConnection）。 2、设置请求的参数。 3、发送请求。 4、以输入流的形式获取返回内容。 5、关闭输入流。 2.HttpClientUtil工具类 /** * jdk 调用第三方接口 * @author hsq */ pub
CloseableHttpResponse
热门推荐
zl的博客
04-08 6万+
最近在使用Apache的httpclient的时候，maven引用了最新版本4.3,发现Idea提示DefaultHttpClient等常用的类已经不推荐使用了，之前在使用4.2.3版本的时候，还没有被deprecated。去看了下官方文档，确实不推荐使用了，点击此处详情。DefaultHttpClient —&gt; CloseableHttpClientHttpResponse —&gt; C...
利用HttpClient发送HTTP请求
06-14
利用HttpClient发送HTTP请求 利用HttpClient发送HTTP请求
使用HttpClient管理HTTP请求
04-26
Apache HttpClient是一个强大的Java库，允许开发者方便地执行HTTP请求并处理响应。这篇博客“使用HttpClient管理HTTP请求”深入探讨了如何有效地利用HttpClient进行网络通信。 HttpClient提供了丰富的功能，包括但...
HttpClient发送http请求需要的jar包
01-16
HttpClient是Apache基金会开发的一个Java库，用于执行HTTP请求。它为开发者提供了强大的功能，包括连接管理、重试策略、请求和响应处理等。在Java应用中，如果你需要发送HTTP请求，HttpClient是一个非常实用的选择。...
httpclient发送post请求
01-12
在Java编程中，`HttpClient` 是一个非常常用的库，用于执行HTTP请求，包括POST和GET等。本示例中，我们将深入探讨如何使用`HttpClient`发送POST请求。 首先，我们需要导入必要的库。Apache HttpClient库提供了`...
httpclient
programmer188的博客
08-11 819
1.HttpClient介绍 HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是 Apache Jakarta Common...
电脑多网卡模式下，使用特定网口发送HTTP请求的代码实现（HttpClient5.1）
CHQIUU的专栏
07-01 1万+
目录前言：解决方案：基于HttpClient5.1：总结： 前言： 前面我们讲了使用基于HttpClient和Socket两种方式处理多网卡模式下的绑定本地网卡发送请求的代码实现，现在讲一下重写HttpClient5实现本地网卡绑定实现方法。 解决方案： 基于HttpClient5.1： 关键代码，重写DefaultRoutePlanner.determineLocalAddress 方法，加入需绑定的本地IP。 代码如下： import lombok.SneakyThrows; import lombo
HttpClient发送请求
weixin_43573186的博客
11-14 3758
HttpClient发送请求 前言：前段时间接到一个需求，要求系统中实现一个可以上传语音文件的功能，然后将文件和需要的参数发送到电信的接口上； 开始说起来感觉很简单，但是就真的被折磨了好几天，主要还是httpClient发送文件和参数到指定url，还有要从公司内网调中台再调电信接口这个过程花费了不少时间。既然涉及到了文件的上传，就想着把涉及到的东西都系统的学一遍，毕竟之前也没做过这些。 HttpClient请求数据到指定接口 对于通过HttpClien发送文件，就要先了解HttpClient的知识了； Ht
HttpClient 教程 ：HttpClient执行Http的方法。
weixin_34409357的博客
06-16 562
1.1. 请求执行HttpClient最基本的功能就是执行Http方法。一个Http方法的执行涉及到一个或者多个Http请求/Http响应的交互，通常这个过程都会自动被HttpClient处理，对用户透明。用户只需要提供Http请求对象，HttpClient就会将http请求发送给目标服务器，并且接收服务器的响应，如果http请求执行不成功，httpclient就会抛出异样。...
使用 HttpClient 进行 HTTP 请求的简介和示例
liuliuliu17的博客
06-20 411
HttpClient 是 Apache HttpComponents 库的一部分，提供了一个功能强大且易于使用的 HTTP 客户端。它支持 HTTP/1.1 协议，并提供了一组丰富的功能，如发送 GET、POST 请求，处理响应，设置请求头、请求参数，以及处理连接管理等。HttpClient 是 Java 中一个功能强大的 HTTP。
HttpClient使用详解
cihongmo6452的博客
08-01 784
Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因...
java调用第三方接口
鹿林深的博客
09-27 409
1.pom引用 <dependency> <groupId>commons-httpclient</groupId> <artifactId>commons-httpclient</artifactId> <version>3.1</versio...
Http系列-HttpClient使用详情解
qq_41644069的博客
01-09 1180
1.HttpClient简介 HTTP 协议是 Internet 上使用得最多、最重要的协议之一，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新
Java中发送Http请求之httpClient
ABestRookie的博客
11-23 4084
Java中发送Http请求之httpClient1 httpClient的简介2 httpClient的案列 HTTP 协议是 Internet 上使用得最多、最重要的协议之一，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源, JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活. 1 httpClient的简介 HttpClient 是 Apache Jakarta Common 下的子
httpclient发起post请求
最新发布
07-29
您可以使用C#中的HttpClient类来发起POST请求。以下是一个示例代码： ```csharp using System; using System.Net.Http; using System.Threading.Tasks; class Program { static async Task Main(string[] args) { using (HttpClient client = new HttpClient()) { string url = "http://example.com/api/endpoint"; // 替换为您要发送POST请求的URL // 构造POST请求的内容，可以是字符串、字节数组或表单数据 var postData = new StringContent("hello world", System.Text.Encoding.UTF8, "application/json"); // 发送POST请求并等待响应 HttpResponseMessage response = await client.PostAsync(url, postData); // 检查响应是否成功 if (response.IsSuccessStatusCode) { // 读取响应内容 string responseContent = await response.Content.ReadAsStringAsync(); Console.WriteLine("响应内容：" + responseContent); } else { Console.WriteLine("请求失败，状态码：" + response.StatusCode); } } } } ``` 在示例代码中，我们使用HttpClient类来创建一个HTTP客户端，并使用PostAsync方法发送POST请求。您需要将`url`替换为您要发送POST请求的URL，并将`postData`替换为您要发送的实际数据。 请注意，此示例中的POST数据是作为字符串发送的，Content-Type设置为`application/json`。如果您需要发送其他类型的数据，请相应地调整代码。 希望对您有所帮助！如有更多问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值