Java 跳过证书方式调用https 接口

 Java 跳过证书方式调用https 接口地址实例：

package com.xuxueli.executor.sample.jboot;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import com.xxl.job.core.log.XxlJobLogger;


/**
 * Jboot app
 */
public class JbootApp {
    public static void main(String[] args) {
         //JbootApplication.run(args);
    	try {
			JbootApp.execute("GET");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
    
    //UUAP 接口地址
   	private static String url="https://XXXXX";
   	final static HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {
   	 
		public boolean verify(String hostname, SSLSession session) {
			return true;
		}
	};

    
    public static void execute(String param) throws Exception {
		XxlJobLogger.log("组织数据同步开始----start-----");
        XxlJobLogger.log("传入参数值："+param);
        
        HttpsURLConnection connection = null;
        BufferedReader bufferedReader = null;
        try {
        	
	    	 SSLContext sslContext = SSLContext.getInstance("SSL");
	    	 sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
	    	 
	    	// 从上述SSLContext对象中得到SSLSocketFactory对象     
	         SSLSocketFactory ssf = sslContext.getSocketFactory(); 
	    	// 打开和URL之间的连接
	    	URL realUrl = new URL(url);
	    	connection = (HttpsURLConnection) realUrl.openConnection();
	    	connection.setSSLSocketFactory(ssf);
	    	
            connection.setDoOutput(true);
            connection.setDoInput(true);
            connection.setRequestMethod("GET");
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)"); 
            connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
            connection.setRequestProperty("Accept-Charset", "application/json;charset=UTF-8");
            connection.connect(); 
            
            // valid StatusCode
            int statusCode = connection.getResponseCode();
            XxlJobLogger.log("接口调用状态："+statusCode);
            if (statusCode != 200) {
                throw new RuntimeException("Http Request StatusCode(" + statusCode + ") Invalid.");
            }

            // result
            bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
            StringBuilder result = new StringBuilder();
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                result.append(line);
            }
            String responseMsg = result.toString();

            XxlJobLogger.log(responseMsg);
        } catch (Exception e) {
            XxlJobLogger.log(e);
        } finally {
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }
                if (connection != null) {
                    connection.disconnect();
                }
            } catch (Exception e2) {
                XxlJobLogger.log(e2);
            }
        }
        
	}
    
     // 创建SSLContext对象，并使用我们指定的信任管理器初始化     
	 public static TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager() {
		    public java.security.cert.X509Certificate[] getAcceptedIssuers() {
		      return new java.security.cert.X509Certificate[]{};
		    }
		 
		    @Override
		    public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
		    }
		 
		    @Override
		    public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
		    }
	 }};

     
}

-----------------------------------下面使用HttpPost--------------------------

package com.common.helper;

import lombok.SneakyThrows;
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.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.util.EntityUtils;
import javax.net.ssl.SSLContext;
import java.io.IOException;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.security.cert.X509Certificate;
import java.util.HashMap;

public class HttpHelper {
    public static final String METHOD_GET = "get";
    public static final String METHOD_POST = "post";
    private static final String EncodeType = "UTF-8";

    private static HashMap<String, String> GetBaseHeaders() {
        HashMap<String, String> baseHaders = new HashMap<String, String>();
        baseHaders.put("accept", "*/*");
        baseHaders.put("connection", "Keep-Alive");
        baseHaders.put("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
        baseHaders.put("Content-Type", "application/json;charset=UTF-8");
        return baseHaders;
    }

    @SneakyThrows
    public static String Invoke(String url, String method, Object parameter, HashMap<String, String> headers) {
        LogHelper.PrintInfo("HTTP Input URL:" + url);
        LogHelper.PrintInfo("HTTP Input method:" + method);
        LogHelper.PrintInfo("HTTP Input parameter:" + JsonHelper.ToString(parameter));
        LogHelper.PrintInfo("HTTP Input headers:" + JsonHelper.ToString(headers));
        CloseableHttpClient client = null;
        CloseableHttpResponse response = null;
        String resultStr = "";
        try {
            client = HttpClients.createDefault();
            RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(60000).setSocketTimeout(60000).setConnectionRequestTimeout(60000).build();
            if (HttpHelper.METHOD_POST.equals(method)) {
                HttpPost httpPost = new HttpPost(url);
                if (headers != null) {
                    headers.forEach((k, v) -> {
                        httpPost.setHeader(k, v);
                    });
                }
                if (GetBaseHeaders() != null) {
                    GetBaseHeaders().forEach((k, v) -> {
                        httpPost.setHeader(k, v);
                    });
                }

                if (parameter != null) {
                    StringEntity bodyEntity = new StringEntity(JsonHelper.ToString(parameter), "utf-8");
                    httpPost.setEntity(bodyEntity);
                }
                httpPost.setConfig(requestConfig);
                client = createSkipSSLClient();
                response = client.execute(httpPost);
            } else {
                HttpGet httpGet = new HttpGet(url);
                if (headers != null) {
                    headers.forEach((k, v) -> {
                        httpGet.setHeader(k, v);
                    });
                }
                if (GetBaseHeaders() != null) {
                    GetBaseHeaders().forEach((k, v) -> {
                        httpGet.setHeader(k, v);
                    });
                }
                httpGet.setConfig(requestConfig);

                response = client.execute(httpGet);
            }
            resultStr = EntityUtils.toString(response.getEntity());
            LogHelper.PrintInfo("HTTP Output:" + resultStr);
        } catch (IOException e) {
            resultStr = "error-" + e.getMessage();
            e.printStackTrace();
        } finally {
            if (response != null) {
                response.close();
            }
            if (client != null) {
                client.close();
            }
        }
        return resultStr;
    }

    /**
     * 创建跳过SSL验证的HttpClient实例
     */
    public static CloseableHttpClient createSkipSSLClient() throws Exception {
        // 创建信任所有证书的TrustManager
        TrustManager[] trustAllCerts = new TrustManager[]{
                new X509TrustManager() {
                    @Override
                    public void checkClientTrusted(X509Certificate[] chain, String authType) {
                        // 空实现，信任所有客户端证书
                    }

                    @Override
                    public void checkServerTrusted(X509Certificate[] chain, String authType) {
                        // 空实现，信任所有服务器证书
                    }

                    @Override
                    public X509Certificate[] getAcceptedIssuers() {
                        return new X509Certificate[]{};
                    }
                }
        };
        // 初始化SSLContext
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, trustAllCerts, new java.security.SecureRandom());

        // 创建SSL连接工厂，不验证主机名
        SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(
                sslContext,
                NoopHostnameVerifier.INSTANCE
        );
        return HttpClients.custom()
                .setSSLSocketFactory(sslSocketFactory)
                .build();
    }
}