接入百度智能云的营业执照识别接口、工商信息查询（基础版）接口到实际业务，参考代码

独白᭄ꦿ

已于 2023-05-06 11:01:56 修改

阅读量1k

点赞数

分类专栏： Java 文章标签：百度云云计算

于 2023-05-06 10:40:02 首次发布

本文链接：https://blog.csdn.net/qq_41114874/article/details/130519768

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

我的代码放在公共模块如下：

1.根据百度云官方文档-SDK中心，下载sdk对应jar包，我下载下来的版本是bce-java-sdk.0.10.254

2.使用mvn命令手动引入jar

mvn install:install-file -DgroupId="bce.java.sdk" -DartifactId="bce-java-sdk" -Dversion="0.10.254" -Dpackaging=jar -Dfile="D:\外部jar存放\jar\bce-java-sdk-0.10.254\lib\bce-java-sdk-0.10.254.jar"

3.项目pom.xml引入

<!--百度智能云sdk-->
<dependency>
    <groupId>bce.java.sdk</groupId>
    <artifactId>bce-java-sdk</artifactId>
    <version>0.10.254</version>
</dependency>

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.7.11</version>
</dependency>

项目application.yml新增配置：

#百度智能云
baidu:
  apiKey: 替换为自己的API Key
  secretKey: 替换为自己的Secret Key

接口报文日志表(t_itf_log)、access_token记录表(t_baidu_token_info)参考如下,自行创建表结构对应实体类

/**
* 重要提示代码中所需工具类
* FileUtil,Base64Util,HttpUtil,GsonUtils请从
* https://ai.baidu.com/file/658A35ABAB2D404FBF903F64D47C1F72
* https://ai.baidu.com/file/C8D81F3301E24D2892968F09AE1AD6E2
* https://ai.baidu.com/file/544D677F5D4E4F17B4122FBD60DB82B3
* https://ai.baidu.com/file/470B3ACCA3FE43788B5A963BF0B625F3
* 下载
*/

新增接口日志操作类LogService

package com.fjqwkj.commons.utils.license.baidu;

import cn.hutool.http.HttpStatus;
import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.fjqwkj.commons.utils.R;
import com.fjqwkj.model.itflog.TItfLog;

/**
 * @author wdh
 * @create 2023-04-27 21:06
 * @desc
 **/
public class LogService {
    /**
     * 保存接口日志
     *
     * @param itfLog
     */
    protected static TItfLog saveLog(String itfUrl, TItfLog itfLog) {
        String res = HttpUtil.post(itfUrl + "/baidu/token/saveLog", JSONObject.toJSONString(itfLog));
        R<TItfLog> tItfLogR = JSONObject.parseObject(res, new TypeReference<R<TItfLog>>() {});
        if (tItfLogR.getCode() != HttpStatus.HTTP_OK) {
            return null;
        }
        return tItfLogR.getData();
    }

    /**
     * 修改接口日志
     *
     * @param itfLog
     */
    protected static void updateLog(String itfUrl, TItfLog itfLog) {
        HttpUtil.post(itfUrl + "/baidu/token/updateLog", JSONObject.toJSONString(itfLog));
    }
}

新增营业执照接口返回实体类LicenseIdentifyDTO、LicenseBasicDTO，可参考

package com.fjqwkj.dto.license;

import lombok.Data;

import java.io.Serializable;

/**
 * @Description: 营业执照基础版返回DTO
 */
@Data
public class LicenseBasicDTO implements Serializable {

	/**
	 *状态码，成功时返回0
	 */
	private Long ErrorCode;
	/**
	 *统一社会信用代码
	 */
	private String CreditCode;
	/**
	 *经营期限自（YYYY-MM-DD）
	 */
	private String Opfrom;
	/**
	 *经营期限至（YYYY-MM-DD）
	 */
	private String Opto;
	/**
	 *法人姓名
	 */
	private String Frname;
	/**
	 *经营状态，包括：
	 * 成立、筹建、存续、在营、开业、在册、正常经营、开业登记中、
	 * 登记成立、撤销、撤销登记、非正常户、告解、个体暂时吊销、
	 * 个体转企业、吊销（未注销）、拟注销、已注销、（待）迁入、（待）迁出、停业、歇业、清算等。
	 */
	private String Entstatus;
	/**
	 *经营业务范围
	 */
	private String Zsopscope;
	/**
	 *查询的状态信息
	 */
	private String Reason;
	/**
	 *原注册号
	 */
	private String Oriregno;
	/**
	 *要核验的工商注册号
	 */
	private String VerifyRegno;
	/**
	 *工商注册号
	 */
	private String Regno;
	/**
	 *要核验的企业名称
	 */
	private String VerifyEntname;
	/**
	 *企业名称
	 */
	private String Entname;
	/**
	 *要核验的住址
	 */
	private String VerifyDom;
	/**
	 *住址
	 */
	private String Dom;
	/**
	 *验证结果
	 * "RegNumResult": {
	 *       "RegNum": "0",
	 *       "Name": "0",
	 *       "Address": "0"
	 *  }
	 * RegNum “0“：一致  “-1”：此号未查询到结果
	 * Name  “0“：一致  “-1”：不一致	“”：不验真
	 * Address “0“：一致 “-1”：不一致 “”：不验真
	 *
	 * BizLicenseVerifyResult RegNumResult;
	 */
	private String regNumCheck;

