HttpClient工具类

最新推荐文章于 2024-10-04 22:38:52 发布
最新推荐文章于 2024-10-04 22:38:52 发布
阅读量258 收藏
点赞数 5
文章标签： http java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smg11/article/details/137789694
版权

HttpClient工具类


import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.GzipDecompressingEntity;
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.methods.HttpRequestBase;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.client.utils.URIUtils;
import org.apache.http.conn.routing.HttpRoute;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.DefaultSchemePortResolver;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.pool.PoolStats;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 
 */
public class HttpClient {
    static final int TIMEOUT_MSEC = 5 * 1000;
    private static Logger logger = LoggerFactory.getLogger(HttpClient.class);
    private static final String DEFAULT_CHARSET = "UTF-8";
    private  static final Byte[] LOCKS = new Byte[0];  
    
//    private static HttpClient INSTANCE1 = null;
    private volatile static HttpClient INSTANCE = null;
    
    private DefaultHttpClientConfig httpClientConfig = null;
    private CloseableHttpClient httpClient;
    private PoolingHttpClientConnectionManager connectionManager;

    private Lock lock = new ReentrantLock();
    private static ConcurrentHashMap<Integer, RequestConfig> requstConfigCache = new ConcurrentHashMap<Integer, RequestConfig>(10);
    
    private HttpClient(DefaultHttpClientConfig httpClientConfig) {
    	this.httpClientConfig =httpClientConfig;
    }

   /* public static HttpClient getHttpClient() {
    	if(INSTANCE1==null){
    		synchronized (LOCKS) {
    			if(INSTANCE1==null){
    				INSTANCE1 = new HttpClient(new DefaultHttpClientConfig());
    			}
			}
    	}
        return INSTANCE1;
    }*/
    
    public static HttpClient getHttpClient(DefaultHttpClientConfig httpClientConfig) {
    	if(INSTANCE==null){
    		synchronized (LOCKS) {
    			if(INSTANCE==null){
    				if(httpClientConfig==null){
    					httpClientConfig=new DefaultHttpClientConfig();
    				}
    				INSTANCE = new HttpClient(httpClientConfig);
    			}
			}
    	}
        return INSTANCE;
    }

    /*
     * timeout:socket超时时间，毫秒;不设置请求超时时间，则默认为2000；
     */
    public RequestConfig getRequestConfig(int timeout) 
    {
    	if(timeout==0)
    	{
    		timeout = 3000;
    	}
    	RequestConfig requestConfig = requstConfigCache.get(timeout);
    	if (requestConfig == null) {
            lock.lock();
            try {
                requestConfig = requstConfigCache.get(timeout);
                if (requestConfig == null) {
                    requestConfig = RequestConfig.custom()
                            .setConnectionRequestTimeout(httpClientConfig.getConnectionRequestTimeout())//该值就是连接不够用的时候等待超时时间，一定要设置，而且不能太大
                            .setConnectTimeout(httpClientConfig.getConnectionTimeout())//连接一个url的连接等待时间（连接超时）
                            .setSocketTimeout(timeout).build();//连接上一个url，获取response的返回等待时间(请求超时)
                    requstConfigCache.put(timeout, requestConfig);
                }
            } finally {
                lock.unlock();
            }
        }
    	return requestConfig;
    }
    public RequestConfig getRequestConfig() 
	{
    	return getRequestConfig(httpClientConfig.getDefaultSocketTimeout());
	}
    
