UniApp + JAVA连接百度云ocr进行身份证识别

首先我们要去百度智能云-智能时代基础设施申请文字识别

然后创建应用

如果没有领取免费额度，先点击去领取，先领取免费额度

创建好了之后有API Key和Secret Key这之后要用到

先看官网给的API

 

有请求路径、请求头和请求参数 还有url参数

必填的项是url参数access_token,和请求参数image或者url和id_card_side

请求头Header中要把

Content-Type设置成application/x-www-form-urlencoded

headers:{
  'Content-Type':'application/x-www-form-urlencoded'
},

首先，我们要先获取access_token

https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=【百度云应用的AK】&client_secret=【百度云应用的SK】'

 请求上边路径填上你的AK和SK在返回值中找到你的access_token

https://ai.baidu.com/ai-doc/REFERENCE/Ck3dwjhhu这里还有别的方法获取

我写了两种识别的方法，一种是通过图片的路径进行识别，另一种是获取本地路径进行识别

方法一通过图片的路径进行识别

可以通过image和url进行数据传输，通过image传输的话要对图像进行base64编码和urlencode编码，咱们这里用到路径传输所以就不用对图片进行编码,要用到图片的完整链接

这是传入图片的完整路径，例如：www.xxx.com/aaa.jpg,

 public static String idcard(String url1) {
        // 请求url
        String url = "https://aip.baidubce.com/rest/2.0/ocr/v1/idcard";
        try {

            String param = "id_card_side=" + "front" + "&url=" + url1;

            // 注意这里仅为了简化编码每一次请求都去获取access_token，线上环境access_token有过期时间， 客户端可自行缓存，过期后重新获取。
            String accessToken = "通过Ak和Sk获取到的accessToken";

            //调用工具类发请求
            String result = HttpUtil.post(url, accessToken, param);
            System.out.println(result);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

这里发送请求的话用的是百度的HttpUtil工具类会放在文章的末尾

在前端发送请求和图片路径到后台

成功识别并返回

这种方法获取的是服务器的图片，如果服务器有反爬机制的话可能会出现请求图片失败

这是一些错误码

错误码	错误描述	HTTP状态码	中文解释
1	Unknown error	200	服务器内部错误，请再次请求，如果持续出现此类错误，请在控制台提交工单联系技术支持团队
2	Service temporarily unavailable	200	服务暂不可用，请再次请求，如果持续出现此类错误，请在控制台提交工单联系技术支持团队
3	Unsupported openapi method	200	调用的API不存在，请检查请求URL后重新尝试，一般为URL中有非英文字符，如"-"，可手动输入重试
4	Open api request limit reached	200	集群超限额，请再次请求，如果持续出现此类错误，请在控制台提交工单联系技术支持团队
6	No permission to access data	200	无权限访问该用户数据，创建应用时未勾选相关文字识别接口，请登录百度云控制台，找到对应的应用，编辑应用，勾选上相关接口后重新调用
14	IAM Certification failed	200	IAM鉴权失败，建议用户参照文档自查生成sign的方式是否正确，或换用控制台中ak sk的方式调用
17	Open api daily request limit reached	200	免费测试资源使用完毕，每天请求量超限额，已支持计费的接口，您可以在控制台文字识别服务选择购买相关接口的次数包或开通按量后付费；邀测和未支持计费的接口，您可以在控制台提交工单申请提升限额
18	Open api qps request limit reached	200	QPS超限额，免费额度并发限制为2QPS，开通按量后付费或购买次数包后并发限制为10QPS，如您需要更多的并发量，可以选择购买QPS叠加包；邀测和未支持计费的接口，您可以在控制台提交工单申请提升限额
19	Open api total request limit reached	200	请求总量超限额，已支持计费的接口，您可以在控制台文字识别服务选择购买相关接口的次数包或开通按量后付费；邀测和未支持计费的接口，您可以在控制台提交工单申请提升限额
100	Invalid parameter	200	无效的access_token参数，token拉取失败，您可以参考“Access Token获取”文档重新获取
110	Access token invalid or no longer valid	200	access_token无效，token有效期为30天，请注意需要定期更换，也可以每次请求都拉取新token
111	Access token expired	200	access token过期，token有效期为30天，请注意需要定期更换，也可以每次请求都拉取新token
216100	invalid param	200	请求中包含非法参数，请检查后重新尝试
216101	not enough param	200	缺少必须的参数，请检查参数是否有遗漏
216102	service not support	200	请求了不支持的服务，请检查调用的url
216103	param too long	200	请求中某些参数过长，请检查后重新尝试
216110	appid not exist	200	appid不存在，请重新核对信息是否为后台应用列表中的appid
216200	empty image	200	图片为空，请检查后重新尝试
216201	image format error	200	上传的图片格式错误，现阶段我们支持的图片格式为：PNG、JPG、JPEG、BMP，请进行转码或更换图片
216202	image size error	200	上传的图片大小错误，现阶段我们支持的图片大小为：base64编码后小于4M，分辨率不高于4096*4096，请重新上传图片
216202	input oversize	200	上传的包体积过大，现阶段不支持 10M 或以上的数据包
216630	recognize error	200	识别错误，请再次请求，请确保图片中包含对应卡证票据
216631	recognize bank card error	200	识别银行卡错误，出现此问题的原因一般为：您上传的图片非银行卡正面，上传了异形卡的图片、上传的银行卡正面图片不完整或模糊
216633	recognize idcard error	200	识别身份证错误，出现此问题的原因一般为：您上传了非身份证图片、上传的身份证图片不完整或模糊
216634	detect error	200	检测错误，请再次请求，如果持续出现此类错误，请在控制台提交工单联系技术支持团队
282000	internal error	200	服务器内部错误，如果您使用的是高精度接口，报这个错误码的原因可能是您上传的图片中文字过多，识别超时导致的，建议您对图片进行切割后再识别，其他情况请再次请求， 如果持续出现此类错误，请在控制台提交工单联系技术支持团队
282003	missing parameters: {参数名}	200	请求参数缺失
282005	batch processing error	200	处理批量任务时发生部分或全部错误，请根据具体错误码排查
282006	batch task limit reached	200	批量任务处理数量超出限制，请将任务数量减少到10或10以下
282100	image transcode error	200	图片压缩转码错误
282102	target detect error	200	未检测到图片中识别目标，请确保图片中包含对应卡证票据，出现此问题的原因一般为：您上传了非卡证图片、图片不完整或模糊
282103	target recognize error	200	图片目标识别错误，请确保图片中包含对应卡证票据，出现此问题的原因一般为：您上传了非卡证图片、图片不完整或模糊
282110	urls not exit	200	URL参数不存在，请核对URL后再次提交
282111	url format illegal	200	URL格式非法，请检查url格式是否符合相应接口的入参要求
282112	url download timeout	200	url下载超时，请检查url对应的图床/图片无法下载或链路状况不好，或图片大小大于3M，或图片存在防盗链，您可以重新尝试一下，如果多次尝试后仍不行，建议更换图片地址
282113	url response invalid	200	URL返回无效参数
282114	url size error	200	URL长度超过1024字节或为0
282808	request id: xxxxx not exist	200	request id xxxxx 不存在
282809	result type error	200	返回结果请求错误（不属于excel或json）
282810	image recognize error	200	图像识别错误，请再次请求，如果持续出现此类错误，请在控制台提交工单联系技术支持团队

 第二种方法获取本地路径图片

获取本地的图片的话我们需要用image传输，需要把图片进行base64和urlencode编码

调用方法传入参数，我这边演示就直接写路径了

这里用到了百度的几个工具类我放在了文章的末尾

这样直接调用就能返回身份证信息

public static String idcard(String filePath) {
        // 请求url
        String url = "https://aip.baidubce.com/rest/2.0/ocr/v1/idcard";
        try {
            // 本地文件路径
            //把这里的路径换成你的图片路径
            //这里的路径可以通过前端传 filePath
            //String filePath = filePath
            String filePath = "C:\\Users\\lenovo\\Desktop\\C$IO}TY3TIQG57[ST8F2X.png";
            //先读取文件转成byte数组
            byte[] imgData = FileUtil.readFileByBytes(filePath);
            //调用Base64Util工具类进行base64编码
            String imgStr = Base64Util.encode(imgData);
            //调用URLEncoder工具类进行urlencode编码
            String imgParam = URLEncoder.encode(imgStr, "UTF-8");

            //封装参数
            String param = "id_card_side=" + "front" + "&image=" + imgParam;

            // 注意这里仅为了简化编码每一次请求都去获取access_token，线上环境access_token有过期时间， 客户端可自行缓存，过期后重新获取。
            String accessToken = "你的access_token";

            //调用HttpUtil发送请求
            String result = HttpUtil.post(url, accessToken, param);
            System.out.println(result);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

工具类

Base64Util

/**
 * Base64 工具类
 */
public class Base64Util {
    private static final char last2byte = (char) Integer.parseInt("00000011", 2);
    private static final char last4byte = (char) Integer.parseInt("00001111", 2);
    private static final char last6byte = (char) Integer.parseInt("00111111", 2);
    private static final char lead6byte = (char) Integer.parseInt("11111100", 2);
    private static final char lead4byte = (char) Integer.parseInt("11110000", 2);
    private static final char lead2byte = (char) Integer.parseInt("11000000", 2);
    private static final char[] encodeTable = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};

    public Base64Util() {
    }

    public static String encode(byte[] from) {
        StringBuilder to = new StringBuilder((int) ((double) from.length * 1.34D) + 3);
        int num = 0;
        char currentByte = 0;

        int i;
        for (i = 0; i < from.length; ++i) {
            for (num %= 8; num < 8; num += 6) {
                switch (num) {
                    case 0:
                        currentByte = (char) (from[i] & lead6byte);
                        currentByte = (char) (currentByte >>> 2);
                    case 1:
                    case 3:
                    case 5:
                    default:
                        break;
                    case 2:
                        currentByte = (char) (from[i] & last6byte);
                        break;
                    case 4:
                        currentByte = (char) (from[i] & last4byte);
                        currentByte = (char) (currentByte << 2);
                        if (i + 1 < from.length) {
                            currentByte = (char) (currentByte | (from[i + 1] & lead2byte) >>> 6);
                        }
                        break;
                    case 6:
                        currentByte = (char) (from[i] & last2byte);
                        currentByte = (char) (currentByte << 4);
                        if (i + 1 < from.length) {
                            currentByte = (char) (currentByte | (from[i + 1] & lead4byte) >>> 4);
                        }
                }

                to.append(encodeTable[currentByte]);
            }
        }

        if (to.length() % 4 != 0) {
            for (i = 4 - to.length() % 4; i > 0; --i) {
                to.append("=");
            }
        }

        return to.toString();
    }
}

HttpUtil

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.List;
import java.util.Map;

/**
 * http 工具类
 */
public class HttpUtil {

    public static String post(String requestUrl, String accessToken, String params)
            throws Exception {
        String contentType = "application/x-www-form-urlencoded";
        return HttpUtil.post(requestUrl, accessToken, contentType, params);
    }

    public static String post(String requestUrl, String accessToken, String contentType, String params)
            throws Exception {
        String encoding = "UTF-8";
        if (requestUrl.contains("nlp")) {
            encoding = "GBK";
        }
        return HttpUtil.post(requestUrl, accessToken, contentType, params, encoding);
    }

    public static String post(String requestUrl, String accessToken, String contentType, String params, String encoding)
            throws Exception {
        String url = requestUrl + "?access_token=" + accessToken;
        return HttpUtil.postGeneralUrl(url, contentType, params, encoding);
    }

    public static String postGeneralUrl(String generalUrl, String contentType, String params, String encoding)
            throws Exception {
        URL url = new URL(generalUrl);
        // 打开和URL之间的连接
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("POST");
        // 设置通用的请求属性
        connection.setRequestProperty("Content-Type", contentType);
        connection.setRequestProperty("Connection", "Keep-Alive");
        connection.setUseCaches(false);
        connection.setDoOutput(true);
        connection.setDoInput(true);

        // 得到请求的输出流对象
        DataOutputStream out = new DataOutputStream(connection.getOutputStream());
        out.write(params.getBytes(encoding));
        out.flush();
        out.close();

        // 建立实际的连接
        connection.connect();
        // 获取所有响应头字段
        Map> headers = connection.getHeaderFields();
        // 遍历所有的响应头字段
        for (String key : headers.keySet()) {
            System.err.println(key + "--->" + headers.get(key));
        }
        // 定义 BufferedReader输入流来读取URL的响应
        BufferedReader in = null;
        in = new BufferedReader(
                new InputStreamReader(connection.getInputStream(), encoding));
        String result = "";
        String getLine;
        while ((getLine = in.readLine()) != null) {
            result += getLine;
        }
        in.close();
        System.err.println("result:" + result);
        return result;
    }
}

FileUtil

import java.io.*;

/**
 * 文件读取工具类
 */
public class FileUtil {

    /**
     * 读取文件内容，作为字符串返回
     */
    public static String readFileAsString(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            throw new FileNotFoundException(filePath);
        }

        if (file.length() > 1024 * 1024 * 1024) {
            throw new IOException("File is too large");
        }

        StringBuilder sb = new StringBuilder((int) (file.length()));
        // 创建字节输入流
        FileInputStream fis = new FileInputStream(filePath);
        // 创建一个长度为10240的Buffer
        byte[] bbuf = new byte[10240];
        // 用于保存实际读取的字节数
        int hasRead = 0;
        while ( (hasRead = fis.read(bbuf)) > 0 ) {
            sb.append(new String(bbuf, 0, hasRead));
        }
        fis.close();
        return sb.toString();
    }

    /**
     * 根据文件路径读取byte[] 数组
     */
    public static byte[] readFileByBytes(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            throw new FileNotFoundException(filePath);
        } else {
            ByteArrayOutputStream bos = new ByteArrayOutputStream((int) file.length());
            BufferedInputStream in = null;

            try {
                in = new BufferedInputStream(new FileInputStream(file));
                short bufSize = 1024;
                byte[] buffer = new byte[bufSize];
                int len1;
                while (-1 != (len1 = in.read(buffer, 0, bufSize))) {
                    bos.write(buffer, 0, len1);
                }

                byte[] var7 = bos.toByteArray();
                return var7;
            } finally {
                try {
                    if (in != null) {
                        in.close();
                    }
                } catch (IOException var14) {
                    var14.printStackTrace();
                }

                bos.close();
            }
        }
    }
}