Httpclient最新工具包 可以过HTTPS验证

最新推荐文章于 2025-06-13 14:38:33 发布
最新推荐文章于 2025-06-13 14:38:33 发布
阅读量2k 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： java开发 文章标签： httpclient
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Java_chaozi/article/details/53116673
这篇博客介绍了如何在最新的HttpClient工具包中配置和使用HTTP客户端，使其能够成功通过HTTPS验证。通过阅读，读者将学习到在Pom.xml文件中引入相关依赖以及创建和配置HttpClient的实用技巧。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Pom.xml

        <httpclient.version>4.3.5</httpclient.version>  
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>${httpclient.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>${httpclient.version}</version>
        </dependency>

工具类

package com.chaojimanong.os.Service.common;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URISyntaxException;
import java.nio.charset.Charset;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.net.ssl.SSLContext;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpException;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
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.config.ConnectionConfig;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.config.SocketConfig;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.cookie.Cookie;
import org.apache.http.cookie.CookieOrigin;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.FormBodyPart;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.impl.cookie.BasicClientCookie;
import org.apache.http.impl.cookie.BestMatchSpec;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import com.cloudmapbj.os.entity.common.HttpResult;


class AnyTrustStrategy implements TrustStrategy{

    @Override
    public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        return true;
    }

}

public class HttpUtil {

    private static final Log log= LogFactory.getLog(HttpUtil.class);

    private static int bufferSize= 1024;

    private static volatile HttpUtil instance;

    private ConnectionConfig connConfig;

    private SocketConfig socketConfig;

    private ConnectionSocketFactory plainSF;

    private KeyStore trustStore;

    private SSLContext sslContext;

    private LayeredConnectionSocketFactory sslSF;

    private Registry<ConnectionSocketFactory> registry;

    private PoolingHttpClientConnectionManager connManager;

    private volatile HttpClient client;

    private volatile BasicCookieStore cookieStore;

    public static String defaultEncoding= "utf-8";

    private static final String SECURED_URI = "";//远程加密认证地址


    public HttpResponse get(String uri) throws Exception {
        return doGetLogin(uri, null);
    }
    private static List<NameValuePair> paramsConverter(Map<String, Object> params){
        List<NameValuePair> nvps = new LinkedList<NameValuePair>();
        Set<Entry<String, Object>> paramsSet= params.entrySet();
        for (Entry<String, Object> paramEntry : paramsSet) {
            nvps.add(new BasicNameValuePair(paramEntry.getKey(), paramEntry.getValue().toString()));
        }
        return nvps;
    }

    public static String readStream(InputStream in, String encoding){
        if (in == null){
            return null;
        }
        try {
            InputStreamReader inReader= null;
            if (encoding == null){
                inReader= new InputStreamReader(in, defaultEncoding);
            }else{
                inReader= new InputStreamReader(in, encoding);
            }
            char[] buffer= new char[bufferSize];
            int readLen= 0;
            StringBuffer sb= new StringBuffer();
            while((readLen= inReader.read(buffer))!=-1){
                sb.append(buffer, 0, readLen);
            }
            inReader.close();
            return sb.toString();
        } catch (IOException e) {
            log.error("读取返回内容出错", e);
        }
        return null;
    }