    private void init() {
        if (httpClient == null) {
            lock.lock();
            try {
                if (httpClient == null) {              	 
                    connectionManager = new PoolingHttpClientConnectionManager();
                    connectionManager.setMaxTotal(httpClientConfig.getMaxTotal());//设置整个连接池最大连接数
                    /**
                     * 根据连接到的主机对MaxTotal的一个细分；比如：
						MaxtTotal=400 DefaultMaxPerRoute=200
					         只连接到http://sishuok.com时，到这个主机的并发最多只有200；而不是400；
						当连接到http://sishuok.com 和 http://qq.com时，
						到每个主机的并发最多只有200；即加起来是400（但不能超过400）；
						所以起作用的设置是DefaultMaxPerRoute。
                     */
                    connectionManager.setDefaultMaxPerRoute(httpClientConfig.getDefaultMaxPerRoute());
                    connectionManager.closeExpiredConnections();
                    httpClient = HttpClientBuilder.create()
                            .setConnectionManager(connectionManager)
                            .setDefaultRequestConfig(getRequestConfig())
                            .disableCookieManagement()
                            .disableAutomaticRetries()
                            .build();
                }
            } finally {
                lock.unlock();
            }
        }
    }

    public PoolStats getConnectionStatus(URI uri) {
    	init();
        if (connectionManager != null) {
            HttpHost target = URIUtils.extractHost(uri);
            if (target.getPort() <= 0) {
                try {
                    target = new HttpHost(
                            target.getHostName(),
                            DefaultSchemePortResolver.INSTANCE.resolve(target),
                            target.getSchemeName());
                } catch (Throwable ignore) {
                    target = null;
                }
            }
            if (target != null)
            {
            	return connectionManager.getStats(new HttpRoute(target));
            }
        }
        return null;
    }

    public String execute(HttpRequestBase request) throws Exception {
        byte[] bytes = executeAndReturnByte(request);
        if (bytes == null || bytes.length == 0) return null;
        return new String(bytes, DEFAULT_CHARSET);
    }
    
    public byte[] executeAndReturnByte(HttpRequestBase request) throws Exception {
        init();
        HttpEntity entity = null;
        CloseableHttpResponse resp = null;
        byte[] rtn = new byte[0];
        if (request == null) return rtn;
        try {
            resp = httpClient.execute(request);
            entity = resp.getEntity();
            if (resp.getStatusLine().getStatusCode() == 200) {
                String encoding = ("" + resp.getFirstHeader("Content-Encoding")).toLowerCase();
                if (encoding.indexOf("gzip") > 0) {
                    entity = new GzipDecompressingEntity(entity);
                }
                rtn = EntityUtils.toByteArray(entity);
            } else {
                logger.warn(request.getURI().toString()+" return error {}");
            }
        } catch (Exception e) {
            logger.error(request.getURI().toString() + " " + e.getMessage());
            throw e;
        } finally {
            EntityUtils.consumeQuietly(entity);
            if (resp != null) {
                try {
                    resp.close();
                } catch (Exception ignore) {
                }
            }
        }
        return rtn;
    }

    /**
     * 发送GET方式请求
     * @param url 地址
     * @param paramMap 参数
     */
    public static String doGet(String url, Map<String, String> paramMap) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        String result = "";
        CloseableHttpResponse response = null;

        try {
            URIBuilder builder = new URIBuilder(url);
            if (paramMap != null) {
                for (String key : paramMap.keySet()) {
                    builder.addParameter(key, paramMap.get(key));
                }
            }
            URI uri = builder.build();
            HttpGet httpGet = new HttpGet(uri);
            response = httpClient.execute(httpGet);
            //判断响应状态
            if (response.getStatusLine().getStatusCode() == 200) {
                result = EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return result;
    }
    public static String doPost(String url, Map<String, String> paramMap) throws IOException {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";

        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);

            // 创建参数列表
            if (paramMap != null) {
                List<NameValuePair> paramList = new ArrayList();
                for (Map.Entry<String, String> param : paramMap.entrySet()) {
                    paramList.add(new BasicNameValuePair(param.getKey(), param.getValue()));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
                httpPost.setEntity(entity);
            }

            httpPost.setConfig(builderRequestConfig());

            // 执行http请求
            response = httpClient.execute(httpPost);

            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            throw e;
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }
    /**
     * 发送POST请求
     * @param url
     * @return
     * @throws IOException
     */
    public static String doPost(String url, String json) throws IOException {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";

        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setConfig(builderRequestConfig());
            httpPost.addHeader("Content-Type", "application/json;charset=UTF-8");

            // 设置 JSON 字符串为请求体
            StringEntity requestEntity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(requestEntity);

            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            throw e; // You may want to log the exception or handle it accordingly
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace(); // You may want to log the exception or handle it accordingly
            }
            try {
                httpClient.close(); // Don't forget to close the httpClient
            } catch (IOException e) {
                e.printStackTrace(); // You may want to log the exception or handle it accordingly
            }
        }

