对接第三方校验身份证

最新推荐文章于 2024-12-29 23:54:44 发布
原创 最新推荐文章于 2024-12-29 23:54:44 发布 · 354 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#阿里云

对接阿里云

阿里云权益中心_助力学生、开发者、企业用云快速上云-阿里云

 

 

 

下载依赖

 


        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.15</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.2.1</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-util</artifactId>
            <version>9.3.7.v20160115</version>
        </dependency>

工具类 


package com.aliyun.api.gateway.demo.util;

import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class HttpUtils {

 /**
  * get
  *
  * @param host
  * @param path
  * @param method
  * @param headers
  * @param querys
  * @return
  * @throws Exception
  */
 public static HttpResponse doGet(String host, String path, String method,
                                  Map<String, String> headers,
                                  Map<String, String> querys)
         throws Exception {
  HttpClient httpClient = wrapClient(host);

  HttpGet request = new HttpGet(buildUrl(host, path, querys));
  for (Map.Entry<String, String> e : headers.entrySet()) {
   request.addHeader(e.getKey(), e.getValue());
  }

  return httpClient.execute(request);
 }

 /**
  * post form
  *
  * @param host
  * @param path
  * @param method
  * @param headers
  * @param querys
  * @param bodys
  * @return
  * @throws Exception
  */
 public static HttpResponse doPost(String host, String path, String method,
                                   Map<String, String> headers,
                                   Map<String, String> querys,
                                   Map<String, String> bodys)
         throws Exception {
  HttpClient httpClient = wrapClient(host);

  HttpPost request = new HttpPost(buildUrl(host, path, querys));
  for (Map.Entry<String, String> e : headers.entrySet()) {
   request.addHeader(e.getKey(), e.getValue());
  }

  if (bodys != null) {
   List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();

   for (String key : bodys.keySet()) {
    nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
   }
   UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
   formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
   request.setEntity(formEntity);
  }

  return httpClient.execute(request);
 }

 /**
  * Post String
  *
  * @param host
  * @param path
  * @param method
  * @param headers
  * @param querys
  * @param body
  * @return
  * @throws Exception
  */
 public static HttpResponse doPost(String host, String path, String method,
                                   Map<String, String> headers,
                                   Map<String, String> querys,
                                   String body)
         throws Exception {
  HttpClient httpClient = wrapClient(host);

  HttpPost request = new HttpPost(buildUrl(host, path, querys));
  for (Map.Entry<String, String> e : headers.entrySet()) {
   request.addHeader(e.getKey(), e.getValue());
  }

  if (StringUtils.isNotBlank(body)) {
   request.setEntity(new StringEntity(body, "utf-8"));
  }

  return httpClient.execute(request);
 }

 /**
  * Post stream
  *
  * @param host
  * @param path
  * @param method
  * @param headers
  * @param querys
  * @param body
  * @return
  * @throws Exception
  */
 public static HttpResponse doPost(String host, String path, String method,
                                   Map<String, String> headers,
                                   Map<String, String> querys,
                                   byte[] body)
         throws Exception {
  HttpClient httpClient = wrapClient(host);

  HttpPost request = new HttpPost(buildUrl(host, path, querys));
  for (Map.Entry<String, String> e : headers.entrySet()) {
   request.addHeader(e.getKey(), e.getValue());
  }

  if (body != null) {
   request.setEntity(new ByteArrayEntity(body));
  }

  return httpClient.execute(request);
 }

 /**
  * Put String
  * @param host
  * @param path
  * @param method
  * @param headers
  * @param querys
  * @param body
  * @return
  * @throws Exception
  */
 public static HttpResponse doPut(String host, String path, String method,
                                  Map<String, String> headers,
                                  Map<String, String> querys,
                                  String body)
         throws Exception {
  HttpClient httpClient = wrapClient(host);

  HttpPut request = new HttpPut(buildUrl(host, path, querys));
  for (Map.Entry<String, String> e : headers.entrySet()) {
   request.addHeader(e.getKey(), e.getValue());
  }

  if (StringUtils.isNotBlank(body)) {
   request.setEntity(new StringEntity(body, "utf-8"));
  }

  return httpClient.execute(request);
 }

 /**
  * Put stream
  * @param host
  * @param path
  * @param method
  * @param headers
  * @param querys
  * @param body
  * @return
  * @throws Exception
  */
 public static HttpResponse doPut(String host, String path, String method,
                                  Map<String, String> headers,
                                  Map<String, String> querys,
                                  byte[] body)
         throws Exception {
  HttpClient httpClient = wrapClient(host);

  HttpPut request = new HttpPut(buildUrl(host, path, querys));
  for (Map.Entry<String, String> e : headers.entrySet()) {
   request.addHeader(e.getKey(), e.getValue());
  }

  if (body != null) {
   request.setEntity(new ByteArrayEntity(body));
  }

  return httpClient.execute(request);
 }

 /**
  * Delete
  *
  * @param host
  * @param path
  * @param method
  * @param headers
  * @param querys
  * @return
  * @throws Exception
  */
 public static HttpResponse doDelete(String host, String path, String method,
                                     Map<String, String> headers,
                                     Map<String, String> querys)
         throws Exception {
  HttpClient httpClient = wrapClient(host);

  HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
  for (Map.Entry<String, String> e : headers.entrySet()) {
   request.addHeader(e.getKey(), e.getValue());
  }

  return httpClient.execute(request);
 }

 private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
  StringBuilder sbUrl = new StringBuilder();
  sbUrl.append(host);
  if (!StringUtils.isBlank(path)) {
   sbUrl.append(path);
  }
  if (null != querys) {
   StringBuilder sbQuery = new StringBuilder();
   for (Map.Entry<String, String> query : querys.entrySet()) {
    if (0 < sbQuery.length()) {
     sbQuery.append("&");
    }
    if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
     sbQuery.append(query.getValue());
    }
    if (!StringUtils.isBlank(query.getKey())) {
     sbQuery.append(query.getKey());
     if (!StringUtils.isBlank(query.getValue())) {
      sbQuery.append("=");
      sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
     }
    }
   }
   if (0 < sbQuery.length()) {
    sbUrl.append("?").append(sbQuery);
   }
  }

  return sbUrl.toString();
 }

 private static HttpClient wrapClient(String host) {
  HttpClient httpClient = new DefaultHttpClient();
  if (host.startsWith("https://")) {
   sslClient(httpClient);
  }

  return httpClient;
 }

 private static void sslClient(HttpClient httpClient) {
  try {
   SSLContext ctx = SSLContext.getInstance("TLS");
   X509TrustManager tm = new X509TrustManager() {
    public X509Certificate[] getAcceptedIssuers() {
     return null;
    }
    public void checkClientTrusted(X509Certificate[] xcs, String str) {

    }
    public void checkServerTrusted(X509Certificate[] xcs, String str) {

    }
   };
   ctx.init(null, new TrustManager[] { tm }, null);
   SSLSocketFactory ssf = new SSLSocketFactory(ctx);
   ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
   ClientConnectionManager ccm = httpClient.getConnectionManager();
   SchemeRegistry registry = ccm.getSchemeRegistry();
   registry.register(new Scheme("https", 443, ssf));
  } catch (KeyManagementException ex) {
   throw new RuntimeException(ex);
  } catch (NoSuchAlgorithmException ex) {
   throw new RuntimeException(ex);
  }
 }
}