	private String nameCheck;

	private String addressCheck;

	/**
	 *注册资本（单位：万元）,只有输入参数regCapital为1的时候才输出
	 */
	private String RegCapital;
	/**
	 *成立/注册日期，只有输入参数EstablishTime为true时展示，默认为空
	 */
	private String EstablishTime;
	/**
	 *唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
	 */
	private String RequestId;

	/**
	 * 核准时间
	 */
	private String issuedate;
	/**
	 * 行政区号
	 */
	private String provincecode;
	/**
	 * 市
	 */
	private String city;
	/**
	 * 行政区号
	 */
	private String citycode;
	/**
	 * 地区
	 */
	private String district;
	/**
	 * 行政区号
	 */
	private String districtcode;
	/**
	 * 企业类型
	 */
	private String companytype;
	/**
	 * 登记机关
	 */
	private String authority;
	/**
	 * 所在省份
	 */
	private String province;
}






package com.fjqwkj.dto.license;

import lombok.Data;

import java.io.Serializable;

/**
 * @Description: 营业执照识别返回DTO
 */
@Data
public class LicenseIdentifyDTO implements Serializable {

	/**
	 *统一社会信用代码（三合一之前为注册号）
	 */
	private String regNum;
	/**
	 *公司名称
	 */
	private String name;
	/**
	 *注册资本
	 */
	private String capital;
	/**
	 *法定代表人
	 */
	private String person;
	/**
	 *地址
	 */
	private String address;
	/**
	 *经营范围
	 */
	private String business;
	/**
	 *主体类型
	 */
	private String type;
	/**
	 *营业期限
	 */
	private String period;
	/**
	 *组成形式
	 */
	private String composingForm;
	/**
	 *成立日期
	 */
	private String setDate;
	/**
	 *Code 告警码列表和释义：
	 * -20001 非营业执照
	 * 注：告警码可以同时存在多个
	 */
	private Integer[] recognizeWarnCode;
	/**
	 *告警码说明：
	 * OCR_WARNING_TPYE_NOT_MATCH 非营业执照
	 * 注：告警信息可以同时存在多个
	 */
	private String[] recognizeWarnMsg;
	/**
	 *唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
	 */
	private String requestId;
}

4.根据官方文档，调用接口之前需先调用接口获取 Access_token，access_token有过期时间，客户端可自行缓存，过期后重新获取。

新增获取accessToken工具类AccessTokenUtils 参考代码如下

package com.fjqwkj.commons.utils.license.baidu;

import com.squareup.okhttp.*;
import org.apache.commons.lang.StringUtils;

import java.io.IOException;

/**
 * @author wdh
 * @create 2023-04-27 11:48
 * @desc
 **/
public class AccessTokenUtils {

    private static final OkHttpClient HTTP_CLIENT = new OkHttpClient();
    /**
     * 获取token地址
     */
    private static final String ACCESS_TOKEN_URL = "https://aip.baidubce.com/oauth/2.0/token?client_id=%s&client_secret=%s&grant_type=client_credentials";

    /**
     * 获取token
     * @param apiKey
     * @param secretKey
     * @return
     * @throws IOException
     */
    public static String getAccessToken(String apiKey, String secretKey) throws IOException {
        if (StringUtils.isBlank(apiKey) || StringUtils.isBlank(secretKey)) {
            throw new IllegalArgumentException("param: apiKey and secretKey is required");
        }
        MediaType mediaType = MediaType.parse("application/json");
        RequestBody body = RequestBody.create(mediaType, "");
        Request request = new Request.Builder()
                .url(String.format(ACCESS_TOKEN_URL, apiKey, secretKey))
                .method("POST", body)
                .addHeader("Content-Type", "application/json")
                .addHeader("Accept", "application/json")
                .build();
        Response response = HTTP_CLIENT.newCall(request).execute();
        return response.body().string();
    }