        return resultString;
    }

    private static RequestConfig builderRequestConfig() {
        return RequestConfig.custom()
                .setConnectTimeout(TIMEOUT_MSEC)
                .setConnectionRequestTimeout(TIMEOUT_MSEC)
                .setSocketTimeout(TIMEOUT_MSEC).build();
    }

    /**
     * Post请求 json嵌套
     * @param url
     * @param paramMap
     * @return
     * @throws IOException
     */
    public static String doPostJson(String url, Map<String, Object> paramMap) throws IOException {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";

        try {
            HttpPost httpPost = new HttpPost(url);

            ObjectMapper objectMapper = new ObjectMapper();
            String json = objectMapper.writeValueAsString(paramMap);

            StringEntity entity = new StringEntity(json, "UTF-8");
            httpPost.setEntity(entity);

            httpPost.setHeader("Content-Type", "application/json");

            response = httpClient.execute(httpPost);

            // 获取并返回响应内容
            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } finally {
            // 关闭连接
            if (response != null) {
                response.close();
            }
            httpClient.close();
        }

        return resultString;
    }

}

上手使用：Post请求 json嵌套

		public void sentMessage(String accessToken, String msgId, String userId, String message, String openKfId, Long id){
		HashMap<String, Object> sentMap = new HashMap<>();
		String SENDING_MESSAGE_ADDRESS_URL = "https://qyapi.weixin.qq.com/cgi-bin/kf/send_msg?access_token=";

        HashMap<String, String> textMap = new HashMap<>();
        sentMap.put("touser", userId);
        sentMap.put(CustomerConstant.OPEN_KFID, openKfId);
        sentMap.put("msgid", msgId);
        sentMap.put("msgtype", "text");
        textMap.put("content", message);
        sentMap.put("text", textMap);
        String sentMessageUrl = CustomerConstant.SENDING_MESSAGE_ADDRESS_URL + accessToken;
        sentJson = doPostJson(sentMessageUrl, sentMap);
}

上手使用：发送POST请求

		 public String changeSession(String openKfId, String userId, String service_state, String servicer_userid) throws IOException {
        String accessToken = getAccessToken(wechatCustomerConfig.getCorpId(), wechatCustomerConfig.getCorpSecret());
        JSONObject jsonParams = new JSONObject();
        String url = CustomerConstant.CHANGE_SESSION_URL + accessToken;
        jsonParams.put(CustomerConstant.OPEN_KFID, openKfId);
        jsonParams.put(CustomerConstant.EXTERNAL_USERID, userId);
        jsonParams.put(CustomerConstant.SERVICE_STATE, service_state);
        jsonParams.put(CustomerConstant.SERVICER_USERID, servicer_userid);
        JSONObject jsonObject = JSON.parseObject(doPost(url, jsonParams.toJSONString()));
        log.info("改变会话回调：{}", jsonObject);
        return null;

    }