    private HttpUtil(){
        //设置连接参数
        connConfig = ConnectionConfig.custom().setCharset(Charset.forName(defaultEncoding)).build();
        socketConfig = SocketConfig.custom().setSoTimeout(100000).build();
        RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder.<ConnectionSocketFactory>create();
        plainSF = new PlainConnectionSocketFactory();
        registryBuilder.register("http", plainSF);
        //指定信任密钥存储对象和连接套接字工厂
        try {
            trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
            sslContext = SSLContexts.custom().useTLS().loadTrustMaterial(trustStore, new AnyTrustStrategy()).build();
            sslSF = new SSLConnectionSocketFactory(sslContext, SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            registryBuilder.register("https", sslSF);
        } catch (KeyStoreException e) {
            throw new RuntimeException(e);
        } catch (KeyManagementException e) {
            throw new RuntimeException(e);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
        registry = registryBuilder.build();
        //设置连接管理器
        connManager = new PoolingHttpClientConnectionManager(registry);
        connManager.setDefaultConnectionConfig(connConfig);
        connManager.setDefaultSocketConfig(socketConfig);
        //指定cookie存储对象
        cookieStore = new BasicCookieStore();
        //构建客户端
         client= HttpClientBuilder.create().setDefaultCookieStore(cookieStore).setConnectionManager(connManager).build();
        HttpPost httpPost = new HttpPost(SECURED_URI);
        httpPost.addHeader("Accept-Charset", "UTF-8");
        //请求头设置账户密码     
        httpPost.addHeader("Authorization", "Basic " + new String(Base64.encodeBase64(("***" + ":" + "***").getBytes(Charset.forName("UTF-8"))), Charset.forName("UTF-8")));
        try {
            HttpResponse execute = client.execute(httpPost);
            System.out.println(execute.getStatusLine().getStatusCode());
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static HttpUtil getInstance(){
        synchronized (HttpUtil.class) {
            if (HttpUtil.instance == null){
                instance = new HttpUtil();
            }
            return instance;
        }
    }

    public InputStream doGet(String url) throws URISyntaxException, ClientProtocolException, IOException{
        HttpResponse response= this.doGet(url, null);
        return response!=null ? response.getEntity().getContent() : null;
    }
    public HttpResult doGetBody(String url) throws URISyntaxException, ClientProtocolException, IOException{
        HttpResponse response= this.doGet(url, null);
        return new HttpResult(response.getStatusLine().getStatusCode(), EntityUtils.toString(
                response.getEntity(), "UTF-8"));
    }

    public String doGetForString(String url) throws URISyntaxException, ClientProtocolException, IOException{
        return HttpUtil.readStream(this.doGet(url), null);
    }

    public InputStream doGetForStream(String url, Map<String, Object> queryParams) throws URISyntaxException, ClientProtocolException, IOException{
        HttpResponse response= this.doGet(url, queryParams);
        return response!=null ? response.getEntity().getContent() : null;
    }

    public String doGetForString(String url, Map<String, Object> queryParams) throws URISyntaxException, ClientProtocolException, IOException{
        return HttpUtil.readStream(this.doGetForStream(url, queryParams), null);
    }

    /**
     * 基本的Get请求
     * @param url 请求url
     * @param queryParams 请求头的查询参数
     * @return
     * @throws URISyntaxException 
     * @throws IOException 
     * @throws ClientProtocolException 
     */
    public HttpResponse doGet(String url, Map<String, Object> queryParams) throws URISyntaxException, ClientProtocolException, IOException{
        HttpGet gm = new HttpGet();
        URIBuilder builder = new URIBuilder(url);
        //填入查询参数
        if (queryParams!=null && !queryParams.isEmpty()){
            builder.setParameters(HttpUtil.paramsConverter(queryParams));
        }
        gm.setURI(builder.build());
        return client.execute(gm);
    }
    public HttpResponse doGetLogin(String url, Map<String, Object> queryParams) throws URISyntaxException, ClientProtocolException, IOException{
        HttpGet gm = new HttpGet();
        URIBuilder builder = new URIBuilder(url);
        //填入查询参数
        if (queryParams!=null && !queryParams.isEmpty()){
            builder.setParameters(HttpUtil.paramsConverter(queryParams));
        }
        gm.setURI(builder.build());
        return client.execute(gm);
    }

    public InputStream doPostForStream(String url, Map<String, Object> queryParams) throws URISyntaxException, ClientProtocolException, IOException {
        HttpResponse response = this.doPost(url, queryParams, null);
        return response!=null ? response.getEntity().getContent() : null;
    }

    public String doPostForString(String url, Map<String, Object> queryParams) throws URISyntaxException, ClientProtocolException, IOException {
        return HttpUtil.readStream(this.doPostForStream(url, queryParams), null);
    }

    public InputStream doPostForStream(String url, Map<String, Object> queryParams, Map<String, Object> formParams) throws URISyntaxException, ClientProtocolException, IOException{
        HttpResponse response = this.doPost(url, queryParams, formParams);
        return response!=null ? response.getEntity().getContent() : null;
    }
    public HttpResult doPostForStreamBody(String url, Map<String, Object> queryParams, Map<String, Object> formParams) throws URISyntaxException, ClientProtocolException, IOException{
        HttpResponse response = this.doPost(url, queryParams, formParams);
        return new HttpResult(response.getStatusLine().getStatusCode(), EntityUtils.toString(
                response.getEntity(), "UTF-8"));
    }

    public String doPostRetString(String url, Map<String, Object> queryParams, Map<String, Object> formParams) throws URISyntaxException, ClientProtocolException, IOException{
        return HttpUtil.readStream(this.doPostForStream(url, queryParams, formParams), null);
    }

    /**
     * 基本的Post请求
     * @param url 请求url
     * @param queryParams 请求头的查询参数
     * @param formParams post表单的参数
     * @return
     * @throws URISyntaxException 
     * @throws IOException 
     * @throws ClientProtocolException 
     */
    public HttpResponse doPost(String url, Map<String, Object> queryParams, Map<String, Object> formParams) throws URISyntaxException, ClientProtocolException, IOException{
        HttpPost pm = new HttpPost();
        URIBuilder builder = new URIBuilder(url);
        //填入查询参数
        if (queryParams!=null && !queryParams.isEmpty()){
            builder.setParameters(HttpUtil.paramsConverter(queryParams));
        }
        pm.setURI(builder.build());
        //填入表单参数
        if (formParams!=null && !formParams.isEmpty()){
            pm.setEntity(new UrlEncodedFormEntity(HttpUtil.paramsConverter(formParams)));
        }
        return client.execute(pm);
    }

    /**
     * 多块Post请求
     * @param url 请求url
     * @param queryParams 请求头的查询参数
     * @param formParts post表单的参数,支持字符串-文件(FilePart)和字符串-字符串(StringPart)形式的参数
     * @param maxCount 最多尝试请求的次数
     * @return
     * @throws URISyntaxException 
     * @throws ClientProtocolException 
     * @throws HttpException
     * @throws IOException
     */
    public HttpResponse multipartPost(String url, Map<String, Object> queryParams, List<FormBodyPart> formParts) throws URISyntaxException, ClientProtocolException, IOException{

        HttpPost pm= new HttpPost();
        URIBuilder builder = new URIBuilder(url);
        //填入查询参数
        if (queryParams!=null && !queryParams.isEmpty()){
            builder.setParameters(HttpUtil.paramsConverter(queryParams));
        }
        pm.setURI(builder.build());
        //填入表单参数
        if (formParts!=null && !formParts.isEmpty()){
            MultipartEntityBuilder entityBuilder = MultipartEntityBuilder.create();
            entityBuilder = entityBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
            for (FormBodyPart formPart : formParts) {
                entityBuilder = entityBuilder.addPart(formPart.getName(), formPart.getBody());
            }
            pm.setEntity(entityBuilder.build());
        }
        return client.execute(pm);
    }

    /**
     * 获取当前Http客户端状态中的Cookie
     * @param domain 作用域
     * @param port 端口 传null 默认80
     * @param path Cookie路径 传null 默认"/"
     * @param useSecure Cookie是否采用安全机制 传null 默认false
     * @return
     */
    public Map<String, Cookie> getCookie(String domain, Integer port, String path, Boolean useSecure){
        if (domain == null){
            return null;
        }
        if (port==null){
            port= 80;
        }
        if (path==null){
            path="/";
        }
        if (useSecure==null){
            useSecure= false;
        }
        List<Cookie> cookies = cookieStore.getCookies();
        if (cookies==null || cookies.isEmpty()){
            return null;
        }

        CookieOrigin origin= new CookieOrigin(domain, port, path, useSecure);
        BestMatchSpec cookieSpec = new BestMatchSpec();
        Map<String, Cookie> retVal= new HashMap<String, Cookie>();
        for (Cookie cookie : cookies) {
            if(cookieSpec.match(cookie, origin)){
                retVal.put(cookie.getName(), cookie);               
            }
        }
        return retVal;
    }

    /**
     * 批量设置Cookie
     * @param cookies cookie键值对图
     * @param domain 作用域 不可为空
     * @param path 路径 传null默认为"/"
     * @param useSecure 是否使用安全机制 传null 默认为false
     * @return 是否成功设置cookie
     */
    public boolean setCookie(Map<String, String> cookies, String domain, String path, Boolean useSecure){
        synchronized (cookieStore) {
            if (domain==null){
                return false;
            }
            if (path==null){
                path= "/";
            }
            if (useSecure==null){
                useSecure= false;
            }
            if (cookies==null || cookies.isEmpty()){
                return true;
            }
            Set<Entry<String, String>> set= cookies.entrySet();
            String key= null;
            String value= null;
            for (Entry<String, String> entry : set) {
                key= entry.getKey();
                if (key==null || key.isEmpty() || value==null || value.isEmpty()){
                    throw new IllegalArgumentException("cookies key and value both can not be empty");
                }
                BasicClientCookie cookie= new BasicClientCookie(key, value);
                cookie.setDomain(domain);
                cookie.setPath(path);
                cookie.setSecure(useSecure);
                cookieStore.addCookie(cookie);
            }
            return true;
        }
    }

    /**
     * 设置单个Cookie
     * @param key Cookie键
     * @param value Cookie值
     * @param domain 作用域 不可为空
     * @param path 路径 传null默认为"/"
     * @param useSecure 是否使用安全机制 传null 默认为false
     * @return 是否成功设置cookie
     */
    public boolean setCookie(String key, String value, String domain, String path, Boolean useSecure){
        Map<String, String> cookies= new HashMap<String, String>();
        cookies.put(key, value);
        return setCookie(cookies, domain, path, useSecure);
    }
     /**
     * 传递json 本人用的这个 记得做判断
     * @param url
     * @param json
     * @return
     * @throws Exception
     */
    public HttpResult doPostForStreamEntity(String url, String json) throws Exception {
        HttpPost pm= new HttpPost();
        StringEntity stringEntity = new StringEntity((json), "UTF-8");
        stringEntity.setContentType("application/json");
        pm.setEntity(stringEntity);
        URIBuilder builder = new URIBuilder(url);
        pm.setURI(builder.build());
        HttpResponse execute = client.execute(pm);
        return new HttpResult(execute.getStatusLine().getStatusCode(), EntityUtils.toString(
                execute.getEntity(), "UTF-8"));
    }


}
httpclient-4.5.4.jar最新版本
12-08
httpclient-4.5.4.jar最新版本， httpclient-4.5.4.jar最新版本可供使用
httpClient使用指南最新版
04-05
Httpclient，一个我们平时开发时经常用到的组件
httpclient4 中文版帮助文档，最新官方版翻译版（第一章 上）
weixin_30807677的博客
09-20 142
（第一章 上） 前言 超文本传输协议（HTTP）也许是当今互联网上使用的最重要的协议了。Web服务，有网络功能的设备和网络计算的发展，都持续扩展了HTTP协议的角色，超越了用户使用的Web浏览器范畴，同时，也增加了需要HTTP协议支持的应用程序的数量。 尽管java.net包提供了基本通过HTTP访问资源的功能，但它没有提供全面的灵活性和其它很多应用程序需要的功能。HttpClie...
java调用http HttpClient
最新发布
huangwei8827488的博客
06-13 117
RestTemplate 是由Spring提供的一个HTTP请求工具。比传统的Apache和HttpCLient便捷许多，能够大大提高客户端的编写效率。此处参考：https://www.cnblogs.com/hehongtao/p/5276425.html。使用JDK原生提供的net，无需其他jar包。
HttpClientUtils
weixin_42133266的博客
11-07 889
HttpClientUtils import org.apache.http.NameValuePair; import org.apache.http.client.entity.UrlEncodedFormEntity; import org.apache.http.client.methods.CloseableHttpResponse; import org.apache.http.cli...
httpclient 工具包
07-21
http协议基础工具类，该类提供了get，post功能调用方法
HttpClientUtil工具类发送get和post请求，支持http和https，支持发送文件
04-07
下面我们将详细讨论HttpClientUtil工具类如何实现这些功能。 首先，HttpClientUtil工具类通常会封装HttpClient的基本操作，以便于开发者在应用中便捷地调用。GET和POST请求是HTTP协议中最常见的两种请求方法。GET...
HttpClient工具包
03-15
HttpClient工具包是Apache开源组织提供的一款强大的HTTP客户端通信库，主要用在Java环境中进行网络请求。这个工具包为开发者提供了丰富的API，使得处理HTTP协议变得简单而高效。HttpClient 4.1.3是该库的一个版本，...
JAVA利用HttpClient进行HTTPS接口调用的方法
08-29
X509证书可以用来验证服务器的身份，并确保数据的安全。 知识点6：TrustManager的基本概念 TrustManager是一个接口，用于管理信任证书。TrustManager可以检查证书的有效性，并决定是否信任该证书。在Java中，...
httpclient.jar包下载.zip
02-21
网络协议方面，HttpClient遵循HTTP/1.1标准，并且可以与HTTPS（即安全的HTTP）一起工作。它处理了连接管理，包括连接池、超时设置和重用，这些在处理大量请求时非常关键。HttpClient还可以处理HTTP状态码和响应头，...
httpClient工具包
iteye_8157的博客
09-19 144
import java.util.ArrayList;import java.util.List;import java.util.Map;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.apache.http.HttpEntity;import org....
httpClient4.5所需工具包
06-27
httpclient-4.5工具包非常齐全，亲测，亲测，亲测....
httpclient-4.5.3官方API中文文档_最新译版_2886K
11-03
文件名称：httpclient-4.5.3.zip 文件类型：ZIP 文件大小：2886KB 浏览入口：index.html文件，用浏览器打开
HTTPClient工具类，完整
08-07
HTTPClient工具类，完整，HTTPClient工具类，完整，HTTPClient工具类，完整HTTPClient工具类，完整，HTTPClient工具类，完整
httpClientUtil
11-13
自己做项目中用到的，以后保存下来以防以后用到。多多积累。
最新版httpclient4.4
11-13
最新版httpclient，jar包在解压后的lib文件夹下
Httpclient工具
chenping的博客
06-12 205
HttpClient是Apache Jakarta Common下的子项目，用来提供高效的、最新的、功能丰富的支持HTTP协议的客户端编程工具包，并且它支持HTTP协议最新的版本和建议。 使用HttpClient请求一个Http请求的步骤为： （1）创建一个HttpClient对象 （2）创建一个Request请求对象 （3）使用HttpClient来执行Request请求，得到对方的response （4）处理response （5）关闭HttpClient public class Httpclient
新版HttpClient 工具类，支持https，cookie。
weixin_44249738的博客
04-26 437
【代码】新版HttpClient 工具类，支持https，cookie。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值