import org.apache.http.HttpResponse;
import org.apache.http.util.EntityUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 
 * @date 2024/10/30
 * @apiNote
 */


public class CardUtil {

 public static String cardVerify(String name,String card){

  String host = "https://slysmrzgzl.market.alicloudapi.com";
  String path = "/get/idcard/checkV2";
  String method = "GET";
  String appcode = "输入自己的appcode";
  Map<String, String> headers = new HashMap<String, String>();
  //最后在header中的格式(中间是英文空格)为Authorization:APPCODE 83359fd73fe94948385f570e3c139105
  headers.put("Authorization", "APPCODE " + appcode);
  Map<String, String> querys = new HashMap<String, String>();
  querys.put("name", name);
  querys.put("idcard", card);


  try {
   /**
    * 重要提示如下:
    * HttpUtils请从
    * https://github.com/aliyun/api-gateway-demo-sign-java/blob/master/src/main/java/com/aliyun/api/gateway/demo/util/HttpUtils.java
    * 下载
    *
    * 相应的依赖请参照
    * https://github.com/aliyun/api-gateway-demo-sign-java/blob/master/pom.xml
    */
   HttpResponse response = com.aliyun.api.gateway.demo.util.HttpUtils.doGet(host, path, method, headers, querys);

   System.out.println(response.toString());
   String string = EntityUtils.toString(response.getEntity());
   return string;

  } catch (Exception e) {
   e.printStackTrace();
  }

  return "";
 }

}

调用方法 

    @GetMapping("/card")
    public AjaxResult card(@RequestParam String name, String card) {

        Integer a = null;

        String s = CardUtil.cardVerify(name, card);
        JSONObject jsonObject = JSONObject.parseObject(s);


        // 获取 data 字段的值
        JSONObject data = jsonObject.getJSONObject("data");

        // 获取 result 字段的值
        a = data.getInteger("result");


        return AjaxResult.success(a);
    }

注意：不同的公司可能提供不同的工具类

