uniapp 身份证识别 微信 百度 图片前端压缩 图片后端压缩

微信：

下面注释代码 HBuilder调试OK 发布微信调试失败 不知所以 
                var ocrUrl = "https://api.weixin.qq.com/cv/ocr/idcard?img_url=" + self.imgUrl + "&access_token=" + self.token;
                wx.chooseImage({
                        sourceType: ['camera'], // 可以指定来源是相册还是相机，默认二者都有
                        const tempFilePaths = res.tempFilePaths
                        wx.uploadFile({
                            url: ocrUrl,
                            filePath: tempFilePaths[0],
                            name: 'img',
                            formData: {
                                contentType: 'image/png',
                                value: "",
                            },
                            success(res) {
                                const data = JSON.parse(res.data);
                                if (data.errcode != 0) {
                                    self.$api.alert("识别失败！");
                                }
                                self.name = data.name;
                                self.idNo = data.id;
                                if (numberUtils.identityCodeValid(self.idNo.trim())) {
                                    self.age = self.getAge(self.idNo.trim());
                                }
                                if (data.gender == '男') {
                                    self.current = 0;
                                } else {
                                    self.current = 1;
                                }
                            },
                            fail(res) {
                                self.$api.alert("识别失败！");
                            },
                        })

前端  转byte64 压缩  /components/image-tools/index.js

function getLocalFilePath(path) {
    if (path.indexOf('_www') === 0 || path.indexOf('_doc') === 0 || path.indexOf('_documents') === 0 || path.indexOf('_downloads') === 0) {
        return path
    }
    if (path.indexOf('file://') === 0) {
        return path
    }
    if (path.indexOf('/storage/emulated/0/') === 0) {
        return path
    }
    if (path.indexOf('/') === 0) {
        var localFilePath = plus.io.convertAbsoluteFileSystem(path)
        if (localFilePath !== path) {
            return localFilePath
        } else {
            path = path.substr(1)
        }
    }
    return '_www/' + path
}

var index = 0
function getNewFileId() {
    return Date.now() + String(index++)
}

function biggerThan(v1, v2) {
    var v1Array = v1.split('.')
    var v2Array = v2.split('.')
    var update = false
    for (var index = 0; index < v2Array.length; index++) {
        var diff = v1Array[index] - v2Array[index]
        if (diff !== 0) {
            update = diff > 0
            break
        }
    }
    return update
}

export function pathToBase64(path) {
    
    return new Promise(function(resolve, reject) {
        if (typeof window === 'object' && 'document' in window) {
            if (typeof FileReader === 'function') {
                var xhr = new XMLHttpRequest()
                xhr.open('GET', path, true)
                xhr.responseType = 'blob'
                xhr.onload = function() {
                    if (this.status === 200) {
                        let fileReader = new FileReader()
                        fileReader.onload = function(e) {
                            resolve(e.target.result)
                        }
                        fileReader.onerror = reject
                        fileReader.readAsDataURL(this.response)
                    }
                }
                xhr.onerror = reject
                xhr.send()
                return
            }
            var canvas = document.createElement('canvas')
            var c2x = canvas.getContext('2d')
            var img = new Image
            img.onload = function() {
                canvas.width = img.width
                canvas.height = img.height
                c2x.drawImage(img, 0, 0)
                resolve(canvas.toDataURL())
                canvas.height = canvas.width = 0
            }
            img.onerror = reject
            img.src = path
            return
        }
        if (typeof plus === 'object') {
            plus.io.resolveLocalFileSystemURL(getLocalFilePath(path), function(entry) {
                entry.file(function(file) {
                    var fileReader = new plus.io.FileReader()
                    fileReader.onload = function(data) {
                        resolve(data.target.result)
                    }
                    fileReader.onerror = function(error) {
                        reject(error)
                    }
                    fileReader.readAsDataURL(file)
                }, function(error) {
                    reject(error)
                })
            }, function(error) {
                reject(error)
            })
            return
        }
        if (typeof wx === 'object' && wx.canIUse('getFileSystemManager')) {
            wx.getFileSystemManager().readFile({
                filePath: path,
                encoding: 'base64',
                success: function(res) {
                    resolve('data:image/png;base64,' + res.data)
                },
                fail: function(error) {
                    reject(error)
                }
            })
            return
        }
        reject(new Error('not support'))
    })
}

export function base64ToPath(base64) {
    return new Promise(function(resolve, reject) {
        if (typeof window === 'object' && 'document' in window) {
            base64 = base64.split(',')
            var type = base64[0].match(/:(.*?);/)[1]
            var str = atob(base64[1])
            var n = str.length
            var array = new Uint8Array(n)
            while (n--) {
                array[n] = str.charCodeAt(n)
            }
            return resolve((window.URL || window.webkitURL).createObjectURL(new Blob([array], { type: type })))
        }
        var extName = base64.match(/data:S+/(S+);/)
        if (extName) {
            extName = extName[1]
        } else {
            reject(new Error('base64 error'))
        }
        var fileName = getNewFileId() + '.' + extName
        if (typeof plus === 'object') {
            var basePath = '_doc'
            var dirPath = 'uniapp_temp'
            var filePath = basePath + '/' + dirPath + '/' + fileName
            if (!biggerThan(plus.os.name === 'Android' ? '1.9.9.80627' : '1.9.9.80472', plus.runtime.innerVersion)) {
                plus.io.resolveLocalFileSystemURL(basePath, function(entry) {
                    entry.getDirectory(dirPath, {
                        create: true,
                        exclusive: false,
                    }, function(entry) {
                        entry.getFile(fileName, {
                            create: true,
                            exclusive: false,
                        }, function(entry) {
                            entry.createWriter(function(writer) {
                                writer.onwrite = function() {
                                    resolve(filePath)
                                }
                                writer.onerror = reject
                                writer.seek(0)
                                writer.writeAsBinary(base64.replace(/^data:S+/S+;base64,/, ''))
                            }, reject)
                        }, reject)
                    }, reject)
                }, reject)
                return
            }
            var bitmap = new plus.nativeObj.Bitmap(fileName)
            bitmap.loadBase64Data(base64, function() {
                bitmap.save(filePath, {}, function() {
                    bitmap.clear()
                    resolve(filePath)
                }, function(error) {
                    bitmap.clear()
                    reject(error)
                })
            }, function(error) {
                bitmap.clear()
                reject(error)
            })
            return
        }
        if (typeof wx === 'object' && wx.canIUse('getFileSystemManager')) {
            var filePath = wx.env.USER_DATA_PATH + '/' + fileName
            wx.getFileSystemManager().writeFile({
                filePath: filePath,
                data: base64.replace(/^data:S+/S+;base64,/, ''),
                encoding: 'base64',
                success: function() {
                    resolve(filePath)
                },
                fail: function(error) {
                    reject(error)
                }
            })
            return
        }
        reject(new Error('not support'))
    })
}

/**
* canvas压缩图片
* @param {参数obj} param 
* @param {文件二进制流} param.file 必传
* @param {目标压缩大小} param.targetSize 不传初始赋值-1
* @param {输出图片宽度} param.width 不传初始赋值-1，等比缩放不用传高度
* @param {输出图片名称} param.fileName 不传初始赋值image
* @param {压缩图片程度} param.quality 不传初始赋值0.92。值范围0~1
* @param {回调函数} param.succ 必传
*/
export function pressImg(param){
  //如果没有回调函数就不执行
  if(param && param.succ){
     //如果file没定义返回null
     if(param.file == undefined) return param.succ(null);
     //给参数附初始值
     param.targetSize = param.hasOwnProperty("targetSize") ? param.targetSize : -1;
     param.width = param.hasOwnProperty("width") ? param.width : -1;
     param.fileName = param.hasOwnProperty("fileName") ? param.fileName: "image";
     param.quality = param.hasOwnProperty("quality") ? param.quality : 0.92;
     var _this = this;
     // 得到文件类型
     // var fileType = param.file.type;
     // // console.log(fileType) //image/jpeg
     // if(fileType.indexOf("image") == -1){
     //   console.log('请选择图片文件^_^');
     //   return param.succ(null);
     // }
     // //如果当前size比目标size小，直接输出
     // var size = param.file.size;
     // if(param.targetSize > size){
     //   return param.succ(param.file);
     // }
     // 读取file文件,得到的结果为base64位
    // changeFileToBaseURL(param.file,function(base64){
        var fileType = "image";
        debugger;
        var base64=param.file;
       if(base64){
         var image = new Image();
         image.src = base64;
         image.onload = function(){
           // 获得长宽比例
           var scale = this.width / this.height;
           // console.log(scale);
           //创建一个canvas
           var canvas = document.createElement('canvas');
           //获取上下文
           var context = canvas.getContext('2d');
           //获取压缩后的图片宽度,如果width为-1，默认原图宽度
           canvas.width = param.width == -1 ? this.width : param.width;
           //获取压缩后的图片高度,如果width为-1，默认原图高度
           canvas.height = param.width == -1 ? this.height : parseInt(param.width / scale);
           //把图片绘制到canvas上面
           context.drawImage(image, 0, 0, canvas.width, canvas.height);
           //压缩图片，获取到新的base64Url
           var newImageData = canvas.toDataURL(fileType,param.quality);
           //将base64转化成文件流
           // var resultFile = dataURLtoFile(newImageData,param.fileName);
           // //判断如果targetSize有限制且压缩后的图片大小比目标大小大，就弹出错误
           // if(param.targetSize != -1 && param.targetSize < resultFile.size){
           //   console.log("图片上传尺寸太大，请重新上传^_^");
           //   param.succ(null);
           // }else{
           //   //返回文件流
           //   param.succ(resultFile);
           // }
           param.succ(newImageData);
         }
       }
    // });
  }
 }
 
 /**
  * 将base64转换为文件
  * @param {baseURL} dataurl 
  * @param {文件名称} filename 
  * @return {文件二进制流}
 */
 function dataURLtoFile(dataurl, filename) {
     var arr = dataurl.split(','), mime = arr[0].match(/:(.*?);/)[1],
         bstr = atob(arr[1]), n = bstr.length, u8arr = new Uint8Array(n);
     while(n--){
         u8arr[n] = bstr.charCodeAt(n);
     }
     return new File([u8arr], filename, {type:mime});
  }
  
  /**
  * @param {二进制文件流} file 
  * @param {回调函数，返回base64} fn 
  */
  function changeFileToBaseURL(file,fn){
    // 创建读取文件对象
        var fileReader = new FileReader();
        //如果file没定义返回null
        if(file == undefined) return fn(null);
        // 读取file文件,得到的结果为base64位
        fileReader.readAsDataURL(file);
        fileReader.onload = function(){
          // 把读取到的base64
          var imgBase64Data = this.result;
          fn(imgBase64Data);
        }
      }

    引入工具 index.js
import {
        pathToBase64,
        base64ToPath,
        pressImg
    } from '@/components/image-tools/index.js'

                uni.chooseImage({
                    count: 1, // 默认9
                    sizeType: ['compressed'], // 可以指定是原图还是压缩图，默认二者都有
                    sourceType: ['album', 'camera'], // 可以指定来源是相册还是相机，默认二者都有
                    type: 'file',
                    success(res) {
                        debugger;
                        const tempFilePaths = res.tempFilePaths;
                        var that = res.tempFilePaths[0];
                        // 地址转成Base64
                        pathToBase64(res.tempFilePaths[0])
                            .then(base64 => {
                                //Base64 进行10倍压缩返回 Base64
                                pressImg({
                                    file: base64,
                                    targetSize: 2 * 1024 * 1024,
                                    quality: 0.1,
                                     600,
                                    succ: function(resultFile) {
                                        //如果不是null就是压缩成功
                                        if (resultFile) {
                                            //TODO
                                            self.$api.request.post('/OCRIdCard/getIdCard', JSON.stringify(resultFile), function(res) {
                                                if (res && res.code == "0" && res.data) {
                                                    const data = res.data;
                                                    self.name = data.words_result.姓名.words;
                                                    self.idNo = data.words_result.公民身份号码.words;
                                                    if (numberUtils.identityCodeValid(self.idNo)) {
                                                        self.age = self.getAge(self.idNo);
                                                    }
                                                    if (data.words_result.性别.words == '男') {
                                                        self.current = 0;
                                                    } else {
                                                        self.current = 1;
                                                    }
                                                } else {
                                                    if (res.data)
                                                        self.$api.alert("识别失败！" + res.data);
                                                    else
                                                        self.$api.alert("识别失败！");
                                                }

                                            }, function(res) {
                                                uni.showToast({
                                                    icon: 'none',
                                                    title: '未连接到服务，请联系管理员' + JSON.stringify(res),
                                                });
                                            }, function() {

                                                uni.hideLoading();
                                            });
                                        }
                                    }
                                })
                            });

java调百度api 工具类

引入两个包 一个Json 用 一个 压缩用

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20160810</version>
</dependency>
<dependency>
    <groupId>net.coobird</groupId>
    <artifactId>thumbnailator</artifactId>
    <version>0.4.8</version>
</dependency>

package XXXXXXX;


import java.awt.image.BufferedImage;
import java.io.*;
import java.math.BigDecimal;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.Base64;
import java.util.List;
import java.util.Map;

import net.coobird.thumbnailator.Thumbnails;
import org.json.JSONObject;

import javax.imageio.ImageIO;


public class BaiDuCardIdentification {




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


            imgByte64=imgByte64.replaceAll("data:image/(.*);base64,","");

            byte[] imgData= commpressPicCycle(Base64.getDecoder().decode(imgByte64), 300, 0.5f);


            String imgStr = Base64Util.encode((byte[])imgData);
            String imgParam = URLEncoder.encode(imgStr, "UTF-8");

            String param = "id_card_side=" + "front" + "&image=" + imgParam;

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

            String result = HttpUtil.post(url, accessToken, param);
            System.out.println(result);
            return result;
        } catch (Exception e) {
            return "身份证识别次数没有了,请联系管理员";
        }
    }

    public static String getAuth(String ak, String sk) {
        // 获取token地址
        String authHost = "https://aip.baidubce.com/oauth/2.0/token?";
        String getAccessTokenUrl = authHost
                // 1. grant_type为固定参数
                + "grant_type=client_credentials"
                // 2. 官网获取的 API Key
                + "&client_id=" + ak
                // 3. 官网获取的 Secret Key
                + "&client_secret=" + sk;
        try {
            URL realUrl = new URL(getAccessTokenUrl);
            // 打开和URL之间的连接
            HttpURLConnection connection = (HttpURLConnection) realUrl.openConnection();
            connection.setRequestMethod("GET");//设置请求方式
            connection.connect();//发送url
            // 获取所有响应头字段
            Map<String, List<String>> map = connection.getHeaderFields();
            // 遍历所有的响应头字段
            for (String key : map.keySet()) {
                System.err.println(key + "--->" + map.get(key));
            }
            // 定义 BufferedReader输入流来读取URL的响应
            BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String result = "";
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
            /**
             * 返回结果示例
             */

            JSONObject jsonObject = new JSONObject(result);
            String access_token = jsonObject.getString("access_token");
            return access_token;
        } catch (Exception e) {
            return "获取token失败";
        }

    }




    /**
     *
     * @param bytes 原图片字节数组
     * @param desFileSize 指定图片大小,单位 kb
     * @param accuracy 精度,递归压缩的比率,建议小于0.9
     * @return
     */
    public static byte[] commpressPicCycle(byte[] bytes, long desFileSize, double accuracy) throws IOException {
        // 获取目标图片
//        File imgFile = new File(desPath);
//        long fileSize = imgFile.length();
        long fileSize = bytes.length;
        System.out.println("=====fileSize======== "+fileSize);
        // 判断图片大小是否小于指定图片大小
        if(fileSize <= desFileSize * 1024){
            return bytes;
        }
        //计算宽高
        BufferedImage bim = ImageIO.read(new ByteArrayInputStream(bytes));
        int imgWidth = bim.getWidth();
        System.out.println(imgWidth+"====imgWidth=====");
        int imgHeight = bim.getHeight();
        int desWidth = new BigDecimal(imgWidth).multiply( new BigDecimal(accuracy)).intValue();
        System.out.println(desWidth+"====desWidth=====");
        int desHeight = new BigDecimal(imgHeight).multiply( new BigDecimal(accuracy)).intValue();
        ByteArrayOutputStream baos = new ByteArrayOutputStream(); //字节输出流（写入到内存）
        Thumbnails.of(new ByteArrayInputStream(bytes)).size(desWidth, desHeight).outputQuality(accuracy).toOutputStream(baos);
        //如果不满足要求,递归直至满足要求
        return commpressPicCycle(baos.toByteArray(), desFileSize, accuracy);
    }


}

 @RequestMapping(value = "/getIdCard", method = RequestMethod.POST)
    @WithoutAuthentication
    public Result getIdCard(@RequestBody Object file){

        Result result = new Result();
        String auth = BaiDuCardIdentification.getAuth("client_id","client_secret");//获取access_token
        //识别身份证信息  是要传入的两个参数  一个是access_token  另一个是文件的路径
        String idcard = BaiDuCardIdentification.getIdCardMessage(auth, file.toString());
        JSONObject parse =  JSONObject.parseObject(idcard); //将百度返回给我们的身份证信息 转换为json对象
        String idcard_number_type = parse.get("idcard_number_type").toString();//获取idcard_number_type判断身份证是否合法

        if (idcard.contains("edit_tool")) {//如果你的身份证图片被修改过  会返回这个字段  值为哪一个软件编辑过
            result.setCode("300");
            result.setData("身份证被"+parse.get("edit_tool").toString()+"编辑过,请重新上传");
            return result;
        }
        if (parse.get("image_status").toString().equals("non_idcard")) {//判断你上传的这张图片是否是个身份证图片
            result.setCode("300");
            result.setData("身份证不合格,请上传身份证照片面图片");
            return result;
        }
        if (idcard_number_type.equals("1")) {//只有idcard_number_type值为1的时候是合格的  其他的均为不合格
            result.setCode("0");
            result.setData(parse);
            return result;

        }
        //身份证不合格的就返回它的错误码  可以到官方文档查看具体的错误类型
        result.setCode("200");
        result.setData("身份证不合法错误码为:"+idcard_number_type);
        return result;

    }