✨ 车辆认证扩到6张证件图,字段与车辆档案对齐;补齐建车必填列

司机端车辆认证此前只有 3 张图、5 个字段,且语义与车辆管理不一致
(「副页」字段里装的其实是主页反面)。本次把证件内容整体对齐车辆表列:

- 车辆表新增 owner_name(所有人:行驶证登记的单位名称,不是司机)与 vin;
- 提交请求与司机端车辆卡片全量对齐表列,行驶证四张图各自独立、
  不再把「主页反面」与「副页正面」挤在同一个字段;
- 业务关系新增为司机自选(自有/管理挂靠/业务合作),不再由后端替用户猜。

顺带修掉三处会直接让功能不可用的缺陷:

1. 司机建车必失败:organization_name、approved_load_kg、business_relation、
   energy_type、registration_no 五列 NOT NULL 且无默认值,而建车链路一个都不设置,
   严格模式下 INSERT 直接报「doesn't have a default value」。已补齐并加服务端校验
   (司机提交链路此前一句都不查,全靠前端)。
2. OCR 自动填充从未生效:后端按契约透传百度原始结果(中文键),
   前端读的却是扁平字段名,永远 undefined 且不报错。新增 OcrFieldSupport
   做归一化(键名别名容错、数值/日期/「长期」归一化、外廓尺寸拆三段、
   有效期区间拆起止),响应的 fields 即前端直接回填的字段。
3. 审核通过不写回车辆档案:状态已通过、内容却还是旧的,自相矛盾。
   现把生效快照的证件内容与指针合并成同一次 UPDATE 写回;快照是改造前
   旧格式时明确报错,而不是静默写一堆空值。