Java中的短信发送
weixin_46372265的博客
07-23 1194
大家好，我是城南。今天我们来深入探讨如何在Java中实现短信发送。无论是用于两步验证、实时警报还是聊天机器人，短信功能在现代应用程序中越来越重要。本文将通过简单明了的步骤，带你实现一个Java应用程序，能够发送短信。
【连连支付】PHP第三方连连支付对接
蹦哒哒的王小哲
10-13 3040
【连连支付】PHP第三方连连支付对接
Java发送短信
weixin_30570101的博客
08-30 234
1、接口使用介绍 发送短信肯定需要使用第三方接口，Java本身是肯定不能直接发送短信的。第三方接口有很多，这里直接找个正规靠谱一点的学习一下 这里使用了中国网建（http://sms.webchinese.cn/） 打开网址后，点击立刻注册体验 2、获取短信密钥 注册完成后，查看红色的短信秘钥。点击修改短信秘钥 这里记好短信秘钥，当然也可以修改短信秘钥 3、使用短信A...
java发送短信
weixin_34348174的博客
12-02 330
最近在做CRM的项目，先接触到的是发送短信。我是通过SMS平台来发送短信的，本人还是菜鸟，如果有说的不对的还望大家给予指正，先谢谢了。1.先到短信平台去注册用户2.注册成功后，到接口API下找到UID和KEY，可以进行修改。GBK编码发送接口地址：http://gbk.sms.webchinese.cn/?Uid=本站用户名&Key=接口安全密码&am...
第三方接口设计注意要点
最新发布
zhangyifang_009的博客
12-29 1180
实际工作中，我们会遇到与三方系统对接的情形，比如对接短信服务、支付服务、地图服务、以及一些外部业务系统的调用和回调等等，不论是我们调用第三方接口还是我们为其他系统提供接口服务，调用过程中会遇到一些大大小小的问题和吐槽的地方，比如接口不通对方可能有白名单限制、接口返回字段与文档不一致、接口不稳定等等，本文总结了一些在设计第三方接口过程中要考虑的到的点。
姓名+银行卡号核验，通过第三方供应商实现
qq_71314862的博客
05-15 735
在实际应用中，选择合适的供应商、正确配置API Key并合理处理验证结果，能够为用户提供安全、便捷的服务体验。首先，需要选择一家可信赖的第三方供应商，通常这些供应商会提供强大的API支持，包括银联、公安、运营商等。银行卡二要素验证指的是通过验证用户提供的银行卡号和姓名是否匹配，来确认用户身份。为了高效、可靠地实现银行卡二要素验证，接入第三方供应商的验证接口是一种常见且有效的方式。以下是详细的实现步骤。2. 调用验证接口：编写代码，通过API调用第三方供应商提供的银行卡二要素验证接口。略（需要代码可私聊）
电信集团ESS接口协议与第三方门户集成
“第三方门户”则指非电信直属的外部平台（如电商平台、政府服务平台、企业自建CRM系统等），这些平台需要与中国电信的后台系统对接以完成用户身份核验、号码开通、套餐变更等操作。“SIM”标签强调了该接口与用户...
身份证实名认证接口费用-身份证信息核验-实名认证示例
weixin_41711744的博客
09-09 875
身份证信息核验是实名认证中一种常见的认证方式，它通过比对用户提交的身份证信息与权威数据库中的信息，来确认用户身份是否真实有效，一般情况下，线上平台实现实名认证功能主要依赖于调用第三方接口​平台来实现。身份证实名认证的过程是当用户在网站或者应用上进行注册或者登录时，要求输入身份证号、姓名有的还需要提供证件人像和现场人像进行核验，如果信息匹配则返回成功的结果，如果信息不匹配，则返回不一致的结果。
java 发送短信
ChangKA的博客
05-29 568
用的是中国网建，需要注册 sendMsgUtf8调用的这个方法 参数分别为 账户 密钥 内容 手机号 package com.wisdombud.potevio.enterprise.web.util; import java.io.IOException; import java.net.URL; import java.util.ArrayList; import java...
利用java发送短信
qq_44970261的博客
09-16 2866
利用java发送短信
使用java发送短信
java算法篇---顺序表
11-16 222
java发送短信需要使用服务商提供的有偿接口，免费赠送五条 以阿里云为例： 1.注册阿里云会员 https://market.aliyun.com/products/56928004/cmapi022659.html?spm=5176.2020520132.101.5.TsClbR#sku=yuncode16659000011 使用到的pom依赖 &amp;lt;dependency&amp;gt; ...
Java发送手机短信
小菜鸟笔记
03-18 2213
该程序我使用的是中国网建SMS短信通来实现的，中国网建地址：http://sms.webchinese.cn/default.shtml 具体使用步骤： 1、注册一个账户 2、获取到key 3、查看相关的api，他提供发送短信的方式有gbk和utf8编码的方式 GBK与UTF-8的请求地址 GBK编码发送接口地址： http://gbk.sms.webchinese.
Java 发送短信功能
qq_52825290的博客
03-06 1648
关于postForObject()方法，相当于向某个地址发送信息。其中MessageRequestBean为请求短信对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值