    public static void main(String[] args) throws IOException {
        String accessToken = getAccessToken("替换为自己的API Key", "替换为自己的Secret Key");
        System.out.println(accessToken);
    }

}

5.新增营业执照识别类BusinessLicense，因access_token具有失效性，所以我根据过期时间做了保存，过期之后重新获取。也可改用其他方式使用redis，或其他方式。

package com.fjqwkj.commons.utils.license.baidu;

import cn.hutool.http.HttpStatus;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.fjqwkj.commons.utils.R;
import com.fjqwkj.commons.utils.StringPool;
import com.fjqwkj.dto.license.LicenseIdentifyDTO;
import com.fjqwkj.model.itflog.TItfLog;
import org.apache.commons.lang.StringUtils;

import java.net.URLEncoder;
import java.util.Date;

/**
 * 营业执照识别
 */
public class BusinessLicense {

    /**
     * 营业执照识别地址
     */
    private static final String BUSINESS_LICENSE_URL = "https://aip.baidubce.com/rest/2.0/ocr/v1/business_license";


    /**
     * 重要提示代码中所需工具类
     * FileUtil,Base64Util,HttpUtil,GsonUtils请从
     * https://ai.baidu.com/file/658A35ABAB2D404FBF903F64D47C1F72
     * https://ai.baidu.com/file/C8D81F3301E24D2892968F09AE1AD6E2
     * https://ai.baidu.com/file/544D677F5D4E4F17B4122FBD60DB82B3
     * https://ai.baidu.com/file/470B3ACCA3FE43788B5A963BF0B625F3
     * 下载
     */
    public static LicenseIdentifyDTO businessLicense(String filePath, String itfUrl) {
        try {
            byte[] imgData = FileUtil.readFileByBytes(filePath);
            String imgStr = Base64Util.encode(imgData);
            String imgParam = URLEncoder.encode(imgStr, "UTF-8");
            String param = "image=" + imgParam;
            //调用可访问数据库服务的模块，itfUrl为那个模块的服务url
            String res = cn.hutool.http.HttpUtil.get(itfUrl + "/baidu/token/refreshToken");
            R<String> accessTokenR = JSONObject.parseObject(res, new TypeReference<R<String>>() {});
            if (accessTokenR.getCode() != HttpStatus.HTTP_OK) {
                throw new Exception("accessToken is null");
            }
            //保存请求日志
            TItfLog itfLog = new TItfLog();
            itfLog.setType(6);
            itfLog.setRequestText(StringUtils.substring(param, StringPool.SPLIT_START, StringPool.SPLIT_LENGTH));
            itfLog.setRequestText1(StringUtils.substring(param, StringPool.SPLIT_START + StringPool.SPLIT_LENGTH, StringPool.SPLIT_LENGTH * 2));
            itfLog.setRequestText2(StringUtils.substring(param, StringPool.SPLIT_LENGTH * 2, StringPool.SPLIT_LENGTH * 3));
            itfLog.setRequestText3(StringUtils.substring(param, StringPool.SPLIT_LENGTH * 3, StringPool.SPLIT_LENGTH * 4));
            itfLog.setUrl(BUSINESS_LICENSE_URL);
            TItfLog saveLog = LogService.saveLog(itfUrl, itfLog);
            String result = HttpUtil.post(BUSINESS_LICENSE_URL, accessTokenR.getData(), param);
            System.out.println(result);
            if (StringUtils.isBlank(result)) {
                throw new Exception("result is null");
            }
            //构造返回报文
            LicenseIdentifyDTO licenseIdentifyDTO = buildResBodyToLicenseIdentifyDTO(result);
            if (saveLog != null) {
                saveLog.setResponseText(StringUtils.substring(result, StringPool.SPLIT_START, StringPool.SPLIT_LENGTH));
                saveLog.setResponseText1(StringUtils.substring(result, StringPool.SPLIT_START + StringPool.SPLIT_LENGTH, StringPool.SPLIT_LENGTH * 2));
                saveLog.setResponseText2(StringUtils.substring(result, StringPool.SPLIT_LENGTH * 2, StringPool.SPLIT_LENGTH * 3));
                saveLog.setResponseText3(StringUtils.substring(result, StringPool.SPLIT_LENGTH * 3, StringPool.SPLIT_LENGTH * 4));
                saveLog.setOutId(licenseIdentifyDTO.getRequestId());
                saveLog.setUpdateBy(licenseIdentifyDTO.getRequestId());
                saveLog.setUpdateDate(new Date());
                LogService.updateLog(itfUrl, saveLog);
            }
            return licenseIdentifyDTO;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 构造返回实体
     *
     * @param resBody
     * @return
     */
    private static LicenseIdentifyDTO buildResBodyToLicenseIdentifyDTO(String resBody) {
        LicenseIdentifyDTO licenseIdentifyDTO = new LicenseIdentifyDTO();
        JSONObject jsonObject = JSONObject.parseObject(resBody);
        JSONObject words_resultJson = jsonObject.getJSONObject("words_result");
        if (words_resultJson != null) {
            JSONObject businessJson = words_resultJson.getJSONObject("经营范围");
            if (businessJson != null) {
                String business = businessJson.getString("words");
                licenseIdentifyDTO.setBusiness(business);
            }
            JSONObject composingFormJson = words_resultJson.getJSONObject("组成形式");
            if (composingFormJson != null) {
                String composingForm = composingFormJson.getString("words");
                licenseIdentifyDTO.setComposingForm(composingForm);
            }
            JSONObject personJson = words_resultJson.getJSONObject("法人");
            if (personJson != null) {
                String person = personJson.getString("words");
                licenseIdentifyDTO.setPerson(person);
            }
            JSONObject capitalJson = words_resultJson.getJSONObject("注册资本");
            if (capitalJson != null) {
                String capital = capitalJson.getString("words");
                licenseIdentifyDTO.setCapital(capital);
            }
            JSONObject nameJson = words_resultJson.getJSONObject("单位名称");
            if (nameJson != null) {
                String name = nameJson.getString("words");
                licenseIdentifyDTO.setName(name);
            }
            JSONObject periodJson = words_resultJson.getJSONObject("有效期");
            if (periodJson != null) {
                String period = periodJson.getString("words");
                licenseIdentifyDTO.setPeriod(period);
            }
            JSONObject regNumJson = words_resultJson.getJSONObject("社会信用代码");
            if (regNumJson != null) {
                String regNum = regNumJson.getString("words");
                licenseIdentifyDTO.setRegNum(regNum);
            }
            JSONObject setDateJson = words_resultJson.getJSONObject("成立日期");
            if (setDateJson != null) {
                String setDate = setDateJson.getString("words");
                licenseIdentifyDTO.setSetDate(setDate);
            }
            JSONObject addressJson = words_resultJson.getJSONObject("地址");
            if (addressJson != null) {
                String address = addressJson.getString("words");
                licenseIdentifyDTO.setAddress(address);
            }
            JSONObject typeJson = words_resultJson.getJSONObject("类型");
            if (typeJson != null) {
                String type = typeJson.getString("words");
                licenseIdentifyDTO.setType(type);
            }
        }
        String direction = jsonObject.getString("direction");
        String words_result_num = jsonObject.getString("words_result_num");
        String log_id = jsonObject.getString("log_id");
        licenseIdentifyDTO.setRequestId(log_id);
        return licenseIdentifyDTO;
    }

    public static void main(String[] args) {
        // 本地文件路径
        String filePath = "C:\\Users\\28235\\Desktop\\项目文件\\营业执照.jpg";
        BusinessLicense.businessLicense(filePath, "http://127.0.0.1:8086/ytsd_itf");
    }
}

6.新增token控制层，用于保存接口报文，保存access_token数据，参考代码如下

package com.fjqwkj.controller.baidutoken;

import com.fjqwkj.commons.enums.ApplyEnum;
import com.fjqwkj.commons.utils.R;
import com.fjqwkj.model.itflog.TItfLog;
import com.fjqwkj.service.itflog.TItfLogService;
import com.fjqwkj.service.tbaidutokeninfo.TBaiduTokenInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author wdh
 * @create 2023-04-27 15:56
 * @desc
 **/
@RestController
@RequestMapping("/baidu/token")
public class BaiDuTokenController {

    @Autowired
    private TBaiduTokenInfoService baiduTokenInfoService;
    @Autowired
    private TItfLogService itfLogService;

    @GetMapping("/refreshToken")
    public R<String> refreshToken() {
        try {
            return baiduTokenInfoService.refreshToken();
        } catch (Exception e) {
            e.printStackTrace();
            return R.fail(-9999, e.getMessage());
        }
    }

    @PostMapping("/saveLog")
    public R<TItfLog> saveLog(@RequestBody TItfLog itfLog) {
        try {
            itfLog.setLogId(itfLogService.seqAlways());
            itfLogService.save(itfLog);
            return R.ok(itfLog);
        } catch (Exception e) {
            e.printStackTrace();
            return R.fail(-9999, ApplyEnum.EXCEPTION.getMsg());
        }
    }

    @PostMapping("/updateLog")
    public R<String> updateLog(@RequestBody TItfLog itfLog) {
        try {
            itfLogService.update(itfLog);
            return R.ok();
        } catch (Exception e) {
            e.printStackTrace();
            return R.fail(-9999, ApplyEnum.EXCEPTION.getMsg());
        }
    }
}

7.新增accessToken的service层类TBaiduTokenInfoService

，参考代码如下：

package com.fjqwkj.service.tbaidutokeninfo;

import com.fjqwkj.commons.utils.R;


public interface TBaiduTokenInfoService {

    /**
     * 获取接口token，并更新
     * @return
     */
	R<String> refreshToken() throws Exception;
}

8.新增service.impl实现类TBaiduTokenInfoServiceImpl，TBaiduTokenInfoMapper对应表结构持久化层的增删改查，此步骤省略，可自行根据项目架构做调整，R为自定义统一返回结果类，参考代码如下

package com.fjqwkj.commons.utils;





import com.fjqwkj.commons.enums.ApiCodeMsgEnum;
import com.fjqwkj.commons.enums.ICodeMsg;

import java.util.Optional;

/**
 * @description: 统一返回结果类
 */
public class R<T> {
    private long code;
    private String msg;
    private T data;

    private R(){}

    private R(ICodeMsg iCodeMsg){
        iCodeMsg =  Optional.ofNullable(iCodeMsg).orElse(ApiCodeMsgEnum.FAIL);
        this.code = iCodeMsg.getCode();
        this.msg = iCodeMsg.getMsg();
    }

    public static <T> R<T> ok(){
        return setValue(null, ApiCodeMsgEnum.SUCCESS);
    }

    public static <T> R<T> ok(T data){
        return setValue(data, ApiCodeMsgEnum.SUCCESS);
    }

    public static <T> R<T> ok(ICodeMsg iCodeMsg){
        return setValue(null, iCodeMsg);
    }

    public static <T> R<T> ok(ICodeMsg iCodeMsg, T data){
        return setValue(data, iCodeMsg);
    }

    public static <T> R<T> ok(long code, String msg){
        return setValue(code,msg,null);
    }

    public static <T> R<T> ok(long code, String msg, T data){
        return setValue(code,msg,data);
    }

    public static <T> R<T> fail(){
        return setValue(null, ApiCodeMsgEnum.FAIL);
    }

    public static <T> R<T> fail(ICodeMsg iCodeMsg){
        return setValue(null, iCodeMsg);
    }

    public static <T> R<T> fail(T t){
        return setValue(t, ApiCodeMsgEnum.FAIL);
    }

    public static <T> R<T> fail(ICodeMsg iCodeMsg, T data){
        return setValue(data, iCodeMsg);
    }

    public static <T> R<T> fail(long code, String msg){
        return setValue(code,msg,null);
    }


    private static <T> R<T> setValue(T data, ICodeMsg iCodeMsg){
        R<T> r = new R<>(iCodeMsg);
        r.setData(data);
        return r;
    }

    private static <T> R<T> setValue(long code, String msg, T data){
        R<T> r = new R<>();
        r.setCode(code);
        r.setMsg(msg);
        r.setData(data);
        return r;
    }

    public long getCode(){return this.code;}

    public String getMsg(){return this.msg;}

    public T getData(){return this.data;}

    public void setCode(long code) {
        this.code = code;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public void setData(T data){
        this.data = data;
    }

    @Override
    public String toString() {
        return "R[code=" + this.getCode() + ", msg=" + this.getMsg() + ", data=" + this.getData() + "]";
    }
}






package com.fjqwkj.commons.enums;

/**
 * @description: 错误码接口
 */
public interface ICodeMsg {

    /**
     * 获取错误码
     * @description: 获取错误码
     * @return: {@link long}
     * @author: WangZ
     * @time: 2020/8/28 15:47
     */
    long getCode();

    /**
     * 获取错误信息
     * @description: 获取错误信息
     * @return: {@link String}
     * @author: WangZ
     * @time: 2020/8/28 15:48
     */
    String getMsg();
}



package com.fjqwkj.commons.enums;

/**
 * @description: 接口异常
 */
public enum ApiCodeMsgEnum implements ICodeMsg {

    /**
     * 请求成功
     */
    SUCCESS(200,"success"),
    /**
     * 请求失败
     */
    FAIL(400,"fail"),
    /**
     * 未授权
     */
    AUTH_FAIL(401,"尚未授权"),
    /**
     * 缺失必要参数
     */
    MISS_PARAMETER(420,"缺失必要参数"),
    /**
     * 参数校验失败
     */
    VALID_ERROR(421,"参数校验失败"),
    /**
     * 服务器出错
     */
    ERROR(500,"server error");

    private final long code;
    private final String msg;

    ApiCodeMsgEnum(long code, String msg){
        this.code = code;
        this.msg = msg;
    }

    /**
     * 获取错误码
     *
     * @description: 获取错误码
     * @return: {@link long}
     * @author: WangZ
     * @time: 2020/8/28 15:47
     */
    @Override
    public long getCode() {
        return this.code;
    }

    /**
     * 获取错误信息
     *
     * @description: 获取错误信息
     * @return: {@link String}
     * @author: WangZ
     * @time: 2020/8/28 15:48
     */
    @Override
    public String getMsg() {
        return this.msg;
    }
}

package com.fjqwkj.service.tbaidutokeninfo.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Snowflake;
import com.fjqwkj.commons.utils.R;
import com.fjqwkj.commons.utils.license.baidu.AccessTokenUtils;
import com.fjqwkj.commons.utils.license.baidu.GsonUtils;
import com.fjqwkj.dao.tbaidutokeninfo.TBaiduTokenInfoMapper;
import com.fjqwkj.model.home.Criteria;
import com.fjqwkj.model.tbaidutokeninfo.TBaiduTokenInfo;
import com.fjqwkj.service.tbaidutokeninfo.TBaiduTokenInfoService;
import com.fjqwkj.vo.baidu.BaiDuAccessTokenVo;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;

@Service
public class TBaiduTokenInfoServiceImpl implements TBaiduTokenInfoService {

    private final Snowflake snowflake = new Snowflake(10, 26);

    @Value("${baidu.apiKey:}")
    private String apiKey;
    @Value("${baidu.secretKey:}")
    private String secretKey;

    @Autowired
    private TBaiduTokenInfoMapper baiduTokenInfoMapper;
    
    @Override
    public R<String> refreshToken() throws Exception {
        //先查数据有没有保存过access_token
        List<TBaiduTokenInfo> baiduTokenInfoList = baiduTokenInfoMapper.selectByCondition(new Criteria());
        if (CollUtil.isEmpty(baiduTokenInfoList)) {
            String accessTokenRes = AccessTokenUtils.getAccessToken(apiKey, secretKey);
            if (StringUtils.isBlank(accessTokenRes)) {
                throw new IllegalArgumentException("accessTokenRes is empty");
            }
            BaiDuAccessTokenVo baiDuAccessTokenVo = GsonUtils.fromJson(accessTokenRes, BaiDuAccessTokenVo.class);
            TBaiduTokenInfo baiduTokenInfo = new TBaiduTokenInfo();
            baiduTokenInfo.setBaiduTokenInfoId(snowflake.nextIdStr());
            baiduTokenInfo.setRefreshToken(baiDuAccessTokenVo.getRefresh_token());
            baiduTokenInfo.setExpiresIn(baiDuAccessTokenVo.getExpires_in());
            baiduTokenInfo.setSessionKey(baiDuAccessTokenVo.getSession_key());
            baiduTokenInfo.setAccessToken(baiDuAccessTokenVo.getAccess_token());
            baiduTokenInfo.setScope(baiDuAccessTokenVo.getScope());
            baiduTokenInfo.setSessionSecret(baiDuAccessTokenVo.getSession_secret());
            baiduTokenInfo.setTokenInvalidDate(DateUtil.offsetSecond(new Date(), baiDuAccessTokenVo.getExpires_in()));
            baiduTokenInfoMapper.save(baiduTokenInfo);
            return R.ok(baiDuAccessTokenVo.getAccess_token());
        }
        TBaiduTokenInfo baiduTokenInfo = baiduTokenInfoList.get(0);
        int compare = DateUtil.compare(baiduTokenInfo.getTokenInvalidDate(), new Date());
        //token过期了,重新生成
        if (compare <= 0) {
            String accessTokenRes = AccessTokenUtils.getAccessToken(apiKey, secretKey);
            if (StringUtils.isBlank(accessTokenRes)) {
                throw new IllegalArgumentException("accessTokenRes is empty");
            }
            BaiDuAccessTokenVo baiDuAccessTokenVo = GsonUtils.fromJson(accessTokenRes, BaiDuAccessTokenVo.class);
            TBaiduTokenInfo obj = new TBaiduTokenInfo();
            obj.setBaiduTokenInfoId(baiduTokenInfo.getBaiduTokenInfoId());
            obj.setRefreshToken(baiDuAccessTokenVo.getRefresh_token());
            obj.setExpiresIn(baiDuAccessTokenVo.getExpires_in());
            obj.setSessionKey(baiDuAccessTokenVo.getSession_key());
            obj.setAccessToken(baiDuAccessTokenVo.getAccess_token());
            obj.setScope(baiDuAccessTokenVo.getScope());
            obj.setSessionSecret(baiDuAccessTokenVo.getSession_secret());
            obj.setTokenInvalidDate(DateUtil.offsetSecond(new Date(), baiDuAccessTokenVo.getExpires_in()));
            obj.setUpdateBy("1000000");
            obj.setUpdateDate(new Date());
            baiduTokenInfoMapper.update(obj);
            return R.ok(baiDuAccessTokenVo.getAccess_token());
        }
        return R.ok(baiduTokenInfo.getAccessToken());
    }
}

9.新增OCR-企业工商信息查询（标准版）工具类BusinesslicenseVerificationStandard

package com.fjqwkj.commons.utils.license.baidu;


import cn.hutool.http.HttpStatus;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.fjqwkj.commons.utils.R;
import com.fjqwkj.commons.utils.StringPool;
import com.fjqwkj.dto.license.LicenseBasicDTO;
import com.fjqwkj.model.itflog.TItfLog;
import com.fjqwkj.vo.baidu.BaiDuLicenseVo;
import com.fjqwkj.vo.baidu.WordsResult;
import org.apache.commons.lang.StringUtils;

import java.util.Date;

/**
 * OCR-企业工商信息查询（标准版）
 */
public class BusinesslicenseVerificationStandard {

    /**
     * 企业工商信息查询（标准版）地址
     */
    private static final String BUSINESSLICENSE_VERIFICATION_STANDARD_URL = "https://aip.baidubce.com/rest/2.0/ocr/v1/businesslicense_verification_standard";

    /**
     * 重要提示代码中所需工具类
     * FileUtil,Base64Util,HttpUtil,GsonUtils请从
     * https://ai.baidu.com/file/658A35ABAB2D404FBF903F64D47C1F72
     * https://ai.baidu.com/file/C8D81F3301E24D2892968F09AE1AD6E2
     * https://ai.baidu.com/file/544D677F5D4E4F17B4122FBD60DB82B3
     * https://ai.baidu.com/file/470B3ACCA3FE43788B5A963BF0B625F3
     * 下载
     */
    public static LicenseBasicDTO businesslicenseVerificationStandard(String verifynum, String itfUrl) {
        try {
            String param = "verifynum=" + verifynum;
            String res = cn.hutool.http.HttpUtil.get(itfUrl + "/baidu/token/refreshToken");
            R<String> accessTokenR = JSONObject.parseObject(res, new TypeReference<R<String>>() {});
            if (accessTokenR.getCode() != HttpStatus.HTTP_OK) {
                throw new Exception("accessToken is null");
            }
            //保存请求日志
            TItfLog itfLog = new TItfLog();
            itfLog.setType(6);
            itfLog.setRequestText(StringUtils.substring(param, StringPool.SPLIT_START, StringPool.SPLIT_LENGTH));
            itfLog.setRequestText1(StringUtils.substring(param, StringPool.SPLIT_START + StringPool.SPLIT_LENGTH, StringPool.SPLIT_LENGTH * 2));
            itfLog.setRequestText2(StringUtils.substring(param, StringPool.SPLIT_LENGTH * 2, StringPool.SPLIT_LENGTH * 3));
            itfLog.setRequestText3(StringUtils.substring(param, StringPool.SPLIT_LENGTH * 3, StringPool.SPLIT_LENGTH * 4));
            itfLog.setUrl(BUSINESSLICENSE_VERIFICATION_STANDARD_URL);
            TItfLog saveLog = LogService.saveLog(itfUrl, itfLog);
            String result = HttpUtil.post(BUSINESSLICENSE_VERIFICATION_STANDARD_URL, accessTokenR.getData(), param);
            System.out.println(result);
            if (StringUtils.isBlank(result)) {
                throw new Exception("result is null");
            }
            //构造返回报文
            LicenseBasicDTO licenseBasicDTO = buildResBodyToLicenseBasicDTO(result);
            if (saveLog != null && licenseBasicDTO != null) {
                saveLog.setResponseText(StringUtils.substring(result, StringPool.SPLIT_START, StringPool.SPLIT_LENGTH));
                saveLog.setResponseText1(StringUtils.substring(result, StringPool.SPLIT_START + StringPool.SPLIT_LENGTH, StringPool.SPLIT_LENGTH * 2));
                saveLog.setResponseText2(StringUtils.substring(result, StringPool.SPLIT_LENGTH * 2, StringPool.SPLIT_LENGTH * 3));
                saveLog.setResponseText3(StringUtils.substring(result, StringPool.SPLIT_LENGTH * 3, StringPool.SPLIT_LENGTH * 4));
                saveLog.setOutId(licenseBasicDTO.getRequestId());
                saveLog.setUpdateBy(licenseBasicDTO.getRequestId());
                saveLog.setUpdateDate(new Date());
                LogService.updateLog(itfUrl, saveLog);
            }
            return licenseBasicDTO;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 构造返回实体
     *
     * @param resBody
     * @return
     */
    private static LicenseBasicDTO buildResBodyToLicenseBasicDTO(String resBody) {
        BaiDuLicenseVo baiDuLicenseVo = JSONObject.parseObject(resBody, BaiDuLicenseVo.class);
        if (baiDuLicenseVo == null) {
            return null;
        }
        LicenseBasicDTO licenseBasicDTO = new LicenseBasicDTO();
        WordsResult wordsResult = baiDuLicenseVo.getWords_result();
        licenseBasicDTO.setCreditCode(wordsResult.getCreditno());
        licenseBasicDTO.setOpfrom(wordsResult.getOperationstartdate());
        licenseBasicDTO.setOpto(wordsResult.getOperationenddate());
        licenseBasicDTO.setFrname(wordsResult.getLegalperson());
        licenseBasicDTO.setEntstatus(wordsResult.getCompanystatus());
        licenseBasicDTO.setZsopscope(wordsResult.getBusinessscope());
        licenseBasicDTO.setVerifyRegno(wordsResult.getCreditno());
        licenseBasicDTO.setRegno(wordsResult.getCompanycode());
        licenseBasicDTO.setVerifyEntname(wordsResult.getCompanyname());
        licenseBasicDTO.setEntname(wordsResult.getCompanyname());
        licenseBasicDTO.setVerifyDom(wordsResult.getCompanyaddress());
        licenseBasicDTO.setDom(wordsResult.getCompanyaddress());
        licenseBasicDTO.setRegCapital(wordsResult.getCapital());
        licenseBasicDTO.setEstablishTime(wordsResult.getEstablishdate());
        licenseBasicDTO.setRequestId(baiDuLicenseVo.getLog_id());
        licenseBasicDTO.setIssuedate(wordsResult.getIssuedate());
        licenseBasicDTO.setAuthority(wordsResult.getAuthority());
        licenseBasicDTO.setProvince(wordsResult.getProvince());
        licenseBasicDTO.setProvincecode(wordsResult.getProvincecode());
        licenseBasicDTO.setCity(wordsResult.getCity());
        licenseBasicDTO.setCitycode(wordsResult.getCitycode());
        licenseBasicDTO.setDistrict(wordsResult.getDistrict());
        licenseBasicDTO.setDistrictcode(wordsResult.getDistrictcode());
        licenseBasicDTO.setCompanytype(wordsResult.getCompanytype());
        return licenseBasicDTO;
    }

    public static void main(String[] args) {
        BusinesslicenseVerificationStandard.businesslicenseVerificationStandard("替换为营业执照识别接口识别出来的统一社会信用代码", "http://127.0.0.1:8086/ytsd_itf");
    }
}

10.嵌入实际项目业务逻辑中即可，

前端上传营业执照图片到接口，获取文件

1.先调用营业执照识别工具BusinessLicense.businessLicense() 获取统一社会信用代码。

2.调用OCR-企业工商信息查询（标准版）工具

BusinesslicenseVerificationStandard.businesslicenseVerificationStandard()获取营业执照信息。

......