This commit is contained in:
2026-10-03 16:34:47 +08:00
parent 214ff38ef8
commit 04a7846328
14 changed files with 1172 additions and 69 deletions
@@ -36,6 +36,7 @@ import org.springblade.transport.ocr.config.BaiduOcrProperties;
import org.springblade.transport.ocr.constant.BaiduOcrType;
import org.springblade.transport.ocr.service.IBaiduOcrService;
import org.springblade.transport.pojo.vo.BaiduOcrResultVO;
import org.springblade.transport.support.OcrFieldSupport;
import org.springframework.stereotype.Service;
import javax.imageio.ImageIO;
@@ -143,6 +144,9 @@ public class BaiduOcrServiceImpl implements IBaiduOcrService {
response.setType(type.name());
response.setSide(normalizedSide);
response.setResult(objectMapper.convertValue(result, RESULT_TYPE));
// 同时下发归一化字段:调用方不该去认识百度那套中文键名,
// 且键名对不上时前端只会「静默什么都不填」,是最难查的一类问题
response.setFields(OcrFieldSupport.extract(type, normalizedSide, result));
return response;
}
@@ -25,6 +25,7 @@
*/
package org.springblade.transport.service.impl;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.metadata.IPage;
import lombok.RequiredArgsConstructor;
import org.springblade.core.log.exception.ServiceException;
@@ -32,6 +33,7 @@ import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.utils.Func;
import org.springblade.system.cache.UserCache;
import org.springblade.transport.mapper.TransportCertRecordMapper;
import org.springblade.transport.pojo.dto.VehicleCertSubmitRequest;
import org.springblade.transport.pojo.entity.Driver;
import org.springblade.transport.pojo.entity.TransportCertRecord;
import org.springblade.transport.pojo.entity.TransportVehicle;
@@ -197,6 +199,11 @@ public class CertAuditServiceImpl implements ICertAuditService {
vehicle.setCertificationRejectReason(reason);
if (pass) {
vehicle.setEffectiveCertRecordId(newEffectiveId);
// 通过即生效:把这次快照的证件内容一并写回车辆档案,让「车辆档案 = 生效值」成立。
// 不写回的话,审核通过之后管理端与司机端看到的仍是提交之前的旧值——
// 状态显示「已通过」、内容却还是旧的,是最容易让人误判的一种不一致。
// 与指针合并成同一次 UPDATE,不额外多写一次同一行。
applySnapshotToVehicle(vehicle, record.getSnapshotJson());
}
transportVehicleService.updateById(vehicle);
return;
@@ -211,6 +218,67 @@ public class CertAuditServiceImpl implements ICertAuditService {
driverService.updateById(driver);
}
/**
* 把生效快照里的车辆证件字段搬进车辆档案(就地写入同一个 patch 对象)
* <p>
* 只搬**证件内容**,不碰两类字段:
* <ul>
* <li>{@code plateNo}:车牌是这辆车的身份,不是本次提交可以改的内容;</li>
* <li>{@code organizationName} / {@code useDepartment}:内部管理归属,
* 由管理端维护,不该被司机的提交内容覆盖。</li>
* </ul>
* 快照里为 null 的字段不会写(框架的 not_null 更新策略会跳过),
* 因此不会把管理端填过、司机端没填的字段清空。
*
* @param vehicle 待更新的车辆 patch
* @param snapshotJson 该条记录的全量提交内容
*/
private void applySnapshotToVehicle(TransportVehicle vehicle, String snapshotJson) {
if (Func.isEmpty(snapshotJson)) {
throw new ServiceException("该认证记录没有提交内容,无法写入车辆档案");
}
VehicleCertSubmitRequest snapshot;
try {
snapshot = JSON.parseObject(snapshotJson, VehicleCertSubmitRequest.class);
} catch (Exception exception) {
throw new ServiceException("该认证记录的提交内容无法解析,未写入车辆档案");
}
// 字段名对不上时 JSON 会解析成「全是 null」而不报错(改造前的历史快照就是这种情况),
// 那样写回等于什么也没写。故用证件内容里的关键字段判定「这份快照是否是当前格式」。
if (Func.isEmpty(snapshot.getDrivingLicenseNo()) && Func.isEmpty(snapshot.getApprovedLoadKg())) {
throw new ServiceException("该认证记录的提交内容与当前字段定义不匹配(可能是改造前的历史快照),"
+ "未写入车辆档案;请重新提交一次认证");
}
vehicle.setOwnerName(snapshot.getOwnerName());
vehicle.setPlateColor(snapshot.getPlateColor());
vehicle.setVehicleType(snapshot.getVehicleType());
vehicle.setVin(snapshot.getVin());
vehicle.setOuterLength(snapshot.getOuterLength());
vehicle.setOuterWidth(snapshot.getOuterWidth());
vehicle.setOuterHeight(snapshot.getOuterHeight());
vehicle.setApprovedLoadKg(snapshot.getApprovedLoadKg());
vehicle.setTractionMassKg(snapshot.getTractionMassKg());
vehicle.setEnergyType(snapshot.getEnergyType());
vehicle.setBusinessRelation(snapshot.getBusinessRelation());
vehicle.setCompulsoryScrapDate(snapshot.getCompulsoryScrapDate());
vehicle.setCompulsoryScrapLongTerm(snapshot.getCompulsoryScrapLongTerm());
vehicle.setDrivingLicenseNo(snapshot.getDrivingLicenseNo());
vehicle.setDrivingLicenseImage(snapshot.getDrivingLicenseImage());
vehicle.setDrivingLicenseMainBack(snapshot.getDrivingLicenseMainBack());
vehicle.setDrivingLicenseViceFront(snapshot.getDrivingLicenseViceFront());
vehicle.setDrivingLicenseViceBack(snapshot.getDrivingLicenseViceBack());
vehicle.setDrivingLicenseStartDate(snapshot.getDrivingLicenseStartDate());
vehicle.setDrivingLicenseEndDate(snapshot.getDrivingLicenseEndDate());
vehicle.setDrivingLicenseLongTerm(snapshot.getDrivingLicenseLongTerm());
vehicle.setRoadTransportCertNo(snapshot.getRoadTransportCertNo());
vehicle.setRoadTransportCertImage(snapshot.getRoadTransportCertImage());
vehicle.setRoadTransportCertStartDate(snapshot.getRoadTransportCertStartDate());
vehicle.setRoadTransportCertEndDate(snapshot.getRoadTransportCertEndDate());
vehicle.setRoadTransportCertLongTerm(snapshot.getRoadTransportCertLongTerm());
vehicle.setRegistrationNo(snapshot.getRegistrationNo());
vehicle.setRegistrationImage(snapshot.getRegistrationImage());
}
/**
* 取该对象当前的生效快照指针
*
@@ -42,6 +42,7 @@ import org.springblade.transport.support.VehiclePlateSupport;
import org.springblade.transport.wrapper.DriverWrapper;
import org.springframework.stereotype.Service;
import java.time.LocalDate;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@@ -119,29 +120,55 @@ public class DriverAppServiceImpl implements IDriverAppService {
DriverVehicleCardVO card = new DriverVehicleCardVO();
card.setId(vehicle.getId());
card.setPlateNo(vehicle.getPlateNo());
card.setOwnerName(Func.toStr(vehicle.getOwnerName(), ""));
card.setPlateColor(Func.toStr(vehicle.getPlateColor(), ""));
card.setVehicleType(vehicle.getVehicleType());
card.setLicenseFrontUrl(Func.toStr(vehicle.getDrivingLicenseImage(), ""));
card.setLicenseBackUrl(firstNotEmpty(vehicle.getDrivingLicenseViceFront(), vehicle.getDrivingLicenseMainBack()));
card.setRoadTransportNo(Func.toStr(vehicle.getRoadTransportCertNo(), ""));
card.setRoadTransportUrl(Func.toStr(vehicle.getRoadTransportCertImage(), ""));
card.setVin("");
card.setEngineNo("");
if (vehicle.getDrivingLicenseEndDate() != null) {
card.setLicenseValidEnd(vehicle.getDrivingLicenseEndDate().toString());
} else if (Integer.valueOf(1).equals(vehicle.getDrivingLicenseLongTerm())) {
card.setLicenseValidEnd("长期");
} else {
card.setLicenseValidEnd("");
}
card.setVin(Func.toStr(vehicle.getVin(), ""));
card.setOuterLength(vehicle.getOuterLength());
card.setOuterWidth(vehicle.getOuterWidth());
card.setOuterHeight(vehicle.getOuterHeight());
card.setApprovedLoadKg(vehicle.getApprovedLoadKg());
card.setTractionMassKg(vehicle.getTractionMassKg());
card.setEnergyType(Func.toStr(vehicle.getEnergyType(), ""));
card.setBusinessRelation(Func.toStr(vehicle.getBusinessRelation(), ""));
card.setCompulsoryScrapDate(dateText(vehicle.getCompulsoryScrapDate(), vehicle.getCompulsoryScrapLongTerm()));
card.setCompulsoryScrapLongTerm(vehicle.getCompulsoryScrapLongTerm());
card.setDrivingLicenseNo(Func.toStr(vehicle.getDrivingLicenseNo(), ""));
// 行驶证四张图各自独立,不再把「主页反面」与「副页正面」挤在同一个字段里:
// 它们本来就是证件上不同的四面,混在一起会让「重新认证」回填出错的图。
card.setDrivingLicenseImage(Func.toStr(vehicle.getDrivingLicenseImage(), ""));
card.setDrivingLicenseMainBack(Func.toStr(vehicle.getDrivingLicenseMainBack(), ""));
card.setDrivingLicenseViceFront(Func.toStr(vehicle.getDrivingLicenseViceFront(), ""));
card.setDrivingLicenseViceBack(Func.toStr(vehicle.getDrivingLicenseViceBack(), ""));
card.setDrivingLicenseStartDate(dateText(vehicle.getDrivingLicenseStartDate(), null));
card.setDrivingLicenseEndDate(dateText(vehicle.getDrivingLicenseEndDate(), vehicle.getDrivingLicenseLongTerm()));
card.setDrivingLicenseLongTerm(vehicle.getDrivingLicenseLongTerm());
card.setRoadTransportCertNo(Func.toStr(vehicle.getRoadTransportCertNo(), ""));
card.setRoadTransportCertImage(Func.toStr(vehicle.getRoadTransportCertImage(), ""));
card.setRoadTransportCertStartDate(dateText(vehicle.getRoadTransportCertStartDate(), null));
card.setRoadTransportCertEndDate(dateText(vehicle.getRoadTransportCertEndDate(), vehicle.getRoadTransportCertLongTerm()));
card.setRoadTransportCertLongTerm(vehicle.getRoadTransportCertLongTerm());
card.setRegistrationNo(Func.toStr(vehicle.getRegistrationNo(), ""));
card.setRegistrationImage(Func.toStr(vehicle.getRegistrationImage(), ""));
card.setCertificationStatus(vehicle.getCertificationStatus());
return card;
}
private String firstNotEmpty(String first, String second) {
if (Func.isNotEmpty(first)) {
return first;
/**
* 日期字段的展示值:长期有效显示「长期」,没填显示空串,其余显示日期
* <p>
* 卡片是「重新认证」表单的回填来源,空值必须是空串而不是「null」这类字符串,
* 否则用户会在日期框里看到一个字面量 null。
*
* @param date 日期
* @param longTerm 长期有效标志:1 表示长期
* @return 展示文本
*/
private String dateText(LocalDate date, Integer longTerm) {
if (date != null) {
return date.toString();
}
return Func.toStr(second, "");
return Integer.valueOf(1).equals(longTerm) ? "长期" : "";
}
/**
@@ -49,9 +49,11 @@ import org.springblade.transport.wrapper.TransportCertRecordWrapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
/**
@@ -70,11 +72,116 @@ import java.util.stream.Collectors;
@RequiredArgsConstructor
public class DriverCertServiceImpl implements IDriverCertService {
/**
* 证件文本字段的长度上限:与车辆表列宽及管理端校验保持一致
*/
private static final int SHORT_TEXT_MAX_LENGTH = 50;
/**
* 所有人(行驶证登记的单位名称)长度上限
*/
private static final int OWNER_NAME_MAX_LENGTH = 100;
private final IDriverAppService driverAppService;
private final IDriverService driverService;
private final ITransportVehicleService transportVehicleService;
private final ITransportCertRecordService transportCertRecordService;
/**
* 司机端提交的车辆认证内容校验
* <p>
* 服务端必须独立校验一遍,不能依赖小程序的前端校验:前端可绕过,
* 且这些字段里 {@code organization_name}、{@code approved_load_kg}、
* {@code business_relation}、{@code energy_type}、{@code registration_no}
* 都是 NOT NULL 且无默认值——缺一个这条 INSERT 就直接报数据库错误,
* 用户看到的是一串英文异常,而不是「哪个字段没填」。
*
* @param driver 当前司机
* @param request 提交内容
*/
private void validateCertContent(Driver driver, VehicleCertSubmitRequest request) {
if (Func.isEmpty(driver.getOrganizationName())) {
throw new ServiceException("司机档案缺少所属组织,请联系管理员补充后再提交");
}
requireText(request.getPlateColor(), "车牌颜色不能为空", SHORT_TEXT_MAX_LENGTH);
requireText(request.getVehicleType(), "车辆类型不能为空", SHORT_TEXT_MAX_LENGTH);
requireText(request.getOwnerName(), "所有人不能为空", OWNER_NAME_MAX_LENGTH);
requireText(request.getEnergyType(), "能源类型不能为空", SHORT_TEXT_MAX_LENGTH);
requireText(request.getBusinessRelation(), "业务关系不能为空", SHORT_TEXT_MAX_LENGTH);
requireText(request.getDrivingLicenseNo(), "行驶证档案编号不能为空", SHORT_TEXT_MAX_LENGTH);
requireText(request.getRoadTransportCertNo(), "道路运输证号不能为空", SHORT_TEXT_MAX_LENGTH);
Optional.ofNullable(request.getVin())
.filter(Func::isNotEmpty)
.ifPresent(vin -> requireText(vin, "车架号格式不正确", 17));
requireNonNegative(request.getApprovedLoadKg(), "核定载质量不能为空", "核定载质量不能小于0");
requireNonNegative(request.getTractionMassKg(), "准牵引总质量不能为空", "准牵引总质量不能小于0");
requireNonNegative(request.getOuterLength(), "外廓长度不能为空", "外廓长度不能小于0");
requireNonNegative(request.getOuterWidth(), "外廓宽度不能为空", "外廓宽度不能小于0");
requireNonNegative(request.getOuterHeight(), "外廓高度不能为空", "外廓高度不能小于0");
requireDateRange(request.getDrivingLicenseStartDate(), request.getDrivingLicenseEndDate(),
request.getDrivingLicenseLongTerm(), "请选择行驶证有效期", "行驶证有效期止不能早于有效期起");
requireDateRange(request.getRoadTransportCertStartDate(), request.getRoadTransportCertEndDate(),
request.getRoadTransportCertLongTerm(), "请选择道路运输证有效期", "道路运输证有效期止不能早于有效期起");
if (Func.isEmpty(request.getCompulsoryScrapDate())
&& !Integer.valueOf(1).equals(request.getCompulsoryScrapLongTerm())) {
throw new ServiceException("请选择强制报废日期");
}
}
/**
* 文本必填 + 长度校验
*
* @param value 待校验值
* @param emptyText 为空时的提示
* @param maxLength 长度上限
*/
private void requireText(String value, String emptyText, int maxLength) {
if (Func.isEmpty(value)) {
throw new ServiceException(emptyText);
}
if (value.trim().length() > maxLength) {
throw new ServiceException(emptyText.replace("不能为空", "") + "不能超过" + maxLength + "字");
}
}
/**
* 数值必填 + 非负校验
*
* @param value 待校验值
* @param emptyText 为空时的提示
* @param negativeText 为负数时的提示
*/
private void requireNonNegative(Integer value, String emptyText, String negativeText) {
if (value == null) {
throw new ServiceException(emptyText);
}
if (value < 0) {
throw new ServiceException(negativeText);
}
}
/**
* 有效期校验:未勾「长期有效」时起止必填,且止不得早于起
*
* @param start 有效期起
* @param end 有效期止
* @param longTerm 长期有效标志:1 表示长期
* @param emptyText 缺值提示
* @param rangeText 区间颠倒提示
*/
private void requireDateRange(LocalDate start, LocalDate end, Integer longTerm,
String emptyText, String rangeText) {
if (Integer.valueOf(1).equals(longTerm)) {
return;
}
if (start == null || end == null) {
throw new ServiceException(emptyText);
}
if (end.isBefore(start)) {
throw new ServiceException(rangeText);
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public Long submitPersonCert(PersonCertSubmitRequest request) {
@@ -330,21 +437,44 @@ public class DriverCertServiceImpl implements IDriverCertService {
*/
private TransportVehicle createVehicleForDriver(Driver driver, VehicleCertSubmitRequest request,
String normalizedPlate) {
validateCertContent(driver, request);
TransportVehicle vehicle = new TransportVehicle();
vehicle.setPlateNo(normalizedPlate);
// 所属组织取司机档案:车辆表的该列 NOT NULL 且无默认值,不填这条 INSERT 直接报
// 「Field 'organization_name' doesn't have a default value」(严格模式下必错)。
// 车辆归到司机所属组织名下,管理端按组织查看时才看得到这台车。
vehicle.setOrganizationName(driver.getOrganizationName());
vehicle.setOwnerName(request.getOwnerName());
vehicle.setPlateColor(request.getPlateColor());
vehicle.setVehicleType(request.getVehicleType());
vehicle.setDrivingLicenseNo(request.getLicenseNo());
vehicle.setDrivingLicenseStartDate(request.getLicenseValidStart());
vehicle.setDrivingLicenseEndDate(request.getLicenseValidEnd());
vehicle.setDrivingLicenseLongTerm(request.getLicenseLongTerm());
vehicle.setDrivingLicenseImage(request.getLicenseFrontUrl());
vehicle.setDrivingLicenseMainBack(request.getLicenseBackUrl());
vehicle.setRoadTransportCertNo(request.getRoadTransportNo());
vehicle.setRoadTransportCertStartDate(request.getRoadTransportValidStart());
vehicle.setRoadTransportCertEndDate(request.getRoadTransportValidEnd());
vehicle.setRoadTransportCertLongTerm(request.getRoadTransportLongTerm());
vehicle.setRoadTransportCertImage(request.getRoadTransportUrl());
vehicle.setVin(request.getVin());
vehicle.setOuterLength(request.getOuterLength());
vehicle.setOuterWidth(request.getOuterWidth());
vehicle.setOuterHeight(request.getOuterHeight());
vehicle.setApprovedLoadKg(request.getApprovedLoadKg());
vehicle.setTractionMassKg(request.getTractionMassKg());
vehicle.setEnergyType(request.getEnergyType());
vehicle.setBusinessRelation(request.getBusinessRelation());
vehicle.setCompulsoryScrapDate(request.getCompulsoryScrapDate());
vehicle.setCompulsoryScrapLongTerm(request.getCompulsoryScrapLongTerm());
// 行驶证四张图与车辆表四列一一对应,不再把「主页反面」塞进语义含糊的「副页」字段
vehicle.setDrivingLicenseNo(request.getDrivingLicenseNo());
vehicle.setDrivingLicenseImage(request.getDrivingLicenseImage());
vehicle.setDrivingLicenseMainBack(request.getDrivingLicenseMainBack());
vehicle.setDrivingLicenseViceFront(request.getDrivingLicenseViceFront());
vehicle.setDrivingLicenseViceBack(request.getDrivingLicenseViceBack());
vehicle.setDrivingLicenseStartDate(request.getDrivingLicenseStartDate());
vehicle.setDrivingLicenseEndDate(request.getDrivingLicenseEndDate());
vehicle.setDrivingLicenseLongTerm(request.getDrivingLicenseLongTerm());
vehicle.setRoadTransportCertNo(request.getRoadTransportCertNo());
vehicle.setRoadTransportCertStartDate(request.getRoadTransportCertStartDate());
vehicle.setRoadTransportCertEndDate(request.getRoadTransportCertEndDate());
vehicle.setRoadTransportCertLongTerm(request.getRoadTransportCertLongTerm());
vehicle.setRoadTransportCertImage(request.getRoadTransportCertImage());
// 机动车登记编号该列同样 NOT NULL:司机端是选填,缺值写空串而不是 null
vehicle.setRegistrationNo(Func.toStr(request.getRegistrationNo(), ""));
vehicle.setRegistrationImage(request.getRegistrationImage());
vehicle.setStatus(BladeConstant.DB_STATUS_NORMAL);
transportVehicleService.save(vehicle);
@@ -0,0 +1,403 @@
/**
* BladeX Commercial License Agreement
* Copyright (c) 2018-2099, https://bladex.cn. All rights reserved.
* <p>
* Use of this software is governed by the Commercial License Agreement
* obtained after purchasing a license from BladeX.
* <p>
* 1. This software is for development use only under a valid license
* from BladeX.
* <p>
* 2. Redistribution of this software's source code to any third party
* without a commercial license is strictly prohibited.
* <p>
* 3. Licensees may copyright their own code but cannot use segments
* from this software for such purposes. Copyright of this software
* remains with BladeX.
* <p>
* Using this software signifies agreement to this License, and the software
* must not be used for illegal purposes.
* <p>
* THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY. The author is
* not liable for any claims arising from secondary or illegal development.
* <p>
* Author: Chill Zhuang (bladejava@qq.com)
*/
package org.springblade.transport.support;
import com.fasterxml.jackson.databind.JsonNode;
import org.springblade.core.tool.utils.Func;
import org.springblade.transport.ocr.constant.BaiduOcrType;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 把百度 OCR 的原始结果归一化成业务字段
* <p>
* 百度返回的 {@code words_result} 键是**中文**(「号牌号码」「车辆识别代码」…),
* 同一含义在纸质证与电子证照之间还有不同写法。让小程序去认识这些中文键,
* 等于把百度接口的形状泄漏到前端,接口一改就要动多个端。
* <p>
* 归一化后下发的键与业务字段同名({@code plateNo}、{@code ownerName}…),前端拿到即可回填;
* 原始结果仍一并下发,归一化没覆盖到的字段不至于丢失。
* <p>
* <b>必须做别名容错的原因</b>:官方文档列举的是「号牌号码」「车辆识别代码」,
* 而实际返回里也出现过「车牌号码」「车辆识别代号」这类写法,电子行驶证还多出
* 「强制报废期止」「能源种类」等字段。写死单个键名的后果是**识别成功但什么也没填**——
* 不报错、不抛异常,最难排查。
*
* @author Chill
*/
public final class OcrFieldSupport {
/**
* {@code words_result} 里每个条目形如 {@code {"words": "桂A12345"}}
*/
private static final String WORDS = "words";
/**
* 表示「长期有效」的词:命中后不产出日期,而把对应的长期有效标志置 1
*/
private static final String LONG_TERM_TEXT = "长期";
/**
* 日期写法:4 位年 + 1~2 位月 + 1~2 位日,中间允许任意非数字分隔(年月日 / 点 / 横线)
*/
private static final Pattern DATE_PATTERN = Pattern.compile("(\\d{4})\\D+(\\d{1,2})\\D+(\\d{1,2})");
private OcrFieldSupport() {
}
/**
* 按证件类型把原始结果归一化
*
* @param type 证件类型
* @param side 证件面:front / back(目前两个面共用一套字段别名)
* @param result 百度原始返回
* @return 归一化字段(键与业务字段同名);识别不到任何字段时返回空 Map
*/
public static Map<String, Object> extract(BaiduOcrType type, String side, JsonNode result) {
Map<String, String> words = readWords(result);
Map<String, Object> fields = new LinkedHashMap<>();
if (words.isEmpty()) {
return fields;
}
for (Map.Entry<String, List<String>> entry : aliasTable(type).entrySet()) {
String raw = firstMatch(words, entry.getValue());
if (Func.isEmpty(raw)) {
continue;
}
putField(fields, entry.getKey(), raw);
}
// 外廓尺寸是唯一「一项要拆成三个字段」的,单独处理
splitOuterSize(words, fields);
// 道路运输证的「有效期」常写成一个区间:止期已由上面取到最后一段,
// 起期要从同一段文本里补,否则用户得照着一张图再敲一遍
splitRangeStart(words, fields, "有效期", "roadTransportCertStartDate");
return fields;
}
/**
* 从「有效期」这类区间文本里取出起期,补进对应的起期字段
*
* @param words 识别结果
* @param fields 结果集
* @param alias 区间所在的键名
* @param startKey 要补的起期字段名
*/
private static void splitRangeStart(Map<String, String> words, Map<String, Object> fields,
String alias, String startKey) {
if (fields.containsKey(startKey)) {
return;
}
String text = firstMatch(words, List.of(alias));
if (Func.isEmpty(text)) {
return;
}
List<String> dates = matchDates(text);
// 至少两段才算区间:只有一段说明那是止期本身,硬当起期会填错
if (dates.size() >= 2) {
fields.put(startKey, dates.get(0));
}
}
/**
* 读取 {@code words_result} 成「中文键 → 文本值」
*
* @param result 百度原始返回
* @return 键值对;结构不符时返回空 Map
*/
private static Map<String, String> readWords(JsonNode result) {
Map<String, String> words = new LinkedHashMap<>();
if (result == null) {
return words;
}
JsonNode wordsResult = result.path("words_result");
if (!wordsResult.isObject()) {
return words;
}
wordsResult.fields().forEachRemaining(entry -> {
JsonNode value = entry.getValue();
if (value == null || value.isNull()) {
return;
}
// 可能是 {"words": "..."},也可能直接是字符串
String text = value.isObject() ? value.path(WORDS).asText("") : value.asText("");
if (Func.isNotEmpty(text)) {
words.put(entry.getKey(), text.trim());
}
});
return words;
}
/**
* 取第一个命中的别名值
*
* @param words 识别结果
* @param aliases 候选键名,按优先级排列
* @return 命中值;都没命中返回 null
*/
private static String firstMatch(Map<String, String> words, List<String> aliases) {
for (String alias : aliases) {
String value = words.get(alias);
if (Func.isNotEmpty(value)) {
return value;
}
}
// 精确键名没命中时按「包含」兜底:百度偶有「核定载质量(kg)」这类带后缀的键
for (String alias : aliases) {
for (Map.Entry<String, String> entry : words.entrySet()) {
if (entry.getKey().contains(alias) && Func.isNotEmpty(entry.getValue())) {
return entry.getValue();
}
}
}
return null;
}
/**
* 写入一个字段,按字段语义做值归一化
* <p>
* 数字字段转数字、日期字段转 {@code yyyy-MM-dd};「长期」不产出日期,
* 而是把对应的长期有效标志置 1——否则「长期」会被当成一个非法日期塞进日期框。
*
* @param fields 结果集
* @param key 业务字段名
* @param raw 识别到的原始文本
*/
private static void putField(Map<String, Object> fields, String key, String raw) {
String text = raw.trim();
if (isDateField(key)) {
if (text.contains(LONG_TERM_TEXT)) {
String longTermKey = longTermKeyOf(key);
if (longTermKey != null) {
fields.put(longTermKey, 1);
}
return;
}
String date = normalizeDate(text, key);
if (date != null) {
fields.put(key, date);
}
return;
}
if (isNumberField(key)) {
Integer number = normalizeNumber(text);
if (number != null) {
fields.put(key, number);
}
return;
}
fields.put(key, text);
}
/**
* 「外廓尺寸」一项拆成外廓长/宽/高三个字段
* <p>
* 形如 {@code 5990×2300×3100},分隔符有 ×、x、*、空格等多种写法。
*
* @param words 识别结果
* @param fields 结果集
*/
private static void splitOuterSize(Map<String, String> words, Map<String, Object> fields) {
String size = firstMatch(words, List.of("外廓尺寸"));
if (Func.isEmpty(size)) {
return;
}
List<String> parts = new ArrayList<>();
for (String part : size.split("[^0-9]+")) {
if (Func.isNotEmpty(part)) {
parts.add(part);
}
}
// 必须正好三段才写回:只识别到两段时多半是漏识别,
// 按顺序硬填会把宽度填成长度、高度填成宽度
if (parts.size() != 3) {
return;
}
String[] keys = {"outerLength", "outerWidth", "outerHeight"};
for (int index = 0; index < keys.length; index++) {
Integer number = normalizeNumber(parts.get(index));
if (number != null) {
fields.put(keys[index], number);
}
}
}
/**
* 各证件类型的字段别名表
*
* @param type 证件类型
* @return 「业务字段名 → 百度键名候选」
*/
private static Map<String, List<String>> aliasTable(BaiduOcrType type) {
if (type == null) {
return Map.of();
}
String name = type.name();
if (BaiduOcrType.ID_CARD.name().equals(name)) {
return idCardAliases();
}
if (BaiduOcrType.DRIVING_LICENSE.name().equals(name)) {
return drivingLicenseAliases();
}
if (BaiduOcrType.VEHICLE_LICENSE.name().equals(name)) {
return vehicleLicenseAliases();
}
if (BaiduOcrType.ROAD_TRANSPORT_CERTIFICATE.name().equals(name)) {
return roadTransportAliases();
}
return Map.of();
}
private static Map<String, List<String>> idCardAliases() {
Map<String, List<String>> aliases = new LinkedHashMap<>();
aliases.put("realName", List.of("姓名"));
aliases.put("idCardNo", List.of("公民身份号码", "公民身份证号码", "身份证号", "身份证号码"));
aliases.put("idCardValidStart", List.of("签发日期", "有效起始日期", "有效期限起"));
aliases.put("idCardValidEnd", List.of("失效日期", "有效期限", "有效期限止"));
return aliases;
}
private static Map<String, List<String>> drivingLicenseAliases() {
Map<String, List<String>> aliases = new LinkedHashMap<>();
aliases.put("driverFileNo", List.of("档案编号", "证号"));
aliases.put("driverClass", List.of("准驾车型"));
aliases.put("driverValidStart", List.of("有效起始日期", "有效期起", "初次领证日期"));
aliases.put("driverValidEnd", List.of("有效期限", "有效期止", "有效期限止"));
return aliases;
}
private static Map<String, List<String>> vehicleLicenseAliases() {
Map<String, List<String>> aliases = new LinkedHashMap<>();
aliases.put("plateNo", List.of("号牌号码", "车牌号码", "号牌"));
aliases.put("vehicleType", List.of("车辆类型"));
aliases.put("ownerName", List.of("所有人"));
aliases.put("vin", List.of("车辆识别代码", "车辆识别代号", "车架号", "VIN"));
aliases.put("drivingLicenseNo", List.of("档案编号", "行驶证档案编号"));
aliases.put("plateColor", List.of("号牌颜色", "车牌颜色"));
aliases.put("energyType", List.of("能源种类", "能源类型"));
aliases.put("approvedLoadKg", List.of("核定载质量"));
aliases.put("tractionMassKg", List.of("准牵引总质量"));
aliases.put("compulsoryScrapDate", List.of("强制报废期止", "强制报废日期"));
aliases.put("drivingLicenseStartDate", List.of("注册日期", "发证日期"));
aliases.put("drivingLicenseEndDate", List.of("检验有效期止", "有效期止"));
return aliases;
}
private static Map<String, List<String>> roadTransportAliases() {
Map<String, List<String>> aliases = new LinkedHashMap<>();
aliases.put("roadTransportCertNo", List.of("道路运输证号", "运输证号"));
aliases.put("ownerName", List.of("业户名称", "所有人"));
aliases.put("roadTransportCertEndDate", List.of("有效期", "有效期止", "有效期至"));
return aliases;
}
private static boolean isDateField(String key) {
return key.endsWith("Date") || key.endsWith("ValidStart") || key.endsWith("ValidEnd");
}
private static boolean isNumberField(String key) {
return "approvedLoadKg".equals(key) || "tractionMassKg".equals(key);
}
private static String longTermKeyOf(String dateKey) {
if ("compulsoryScrapDate".equals(dateKey)) {
return "compulsoryScrapLongTerm";
}
if ("drivingLicenseEndDate".equals(dateKey)) {
return "drivingLicenseLongTerm";
}
if ("roadTransportCertEndDate".equals(dateKey)) {
return "roadTransportCertLongTerm";
}
return null;
}
/**
* 数字归一化:去掉「kg」「毫米」等单位与千分位后取整
*
* @param text 识别文本
* @return 整数;取不到合理数字返回 null
*/
private static Integer normalizeNumber(String text) {
String digits = text.replaceAll("[^0-9]", "");
// 载质量、外廓尺寸最多 6 位;过长说明识别串了字段,宁可不填也不填错
if (digits.isEmpty() || digits.length() > 6) {
return null;
}
return Integer.valueOf(digits);
}
/**
* 日期归一化
* <p>
* 覆盖 {@code 2015年03月12日} / {@code 2015.3.9} / {@code 2015-03-12} / {@code 20150312}
* 这几种写法,统一成 {@code yyyy-MM-dd}。
* <p>
* 区间(如「2015.03.12-2035.03.12」「2020-01-01 至 2030-01-01」)**按字段语义取一端**:
* 以 Start 结尾的取第一段,其余(止期类)取最后一段。取错一端不会报错,
* 只会把有效期起填成止——比不填更难发现。
*
* @param text 识别文本
* @param key 业务字段名,用于判断该取区间的哪一端
* @return 归一化日期;无法识别返回 null
*/
private static String normalizeDate(String text, String key) {
List<String> dates = matchDates(text);
if (!dates.isEmpty()) {
return key.endsWith("Start") ? dates.get(0) : dates.get(dates.size() - 1);
}
String compact = text.replaceAll("[^0-9]", "");
if (compact.length() == 8) {
return formatDate(compact);
}
return null;
}
/**
* 取出文本里所有日期(按出现顺序)
*
* @param text 识别文本
* @return 归一化后的日期列表
*/
private static List<String> matchDates(String text) {
List<String> dates = new ArrayList<>();
Matcher matcher = DATE_PATTERN.matcher(text);
while (matcher.find()) {
dates.add(String.format("%s-%02d-%02d", matcher.group(1),
Integer.parseInt(matcher.group(2)), Integer.parseInt(matcher.group(3))));
}
return dates;
}
private static String formatDate(String digits) {
return digits.substring(0, 4) + "-" + digits.substring(4, 6) + "-" + digits.substring(6, 8);
}
}