SuperLong-1129
关注
httpClient 工具类
05-06
httpClient 工具类，简化请求开发，拿来即用，我用在SpringBoot框架；对于依赖，你可以根据包名导入。
httpclient 工具类
05-17
在本文中，我们将深入探讨HttpClient工具类的创建与使用，以及如何自定义返回的对象。 首先，我们需要引入HttpClient的相关依赖。在Maven项目中，可以在pom.xml文件中添加以下依赖： ```xml <groupId>org.apache...
httpClient工具类
02-22
在实际项目中，通常会封装一个HttpClient工具类，将上述操作抽象成便捷的方法，方便其他代码调用。文件`httpClientUtil`可能就是这样一个工具类，包含了上述功能的实现。通过阅读和理解这个工具类的代码，我们可以更...
WinHttp异步实现GET, POST, 多线程下载文件
FlameCyclone的博客
09-29 581
基于WinHttp封装, 实现异步多线程文件下载, GET请求, POST请求
socket和http区别
weixin_37788102的博客
10-03 420
http：http是客户端用http协议进行请求，发送请求的时候需要封装http请求头，并绑定请求的数据，服务器一般有web服务器配合(当然也非绝对)，http的请求方式为客户端主动发起请求，服务器才能给响应，一次请求完毕后则断开连接，以节省资源，服务器不能主动给客户端发起响应，主要使用类是NSURLConnection。其中，主体不同指的是socke是一个调用接口（API），而HTTP是基于TCP/IP协议的应用层协议。http：HTTP是基于TCP/IP协议的应用层协议，定义的是传输数据的内容的规范。
HTTP 和 HTTPS 协议的区别？
智通全网络工作室的博客
09-27 1449
HTTP 是一种无状态的、基于请求/响应模型的应用层协议，旨在用于分布式、协作和超媒体信息系统。最常见的用途是查看网页。HTTP 协议在 TCP/IP 上运行，其标准端口是 80。了解 HTTP 和 HTTPS 之间的区别至关重要。HTTPS 是保护用户信息和提升网站信任度的关键因素。在一个安全意识增强的时代，确保你的网站使用 HTTPS 不仅是一个负责任的做法，也是赢得用户信任的基石。希望这篇博客能帮助你更好地理解这两种协议的区别及其重要性。
java8:hutool：httputil.post读取配置项中的url
hongyuxiongji的博客
09-28 656
不过这种方式有潜在的问题，因为在Spring容器初始化Bean的时候构造函数会被调用，但是如果@Value注入还没完成（例如配置文件加载延迟等情况），可能会导致staticUrl的值为null。如果HttpUtil.post是静态方法，无法直接访问非静态的@Value注入的属性。1. 首先将配置项的值通过@Value注入到类的成员变量，然后在构造函数中将这个值传递给一个静态变量。这种方式更符合Spring的依赖注入原则，而且可以确保在需要使用配置值的时候能够正确获取到。通过一个工具类方法获取配置值。
HTTP 协议的基本格式和 fiddler 的用法
GodK777的博客
10-03 541
一、请求格式1. 请求行- 包含请求方法（如 GET、POST、PUT 等）、请求的资源路径和 HTTP 版本。例如：“GET /index.html HTTP/1.1”。2. 请求头- 由一系列键值对组成，如“Host”表示请求的主机名，“User-Agent”表示发出请求的客户端信息等。- 每个请求头占一行，格式为“头字段名: 值”。3. 空行- 用于分隔请求头和请求体。4. 请求体- 对于某些请求方法（如 POST），会包含要提交的数据。二、响应格式。
HTTP【网络】
qq_2972806103的博客
10-03 1012
HTTP协议格式、HTTP的方法 、HTTP的状态码、HTTP常见的Header
windows C++-使用任务和 XML HTTP 请求进行连接(一)
苏洛的博客
10-02 738
当您使用 IXMLHTTPRequest2 接口通过 HTTP 创建 Web 请求时，可以实现 IXMLHTTPRequest2Callback 接口来接收服务器响应并对其他事件做出响应。此示例定义了 HttpRequest 类来创建 Web 请求，并定义了 HttpRequestBuffersCallback 和 HttpRequestStringCallback 类来处理响应。
网络协议 TCP、UDP 和 HTTP
m0_68570169的博客
09-27 1658
特性TCPUDP连接方式面向连接（三次握手）无连接可靠性可靠（确认、重传、校验、排序）不可靠（不确认、不重传、不排序）传输顺序保证顺序到达不保证顺序流量控制有无拥塞控制有无头部开销较大较小速度较慢（但可靠）较快（但不可靠）典型应用场景DNS、视频会议、在线游戏TCP和UDP各有优劣，选择使用哪种协议取决于具体的应用需求。如果需要数据可靠性和顺序性，TCP是更好的选择；如果对传输速度和实时性要求高，且能容忍部分数据丢失，则UDP更为适合。特性。
什么是 HTTP 请求中的 options 请求？
汪子熙的专家技术分享
10-03 933
OPTIONS 请求作为 HTTP 方法中的一种，扮演着极为重要的角色，尤其是在跨域请求和 API 开发中。它为客户端提供了与服务器进行沟通和协商的手段，使得前后端的交互更加安全和灵活。开发者需要对 OPTIONS 请求的工作原理有清晰的理解，特别是在 CORS 场景下，通过正确配置服务器的 CORS 头部，可以确保前端应用的稳定运行。
windows C++-windows C++-使用任务和 XML HTTP 请求进行连接(二)
苏洛的博客
10-03 350
当您使用 IXMLHTTPRequest2 接口通过 HTTP 创建 Web 请求时，可以实现 IXMLHTTPRequest2Callback 接口来接收服务器响应并对其他事件做出响应。此示例定义了 HttpRequest 类来创建 Web 请求，并定义了 HttpRequestBuffersCallback 和 HttpRequestStringCallback 类来处理响应。
【分布式微服务云原生】 RPC协议：超越HTTP的远程通信艺术
Dylaniou的博客
10-01 1124
实现方式描述基于TCP/IPRPC直接使用TCP/IP协议栈进行点对点的网络通信基于HTTP使用HTTP/2作为其传输协议，提供头部压缩、多路复用等特性基于Web服务基于SOAP或REST等Web服务标准实现自定义协议实现为自定义的二进制协议，直接运行在TCP或其他网络协议之上希望这篇文章能够帮助你更好地理解和应用RPC协议。记得在评论区留下你的想法，让我们一起进步！
HTTP 重定向：301 与 308 的区别
吃面不喝汤的博客
09-29 280
HTTP 重定向是指服务器响应客户端请求时，通过特定的状态码和Location响应头将客户端引导到另一个资源。例如，当用户访问一个过期或被移动的页面时，服务器可以通过重定向将用户自动转移到新的页面，提升用户体验。
http 缓存
秋夫人
10-03 865
HTTP缓存是一种重要的性能优化技术，它通过存储和重用之前获取的资源来减少网络流量和加快页面加载速度。
在 ArkTS 网络请求中，重新封装一下 http 模块
最新发布
读心悦
10-04 816
注意，这个封装假设服务器返回的是JSON格式的数据，并在成功响应时将其解析为JavaScript对象。如果服务器返回的是其他格式的数据，你需要相应地修改解析逻辑。模块可以提供一个更简洁、更易于使用的API，同时隐藏底层细节，使开发者能够更专注于业务逻辑。以下是一个简单的示例，展示了如何重新封装鸿蒙系统的。方法，分别用于发起GET和POST请求。此外，这个封装没有处理请求超时、重试机制等高级功能。如果你需要这些功能，可以在封装中添加相应的逻辑。在这个封装中，我们创建了一个。在ArkTS中，重新封装。
什么是 HTTP 请求的 X-Forwarded-Proto 字段
汪子熙的专家技术分享
09-29 750
在现代网络架构中，特别是涉及反向代理服务器和负载均衡器的架构中，头部字段扮演着重要角色。反向代理服务器和负载均衡器是常见的网络组件，它们站在客户端和最终服务器之间，处理请求并将其转发到适当的目标服务器。这个过程中，原始客户端请求的信息可能会丢失或者被修改，而提供了一种方法来保留和传递重要的协议信息。
httpclient工具类
07-27
Java HttpClient工具类是一个用于发送HTTP请求的Java类库。...该工具类可以用于访问Web服务、下载文件、上传文件等各种场景。...使用Java HttpClient工具类可以方便地实现与Web服务的交互，提高开发效率。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值