• Java集成腾讯云OCR身份证识别接口

    一、背景

            项目用到身份证识别获取人员信息的功能，于是想到了腾讯云提供这样的API。在整合代码过程都很顺利，利用腾讯云官方SDK很快集成进来。但是在上测试环境部署时有了新的问题，通过Nginx代理后的环境无法访问到目标腾讯云接口，遂有了如下的改造过程。

    二、SDK集成Demo

            首先是Maven依赖树：

    1.         <dependency>
    2.             <groupId>com.tencentcloudapigroupId>
    3.             <artifactId>tencentcloud-sdk-javaartifactId>
    4.             <version>4.0.11version>
    5.         dependency>

            然后是腾讯云提供的调试代码，改造了一部分：

    1. import com.tencentcloudapi.common.Credential;
    2. import com.tencentcloudapi.common.exception.TencentCloudSDKException;
    3. import com.tencentcloudapi.common.profile.ClientProfile;
    4. import com.tencentcloudapi.common.profile.HttpProfile;
    5. import com.tencentcloudapi.ocr.v20181119.OcrClient;
    6. import com.tencentcloudapi.ocr.v20181119.models.IDCardOCRRequest;
    7. import com.tencentcloudapi.ocr.v20181119.models.IDCardOCRResponse;
    8. import lombok.extern.slf4j.Slf4j;
    9. import org.springframework.beans.factory.annotation.Value;
    10. import org.springframework.context.annotation.PropertySource;
    11. import org.springframework.stereotype.Component;
    12.  
    13. import java.text.ParseException;
    14.  
    15. @Component
    16. @Slf4j
    17. @PropertySource("classpath:/properties/tencentCard.properties")
    18. public class TencentUtil {
    19.  
    20.     @Value("${secretId}")
    21.     private String secretId;
    22.  
    23.     @Value("${secretKey}")
    24.     private String secretKey;
    25.  
    26.     @Value("${tencentUrl}")
    27.     private String tencentUrl;
    28.  
    29.  
    30.     public RecognitionView recognition(String cBase64) {
    31.         if (cBase64.length() > 10485760) {
    32.             throw new BusinessException("证件识别失败：图片文件太大");
    33.         }
    34.         RecognitionView tRecognitionView = new RecognitionView();
    35.         try{
    36.             // 实例化一个认证对象，入参需要传入腾讯云账户 SecretId 和 SecretKey，此处还需注意密钥对的保密
    37.             // 代码泄露可能会导致 SecretId 和 SecretKey 泄露，并威胁账号下所有资源的安全性。以下代码示例仅供参考，建议采用更安全的方式来使用密钥，请参见：https://cloud.tencent.com/document/product/1278/85305
    38.             // 密钥可前往官网控制台 https://console.cloud.tencent.com/cam/capi 进行获取
    39.             Credential cred = new Credential(secretId, secretKey);
    40.             // 实例化一个http选项，可选的，没有特殊需求可以跳过
    41.             HttpProfile httpProfile = new HttpProfile();
    42.             httpProfile.setEndpoint(tencentUrl);
    43.             // 实例化一个client选项，可选的，没有特殊需求可以跳过
    44.             ClientProfile clientProfile = new ClientProfile();
    45.             clientProfile.setHttpProfile(httpProfile);
    46.             // 实例化要请求产品的client对象,clientProfile是可选的
    47.             OcrClient client = new OcrClient(cred, "ap-beijing", clientProfile);
    48.             // 实例化一个请求对象,每个接口都会对应一个request对象
    49.             IDCardOCRRequest req = new IDCardOCRRequest();
    50.             req.setImageBase64(cBase64);
    51.             // 返回的resp是一个IDCardOCRResponse的实例，与请求对象对应
    52.             IDCardOCRResponse resp = client.IDCardOCR(req);
    53.             tRecognitionView.setRecognitionView(resp);
    54.             // 输出json格式的字符串回包
    55.             log.info("证件识别返回参数：" + IDCardOCRResponse.toJsonString(resp));
    56.         } catch (Exception e) {
    57.             String tError = "证件识别失败：" + e.getMessage();
    58.             log.error(tError);
    59.             throw new BusinessException(tError);
    60.         }
    61.         return tRecognitionView;
    62.     }
    63.  
    64. }

            postman调试后可以正常获取到解析内容

    三、Nginx调用失败及解决

            部署到测试环境后，由于内网服务器需要代理到外网服务器进行外网地址的访问，此时便提示证书找不到的错误。

            找问题的过程很坎坷，从证书的有效性、代理的连通性、SDK的限制性等等，研究了将近三天，就连做梦都在思考哪里有问题。最后实在没了方向，决定从根上入手，跳过证书验证。

            跳过验证分为两步，1、放弃SDK请求方式，需要手写Connection；2、增加跳过证书的代码逻辑。于是便有了如下代码：

    1. import com.alibaba.fastjson.JSON;
    2. import com.google.gson.Gson;
    3. import com.google.gson.reflect.TypeToken;
    4. import com.tencentcloudapi.common.Credential;
    5. import com.tencentcloudapi.common.JsonResponseModel;
    6. import com.tencentcloudapi.common.profile.ClientProfile;
    7. import com.tencentcloudapi.common.profile.HttpProfile;
    8. import com.tencentcloudapi.ocr.v20181119.OcrClient;
    9. import com.tencentcloudapi.ocr.v20181119.models.IDCardOCRRequest;
    10. import com.tencentcloudapi.ocr.v20181119.models.IDCardOCRResponse;
    11. import lombok.extern.slf4j.Slf4j;
    12. import okhttp3.*;
    13. import org.apache.commons.codec.binary.Base64;
    14. import org.springframework.beans.factory.annotation.Value;
    15. import org.springframework.context.annotation.PropertySource;
    16. import org.springframework.stereotype.Component;
    17.  
    18. import javax.crypto.Mac;
    19. import javax.crypto.spec.SecretKeySpec;
    20. import javax.xml.bind.DatatypeConverter;
    21. import java.lang.reflect.Type;
    22. import java.nio.charset.Charset;
    23. import java.nio.charset.StandardCharsets;
    24. import java.security.MessageDigest;
    25. import java.text.SimpleDateFormat;
    26. import java.util.*;
    27.  
    28. @Component
    29. @Slf4j
    30. @PropertySource("classpath:/properties/tencentCard.properties")
    31. public class TencentUtil {
    32.  
    33.     @Value("${secretId}")
    34.     private String secretId;
    35.  
    36.     @Value("${secretKey}")
    37.     private String secretKey;
    38.  
    39.     @Value("${tencentUrl}")
    40.     private String tencentUrl;
    41.  
    42.     private final static String CT_JSON = "application/json; charset=utf-8"; // 请求头内容类型
    43.     private final static Charset UTF8 = StandardCharsets.UTF_8; // 编码格式
    44.     static final OkHttpClient HTTP_CLIENT = new SslUtils().getUnsafeOkHttpClient();
    45.  
    46.     public RecognitionView recognitionPassSSL(byte[] cbyte) {
    47.         String ImageBase64 = Base64.encodeBase64String(cbyte);
    48.         Map tRequest = new HashMap<>();
    49.         tRequest.put("ImageBase64", ImageBase64);
    50.         String requestData = JSON.toJSONString(tRequest);
    51.         RecognitionView tRecognitionView = new RecognitionView();
    52.         try {
    53.             MediaType mediaType = MediaType.parse(CT_JSON);
    54.             RequestBody body = RequestBody.create(mediaType, requestData);
    55.             Request.Builder tBuilder = new Request.Builder()
    56.                     .url("https://" + tencentUrl)
    57.                     .method("POST", body);
    58.             this.assembleHeader(tBuilder,this.sign(requestData));
    59.             Request request = tBuilder.build();
    60.             Response response = HTTP_CLIENT.newCall(request).execute();
    61.             String tResult = response.body().string();
    62.             Gson gson = new Gson();
    63.             log.info("证件识别返回参数：" + tResult);
    64.             if (tResult.contains("Error")) {
    65.                 //{"Response":{"RequestId":"4dd26ba4-3e0e-412b-b5a3-047829d5541f","Error":{"Code":"FailedOperation.ImageNoIdCard","Message":"照片未检测到身份证"}}}
    66.                 JsonResponseModel resp = JSON.parseObject(tResult,JsonResponseModel.class);
    67.                 TencentErrorView tTencentErrorView = JSON.parseObject(JSON.toJSONString(resp.response),TencentErrorView.class);
    68.                 throw new BusinessException(tTencentErrorView.getError().getMessage());
    69.             } else {
    70.                 //{"name": "吕能仕","id": "362323194911046513","nation": "汉","sex": "男","birthDay": "1949-11-04","address": "江西省上饶市玉山县四股桥乡丁村村喻村4号","age_unit": "岁","age_value": "73"}
    71.                 Type type = new TypeToken>() {}.getType();
    72.                 JsonResponseModel resp = gson.fromJson(tResult, type);
    73.                 tRecognitionView.setRecognitionView(resp.response);
    74.             }
    75.         } catch (Exception e) {
    76.             String tError = "证件识别失败：" + e.getMessage();
    77.             log.error(tError);
    78.             throw new BusinessException(tError);
    79.         }
    80.         return tRecognitionView;
    81.     }
    82.  
    83.     private void assembleHeader(Request.Builder tBuilder, Map sign) {
    84.         Set strings = sign.keySet();
    85.         for (String tName : strings) {
    86.             tBuilder.addHeader(tName, sign.get(tName));
    87.         }
    88.     }
    89.  
    90.     public RecognitionView recognition(byte[] cbyte) {
    91.         String tBase64 = Base64.encodeBase64String(cbyte);
    92.         RecognitionView tRecognitionView = new RecognitionView();
    93.         try {
    94.             // 实例化一个认证对象，入参需要传入腾讯云账户 SecretId 和 SecretKey，此处还需注意密钥对的保密
    95.             // 代码泄露可能会导致 SecretId 和 SecretKey 泄露，并威胁账号下所有资源的安全性。以下代码示例仅供参考，建议采用更安全的方式来使用密钥，请参见：https://cloud.tencent.com/document/product/1278/85305
    96.             // 密钥可前往官网控制台 https://console.cloud.tencent.com/cam/capi 进行获取
    97.             Credential cred = new Credential(secretId, secretKey);
    98.             // 实例化一个http选项，可选的，没有特殊需求可以跳过
    99.             HttpProfile httpProfile = new HttpProfile();
    100.             httpProfile.setEndpoint(tencentUrl);
    101.             // 实例化一个client选项，可选的，没有特殊需求可以跳过
    102.             ClientProfile clientProfile = new ClientProfile();
    103.             clientProfile.setHttpProfile(httpProfile);
    104.             // 实例化要请求产品的client对象,clientProfile是可选的
    105.             OcrClient client = new OcrClient(cred, "ap-beijing", clientProfile);
    106.             // 实例化一个请求对象,每个接口都会对应一个request对象
    107.             IDCardOCRRequest req = new IDCardOCRRequest();
    108.             req.setImageBase64(tBase64);
    109.             // 返回的resp是一个IDCardOCRResponse的实例，与请求对象对应
    110.             IDCardOCRResponse resp = client.IDCardOCR(req);
    111.             tRecognitionView.setRecognitionView(resp);
    112.             // 输出json格式的字符串回包
    113.             log.info("证件识别返回参数：" + IDCardOCRResponse.toJsonString(resp));
    114.         } catch (Exception e) {
    115.             String tError = "证件识别失败：" + e.getMessage();
    116.             log.error(tError);
    117.             throw new BusinessException(tError);
    118.         }
    119.         return tRecognitionView;
    120.     }
    121.  
    122.  
    123.     /**
    124.      * API签名方法
    125.      * @param data 发送的json串数据
    126.      * @return 请求头map
    127.      * @throws Exception 异常
    128.      */
    129.     @SuppressWarnings({"JsonStandardCompliance", "DuplicatedCode"})
    130.     private Map sign(String data) throws Exception {
    131.         String service = "ocr"; // 腾讯云服务器
    132.         String host = "ocr.tencentcloudapi.com"; // 服务器地址
    133.         String region = "ap-beijing"; // 服务器区域
    134.         String action = "IDCardOCR"; // api接口名称
    135.         String version = "2018-11-19"; // 接口版本号
    136.         String algorithm = "TC3-HMAC-SHA256";
    137.         // String timestamp = "1551113065";
    138.         String timestamp = String.valueOf(System.currentTimeMillis() / 1000); // 时间戳
    139.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    140.         // 注意时区，否则容易出错
    141.         sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
    142.         String date = sdf.format(new Date(Long.valueOf(timestamp + "000")));
    143.  
    144.         // ************* 步骤 1：拼接规范请求串 *************
    145.         String httpRequestMethod = "POST"; // 请求方法
    146.         String canonicalUri = "/";
    147.         String canonicalQueryString = "";
    148.         String canonicalHeaders = "content-type:application/json; charset=utf-8\n" + "host:" + host + "\n"; // 请求头信息
    149.         String signedHeaders = "content-type;host"; // 签名头包含内容
    150.  
    151.         String payload = data; // 请求内容
    152.         String hashedRequestPayload = sha256Hex(payload);
    153.         String canonicalRequest = httpRequestMethod + "\n" + canonicalUri + "\n" + canonicalQueryString + "\n"
    154.                 + canonicalHeaders + "\n" + signedHeaders + "\n" + hashedRequestPayload;
    155.  
    156.         // ************* 步骤 2：拼接待签名字符串 *************
    157.         String credentialScope = date + "/" + service + "/" + "tc3_request";
    158.         String hashedCanonicalRequest = sha256Hex(canonicalRequest);
    159.         String stringToSign = algorithm + "\n" + timestamp + "\n" + credentialScope + "\n" + hashedCanonicalRequest;
    160.  
    161.         // ************* 步骤 3：计算签名 *************
    162.         byte[] secretDate = hmac256(("TC3" + secretKey).getBytes(UTF8), date);
    163.         byte[] secretService = hmac256(secretDate, service);
    164.         byte[] secretSigning = hmac256(secretService, "tc3_request");
    165.         String signature = DatatypeConverter.printHexBinary(hmac256(secretSigning, stringToSign)).toLowerCase();
    166.  
    167.         // ************* 步骤 4：拼接 Authorization *************
    168.         String authorization = algorithm + " " + "Credential=" + secretId + "/" + credentialScope + ", "
    169.                 + "SignedHeaders=" + signedHeaders + ", " + "Signature=" + signature;
    170.  
    171.         TreeMap headers = new TreeMap();
    172.         headers.put("Authorization", authorization);
    173.         headers.put("Content-Type", CT_JSON);
    174.         headers.put("Host", host);
    175.         headers.put("X-TC-Action", action);
    176.         headers.put("X-TC-Timestamp", timestamp);
    177.         headers.put("X-TC-Version", version);
    178.         headers.put("X-TC-Region", region);
    179.         return headers;
    180.     }
    181.  
    182.     private static byte[] hmac256(byte[] key, String msg) throws Exception {
    183.         Mac mac = Mac.getInstance("HmacSHA256");
    184.         SecretKeySpec secretKeySpec = new SecretKeySpec(key, mac.getAlgorithm());
    185.         mac.init(secretKeySpec);
    186.         return mac.doFinal(msg.getBytes(UTF8));
    187.     }
    188.  
    189.     private static String sha256Hex(String s) throws Exception {
    190.         MessageDigest md = MessageDigest.getInstance("SHA-256");
    191.         byte[] d = md.digest(s.getBytes(UTF8));
    192.         return DatatypeConverter.printHexBinary(d).toLowerCase();
    193.     }
    194. }

    最关键的就是忽略https验证，建议收藏！！

    1. import cn.hutool.http.HttpRequest;
    2. import cn.hutool.http.Method;
    3. import okhttp3.OkHttpClient;
    4. import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
    5. import org.apache.http.impl.client.CloseableHttpClient;
    6. import org.apache.http.impl.client.HttpClientBuilder;
    7. import org.apache.http.impl.client.HttpClients;
    8. import org.apache.http.util.TextUtils;
    9. import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
    10. import org.springframework.http.converter.StringHttpMessageConverter;
    11. import org.springframework.web.client.RestTemplate;
    12.  
    13. import javax.net.ssl.*;
    14. import java.nio.charset.StandardCharsets;
    15. import java.security.cert.CertificateException;
    16. import java.security.cert.X509Certificate;
    17. import java.util.Arrays;
    18. import java.util.concurrent.TimeUnit;
    19.  
    20. @SuppressWarnings({"Convert2Lambda"})
    21. public class SslUtils {
    22.  
    23.     private static void trustAllHttpsCertificates() throws Exception {
    24.         javax.net.ssl.TrustManager[] trustAllCerts = new javax.net.ssl.TrustManager[1];
    25.         javax.net.ssl.TrustManager tm = new miTM();
    26.         trustAllCerts[0] = tm;
    27.         SSLContext sc = SSLContext.getInstance("SSL");
    28.         sc.init(null, trustAllCerts, null);
    29.         javax.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
    30.     }
    31.  
    32.     @SuppressWarnings({"unused", "RedundantThrows"})
    33.     static class miTM implements javax.net.ssl.TrustManager, javax.net.ssl.X509TrustManager {
    34.         public X509Certificate[] getAcceptedIssuers() {
    35.             return null;
    36.         }
    37.  
    38.         public boolean isServerTrusted(X509Certificate[] certs) {
    39.             return true;
    40.         }
    41.  
    42.         public boolean isClientTrusted(X509Certificate[] certs) {
    43.             return true;
    44.         }
    45.  
    46.  
    47.         public void checkServerTrusted(X509Certificate[] certs, String authType)
    48.                 throws java.security.cert.CertificateException {
    49.         }
    50.  
    51.  
    52.         public void checkClientTrusted(X509Certificate[] certs, String authType)
    53.                 throws java.security.cert.CertificateException {
    54.         }
    55.     }
    56.  
    57.  
    58.     /**
    59.      * 忽略SSL证书校验
    60.      * @throws Exception e
    61.      */
    62.     public static void ignoreSsl() throws Exception {
    63.         javax.net.ssl.HostnameVerifier hv = new javax.net.ssl.HostnameVerifier() {
    64.             public boolean verify(String urlHostName, javax.net.ssl.SSLSession session) {
    65.                 return true;
    66.             }
    67.         };
    68.         trustAllHttpsCertificates();
    69.         javax.net.ssl.HttpsURLConnection.setDefaultHostnameVerifier(hv);
    70.     }
    71.  
    72.     /**
    73.      * Created with IDEA
    74.      * Author: www.itze.cn
    75.      * Date: 2021-02-24
    76.      * Email：gitlab@111.com
    77.      * okhttp忽略所有SSL证书认证
    78.      *
    79.      * @return
    80.      */
    81.     public OkHttpClient getUnsafeOkHttpClient() {
    82.         try {
    83.             final TrustManager[] trustAllCerts = new TrustManager[]{
    84.                     new X509TrustManager() {
    85.                         @Override
    86.                         public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) {
    87.                         }
    88.  
    89.                         @Override
    90.                         public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) {
    91.                         }
    92.  
    93.                         @Override
    94.                         public java.security.cert.X509Certificate[] getAcceptedIssuers() {
    95.                             return new java.security.cert.X509Certificate[]{};
    96.                         }
    97.                     }
    98.             };
    99.             final SSLContext sslContext = SSLContext.getInstance("SSL");
    100.             sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
    101.             final javax.net.ssl.SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
    102.             OkHttpClient.Builder builder = new OkHttpClient.Builder();
    103.             builder.sslSocketFactory(sslSocketFactory, (X509TrustManager) (trustAllCerts[0]));
    104.             builder.hostnameVerifier(new HostnameVerifier() {
    105.                 //这里存放不需要忽略SSL证书的域名，为空即忽略所有证书
    106.                 String[] ssls = {};
    107.  
    108.                 @Override
    109.                 public boolean verify(String hostname, SSLSession session) {
    110.                     if (TextUtils.isEmpty(hostname)) {
    111.                         return false;
    112.                     }
    113.                     return !Arrays.asList(ssls).contains(hostname);
    114.                 }
    115.             });
    116.  
    117.             OkHttpClient okHttpClient = builder.connectTimeout(10, TimeUnit.MINUTES).
    118.                     writeTimeout(10, TimeUnit.MINUTES).readTimeout(10, TimeUnit.MINUTES).retryOnConnectionFailure(true).build();
    119.             return okHttpClient;
    120.         } catch (Exception e) {
    121.             throw new RuntimeException(e);
    122.         }
    123.     }
    124.  
    125.  
    126.     /**
    127.      * 跳过证书效验的sslcontext
    128.      *
    129.      * @return
    130.      * @throws Exception
    131.      */
    132.     private static SSLContext createIgnoreVerifySSL() throws Exception {
    133.         SSLContext sc = SSLContext.getInstance("TLS");
    134.  
    135.         // 实现一个X509TrustManager接口，用于绕过验证，不用修改里面的方法
    136.         X509TrustManager trustManager = new X509TrustManager() {
    137.             @Override
    138.             public void checkClientTrusted(java.security.cert.X509Certificate[] paramArrayOfX509Certificate,
    139.                                            String paramString) throws CertificateException {
    140.             }
    141.  
    142.             @Override
    143.             public void checkServerTrusted(java.security.cert.X509Certificate[] paramArrayOfX509Certificate,
    144.                                            String paramString) throws CertificateException {
    145.             }
    146.  
    147.             @Override
    148.             public java.security.cert.X509Certificate[] getAcceptedIssuers() {
    149.                 return null;
    150.             }
    151.         };
    152.         sc.init(null, new TrustManager[] { trustManager }, null);
    153.         return sc;
    154.     }
    155.  
    156.     /**
    157.      * 构造RestTemplate
    158.      *
    159.      * @return
    160.      * @throws Exception
    161.      */
    162.     public static RestTemplate getIgnoreSslRestTemplate() throws Exception {
    163.         HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
    164.         // 超时
    165.         factory.setConnectionRequestTimeout(5000);
    166.         factory.setConnectTimeout(5000);
    167.         factory.setReadTimeout(5000);
    168.         SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(createIgnoreVerifySSL(),
    169.                 // 指定TLS版本
    170.                 null,
    171.                 // 指定算法
    172.                 null,
    173.                 // 取消域名验证
    174.                 new HostnameVerifier() {
    175.                     @Override
    176.                     public boolean verify(String string, SSLSession ssls) {
    177.                         return true;
    178.                     }
    179.                 });
    180.         CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
    181.         factory.setHttpClient(httpClient);
    182.         RestTemplate restTemplate = new RestTemplate(factory);
    183.         // 解决中文乱码问题
    184.         restTemplate.getMessageConverters().set(1, new StringHttpMessageConverter(StandardCharsets.UTF_8));
    185.         return restTemplate;
    186.     }
    187.  
    188.     /**
    189.      * 构造HttpClientBuilder
    190.      *
    191.      * @return
    192.      * @throws Exception
    193.      */
    194.     public static HttpClientBuilder getIgnoreSslHttpClientBuilder() throws Exception {
    195.         HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
    196.         // 超时
    197.         factory.setConnectionRequestTimeout(5000);
    198.         factory.setConnectTimeout(5000);
    199.         factory.setReadTimeout(5000);
    200.         SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(createIgnoreVerifySSL(),
    201.                 // 指定TLS版本
    202.                 null,
    203.                 // 指定算法
    204.                 null,
    205.                 // 取消域名验证
    206.                 new HostnameVerifier() {
    207.                     @Override
    208.                     public boolean verify(String string, SSLSession ssls) {
    209.                         return true;
    210.                     }
    211.                 });
    212.         HttpClientBuilder httpClientBuilder = HttpClients.custom().setSSLSocketFactory(sslsf);
    213.         return httpClientBuilder;
    214.     }
    215.  
    216.     /**
    217.      * 构造HttpRequest hu
    218.      *
    219.      * @return
    220.      * @throws Exception
    221.      */
    222.     public static HttpRequest getIgnoreSslHttpRequest(String url,Method cMethod) throws Exception {
    223.         HttpRequest tHttpRequest = new HttpRequest(url);
    224.         tHttpRequest.setMethod(cMethod);
    225.         return tHttpRequest.setSSLSocketFactory(createIgnoreVerifySSL().getSocketFactory());
    226.     }
    227.  
    228. }

    四、总结

            经过验证，该方式可以访问经过Nginx代理的腾讯云接口。整个解决过程缺少对问题现状的分析，并没有制定切入点，而是想到哪里改哪里，所以修改的过程异常煎熬。

            后续对于问题的挖掘及解决要整体分析然后列出各个怀疑的情况和解决方案，然后对照着清单逐一排查，如此条理清晰的处理过程才会更有效的解决问题。

    2023-12-12 更新：SslUtils工具类增加多种跳过SSL证书验证逻辑

  • 相关阅读:
    iOS开发：多线程之理解任务和队列
    C#入门（11）：泛型介绍
    实验室LIMS管理系统能够解决那些企业难题
    RFSoC应用笔记 - RF数据转换器 -08- RFSoC关键配置之RF-DAC内部解析（二）
    替代MySQL半同步复制，Meta技术团队推出MySQL Raft共识引擎
    C++ Reference: Standard C++ Library reference: C Library: cwchar: vwprintf
    CUDA优化reduce
    ES中的三种查询
    C#列表List的创建与使用
    交换机基本配置(switch)--华为-思科
  • 原文地址：https://blog.csdn.net/AikesLs/article/details/134080623