JAVA HttpClient可以直接请求https

import com.alibaba.fastjson.JSONObject;
import org.apache.http.*;
import org.apache.http.client.entity.GzipDecompressingEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.springframework.stereotype.Component;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.net.URI;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @program: 
 * @description:
 * @packagename: 
 * @author:
 * @date: 
 **/
@Component
public class HttpClientUtil {
    CloseableHttpClient httpClient;
    public HttpClientUtil(){
        try {
            // 采用绕过验证的方式处理https请求
            SSLContext sslcontext = createIgnoreVerifySSL();
            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext,
                    NoopHostnameVerifier.INSTANCE);
            // 设置协议http和https对应的处理socket链接工厂的对象
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory> create()
                    .register("http", PlainConnectionSocketFactory.INSTANCE)
                    .register("https", sslsf).build();
            PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(
                    socketFactoryRegistry);
            HttpClients.custom().setConnectionManager(connManager);
            // 创建自定义的httpclient对象
            httpClient = HttpClients.custom().setConnectionManager(connManager).setSSLSocketFactory(sslsf).build();
        } catch (KeyManagementException | NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }

    public String get(String url) {
        return get(url, null,null);
    }
    public String get(String url,List<Header> headers) {
        return get(url, null,headers);
    }
    public <T> T getObject(String url, Map<String, String> paramMap, Class<T> clazz) {
        String result = get(url, paramMap,null);
        return JSONObject.parseObject(result, clazz);
    }

    public <T> T getObject(String url, Class<T> clazz) {
        try {
            String result = get(url, null,null);
            return JSONObject.parseObject(result, clazz);
        }catch (Exception e) {
            return null;
        }

    }

    public String get(String url, Map<String, String> paramMap,List<Header> headers) {
        String result = "";
        HttpGet get = new HttpGet(url);
        try {
            if (null != paramMap) {
                List<NameValuePair> params = setHttpParams(paramMap);
                String param = URLEncodedUtils.format(params, "UTF-8");
                get.setURI(URI.create(url + "?" + param));
            } else {
                get.setURI(URI.create(url));
            }
            if (headers!=null){
                for (Header header:headers
                     ) {
                    get.addHeader(header);
                }
            }
            HttpResponse response = httpClient.execute(get);
            //从response中获取响应体
            HttpEntity entity = response.getEntity();
            //把响应体转成文本
            if (response.containsHeader("Content-Encoding")) {
                result = EntityUtils.toString(new GzipDecompressingEntity(response.getEntity()));
            } else {
                result = EntityUtils.toString(entity, "UTF-8");
            }
            if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
                result = null;
            }
        } catch (Exception e) {
            System.out.println("请求异常");
            throw new RuntimeException(e);
        } finally {
            get.abort();
        }
        return result;
    }
    public String post(String url,JSONObject json, Map<String, String> paramMap,List<Header> headers) {
        String result = "";
        HttpPost post = new HttpPost(url);
        try {
            if (null != paramMap) {
                List<NameValuePair> params = setHttpParams(paramMap);
                String param = URLEncodedUtils.format(params, "UTF-8");
                post.setURI(URI.create(url + "?" + param));
            } else {
                post.setURI(URI.create(url));
            }
            if (headers!=null){
                for (Header header:headers
                ) {
                    post.addHeader(header);
                }
            }
            //装填参数
            StringEntity s = new StringEntity(json.toString(), "utf-8");
            s.setContentEncoding(new BasicHeader("Content-type",
                    "application/json"));
            //设置参数到请求对象中
            post.setEntity(s);
            post.setHeader("Content-type", "application/json");

            HttpResponse response = httpClient.execute(post);
            //从response中获取响应体
            HttpEntity entity = response.getEntity();
            //把响应体转成文本
            if (response.containsHeader("Content-Encoding")) {
                result = EntityUtils.toString(new GzipDecompressingEntity(response.getEntity()));
            } else {
                result = EntityUtils.toString(entity, "UTF-8");
            }
            if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
                result = null;
            }
        } catch (Exception e) {
            System.out.println("请求异常");
            throw new RuntimeException(e);
        } finally {
            post.abort();
        }
        return result;
    }
    public List<NameValuePair> setHttpParams(Map<String, String> paramMap) {
        List<NameValuePair> params = new ArrayList<NameValuePair>();
        Set<Map.Entry<String, String>> set = paramMap.entrySet();
        for (Map.Entry<String, String> entry : set) {
            params.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
        }
        return params;
    }
    /**
     * 绕过验证
     *
     */
    private  SSLContext createIgnoreVerifySSL() throws NoSuchAlgorithmException, KeyManagementException {
        SSLContext sc = SSLContext.getInstance("SSLv3");

        // 实现一个X509TrustManager接口，用于绕过验证，不用修改里面的方法
        X509TrustManager trustManager = new X509TrustManager() {
            @Override
            public void checkClientTrusted(java.security.cert.X509Certificate[] paramArrayOfX509Certificate,
                                           String paramString) throws CertificateException {
            }

            @Override
            public void checkServerTrusted(java.security.cert.X509Certificate[] paramArrayOfX509Certificate,
                                           String paramString) throws CertificateException {
            }

            @Override
            public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        };

        sc.init(null, new TrustManager[] { trustManager }, null);
        return sc;
    }

}

  HttpClientUtil httpClientUtil = new HttpClientUtil();
  String result = httpClientUtil.get(url);