案例 3：保险理赔核赔计算

本案例对应 JQuick-Java 仓库 USE-CASES.md 中的场景 3：保险理赔核赔计算（生产级样板），属于保险领域，解决医疗险、重疾险、意外险、车险四类产品理赔案件的自动化核赔：沿「等待期资格校验 → 赔付比例 → 免赔额 → 理算 → 产品封顶 → 风险评分 → 通道路由」的核赔实务链路，输出核赔结论、赔付金额与处置通道。

行业场景

理赔核赔是保险公司理赔流程中决定「赔不赔、赔多少、谁来赔」的关键环节。客户报案后，理赔系统需要采集产品类型（医疗险/重疾险/意外险/车险）、就诊医院等级（三甲/二甲/社区医院）、申请赔付金额、发票与费用清单金额、保单约定免赔额、已投保天数与产品等待期、近 1 年历史理赔次数、风控标记次数（黑名单、重复报案、影像异常等）、是否意外出险、材料是否齐全等报案要素。

核赔首先做资格校验：已投保天数小于等待期天数的案件不承担赔付责任，直接拒赔。通过资格校验后进入理算：赔付比例由产品类型、医院等级与是否意外三者交叉确定（医疗险三甲 85%、二甲 75%、社区 60%；重疾险 100%；意外险 90%；车险意外 90%、非意外 70%）；实际免赔额按产品调整（重疾 0 免赔、意外减半、且不超过申请金额）；赔付金额以申请金额与发票金额的较小者为费用基数，扣除免赔额后乘以赔付比例；最后执行各产品封顶线——医疗 20 万、重疾 50 万、车险 30 万、意外 10 万。

与理算并行的是反欺诈风控：风险分由历史理赔次数（每次 10 分）、风控标记次数（每次 25 分）与大额报案加分（10 万以上加 20、5 万以上加 10）构成，映射 LOW/MEDIUM/HIGH 三级；风控标记达到 2 次、或 1 次标记且金额达到 5 万元的案件必须转调查岗。

最终输出物包括核赔结论（APPROVE 正常赔付 / MANUAL_AUDIT 转人工审核 / REJECT 拒赔）、赔付金额、实际免赔额、赔付比例、风险分与风险等级、是否转调查、是否走小额快赔通道，以及逐条核赔说明（等待期拒赔、触达封顶线、材料不齐、快赔准入、理赔频次偏高等），供理赔员执行与向客户解释。其中材料齐全、赔款不超过 5000 元且无历史理赔的案件进入小额快赔通道，实现秒级赔付。

业务痛点

赔付比例矩阵复杂且调整频繁：4 类产品 × 3 档医院等级 × 是否意外的交叉比例硬编码在核心理赔系统中，新增合作医院网络、报备新产品或调整比例时都要修改核心代码并重新发版。
等待期、免赔、封顶线随条款变化：重疾 0 免赔、意外免赔减半、医疗 20 万/重疾 50 万/车险 30 万/意外 10 万的封顶线均来自产品报备条款，产品线增多后口径分散、极易错用旧条款造成错赔超赔。
理算链路长、环节耦合：等待期校验、比例、免赔、取小、乘法、封顶、防负任一环节写错都会直接导致赔付金额错误，混写在一个大方法里时难以逐段测试与定位。
风控路由与理算混写，骗赔漏拦：风控标记转调查、大额案件复核、小额快赔准入等条件与理算逻辑纠缠，出现「2 次风控标记 + 8 万大额报案」仍被自动赔付的漏洞风险。
结论不可解释：只有赔款数字、没有核赔说明，等待期拒赔、封顶减赔、材料不齐转人工等结论面对客户投诉与监管检查时难以举证。
保险核心老旧、信创推进难：大量寿险/财险核心仍运行在 JDK 8 与国产化配套 JDK 上，无法承受重型规则平台的独立中间件与数据库运维成本。

方案架构

本案例采用「领域模型 + 规则接口与 XML 规则脚本 + 编排服务 + 测试」的六件套结构：等待期、比例、免赔、封顶、风险、路由全部由 XML 规则外置管理，Service 负责串联核赔链路、封顶复核与核赔说明组装。

层次	职责	对应文件
领域模型	报案要素、核赔结果	`ClaimRequest.java`、`ClaimDecision.java`
规则集与 XML	等待期、比例、免赔、理算、封顶、风险、通道路由，口径全部外置	`ClaimAuditRules.java`、`claim-audit.xml`
编排服务	核赔链路串联、封顶复核、调查改判、核赔说明与金额精度处理	`ClaimAuditService.java`
测试	6 组核赔业务形态	`ClaimAuditServiceTest.java`

规则方法拆分

规则接口共 10 个方法，严格按照核赔实务链路排列，每个方法只做一件事：

规则方法	口径	分值/输出
`withinWaitingPeriod`	已投保天数小于等待期天数即处于等待期	boolean
`reimburseRatio`	产品类型 × 医院等级 × 是否意外：医疗 0.85/0.75/0.6、重疾 1.0、意外 0.9、车险 0.9/0.7	0.6 ~ 1.0
`actualDeductible`	重疾免赔为 0、意外免赔减半、且不超过申请金额	实际免赔额（元）
`payableAmount`	（min(申请金额, 发票金额) - 免赔额）× 比例，结果不为负	赔付金额（元）
`applyCap`	医疗 20 万 / 重疾 50 万 / 车险 30 万 / 意外 10 万封顶	封顶后金额（元）
`riskScore`	历史理赔次数 × 10 + 风控标记 × 25 + 大额报案加分（≥10 万 +20、≥5 万 +10）	风险分
`riskLevel`	≥60 HIGH / ≥30 MEDIUM / 否则 LOW	LOW / MEDIUM / HIGH
`needInvestigation`	风控标记 ≥2 次，或标记 ≥1 次且金额 ≥5 万	boolean
`auditResult`	等待期拒赔 → 标记转人工 → 未达免赔拒赔 → 材料齐通过 / 不齐转人工	APPROVE / MANUAL_AUDIT / REJECT
`fastTrack`	材料齐全 + 赔款 ≤5000 元 + 无历史理赔	boolean

代码实现（完整可运行）

将六个文件按源码原有包结构放入 Maven 工程的 src/test 对应目录：模型类 ClaimRequest.java、ClaimDecision.java 位于 com.github.paohaijiao.demo.model；规则接口 ClaimAuditRules.java 与测试类 ClaimAuditServiceTest.java 位于 com.github.paohaijiao.demo；编排服务 ClaimAuditService.java 位于 com.github.paohaijiao.demo.service；规则脚本 claim-audit.xml 位于 src/test/resources/demo/。六个文件的包名保持源码原样，模型类依赖 Lombok 的 @Data 注解。在工程根目录执行 mvn test -Dtest=ClaimAuditServiceTest 即可运行全部 6 个用例。

ClaimRequest.java

package com.github.paohaijiao.demo.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 理赔申请单（报案要素）
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ClaimRequest {

    /**
     * 理赔单号
     */
    private String claimNo;

    /**
     * 保单号
     */
    private String policyNo;

    /**
     * 被保险人
     */
    private String insuredName;

    /**
     * 产品类型：MEDICAL-医疗险 / CRITICAL_ILLNESS-重疾险 / ACCIDENT-意外险 / AUTO-车险
     */
    private String productType;

    /**
     * 就诊医院等级：THIRD_A-三甲 / SECOND_A-二甲 / COMMUNITY-社区医院
     */
    private String hospitalLevel;

    /**
     * 申请赔付金额（元）
     */
    private double claimAmount;

    /**
     * 发票/费用清单金额（元）
     */
    private double invoiceAmount;

    /**
     * 保单约定免赔额（元）
     */
    private double deductible;

    /**
     * 已投保天数
     */
    private int insuredDays;

    /**
     * 产品等待期天数
     */
    private int waitingPeriodDays;

    /**
     * 近 1 年历史理赔次数
     */
    private int priorClaimCount;

    /**
     * 风控标记次数（黑名单、重复报案、影像异常等）
     */
    private int fraudFlagCount;

    /**
     * 是否意外出险
     */
    private boolean isAccident;

    /**
     * 理赔材料是否齐全
     */
    private boolean documentComplete;
}

ClaimDecision.java

package com.github.paohaijiao.demo.model;

import lombok.Data;

import java.util.ArrayList;
import java.util.List;

/**
 * 理赔核赔结果
 */
@Data
public class ClaimDecision {

    /**
     * 理赔单号
     */
    private String claimNo;

    /**
     * 核赔结论：APPROVE-正常赔付 / MANUAL_AUDIT-转人工审核 / REJECT-拒赔
     */
    private String auditResult;

    /**
     * 赔付金额（元）
     */
    private double payableAmount;

    /**
     * 实际扣减的免赔额（元）
     */
    private double deductibleAmount;

    /**
     * 适用赔付比例
     */
    private double reimburseRatio;

    /**
     * 理赔风险分
     */
    private int riskScore;

    /**
     * 理赔风险等级：LOW / MEDIUM / HIGH
     */
    private String riskLevel;

    /**
     * 是否需要转调查岗
     */
    private boolean needInvestigation;

    /**
     * 是否走小额快赔通道
     */
    private boolean fastTrack;

    /**
     * 核赔说明，供理赔员与客户解释使用
     */
    private List<String> auditNotes = new ArrayList<String>();

    public void addAuditNote(String note) {
        this.auditNotes.add(note);
    }
}

ClaimAuditRules.java

package com.github.paohaijiao.demo;

import com.github.paohaijiao.xml.param.Param;

/**
 * 场景 3（生产级样板）：保险理赔核赔规则集
 * <p>
 * 规则按核赔实务拆分为「资格校验 → 比例与免赔额 → 赔付计算 → 封顶 → 风险与通道路由」，
 * 由 {@code ClaimAuditService} 串联执行，规则脚本见
 * {@code src/test/resources/demo/claim-audit.xml}。
 */
public interface ClaimAuditRules {

    /**
     * 是否处于等待期（等待期内不承担赔付责任）
     */
    boolean withinWaitingPeriod(@Param("insuredDays") int insuredDays,
                                @Param("waitingPeriodDays") int waitingPeriodDays);

    /**
     * 赔付比例：产品类型 × 医院等级 × 是否意外
     */
    double reimburseRatio(@Param("productType") String productType,
                          @Param("hospitalLevel") String hospitalLevel,
                          @Param("isAccident") boolean isAccident);

    /**
     * 实际扣减的免赔额（重疾免赔、意外减半、不超过申请金额）
     */
    double actualDeductible(@Param("productType") String productType,
                            @Param("deductible") double deductible,
                            @Param("claimAmount") double claimAmount);

    /**
     * 赔付金额 =（实际费用 - 免赔额）× 赔付比例
     */
    double payableAmount(@Param("claimAmount") double claimAmount,
                         @Param("invoiceAmount") double invoiceAmount,
                         @Param("ratio") double ratio,
                         @Param("deductibleAmount") double deductibleAmount);

    /**
     * 产品封顶线控制
     */
    double applyCap(@Param("payableAmount") double payableAmount,
                    @Param("productType") String productType);

    /**
     * 理赔风险分：历史理赔次数 + 风控标记 + 大额报案
     */
    int riskScore(@Param("priorClaimCount") int priorClaimCount,
                  @Param("fraudFlagCount") int fraudFlagCount,
                  @Param("claimAmount") double claimAmount);

    /**
     * 理赔风险等级：LOW / MEDIUM / HIGH
     */
    String riskLevel(@Param("riskScore") int riskScore);

    /**
     * 是否需要转调查岗
     */
    boolean needInvestigation(@Param("fraudFlagCount") int fraudFlagCount,
                              @Param("claimAmount") double claimAmount);

    /**
     * 核赔结论：APPROVE / MANUAL_AUDIT / REJECT
     */
    String auditResult(@Param("withinWaitingPeriod") boolean withinWaitingPeriod,
                       @Param("fraudFlagCount") int fraudFlagCount,
                       @Param("documentComplete") boolean documentComplete,
                       @Param("payableAmount") double payableAmount);

    /**
     * 是否走小额快赔通道
     */
    boolean fastTrack(@Param("payableAmount") double payableAmount,
                      @Param("documentComplete") boolean documentComplete,
                      @Param("priorClaimCount") int priorClaimCount);
}

udit.xml

class="header">

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE javas PUBLIC "-//PAOHAIJIAO//DTD API JAVA 1.0//EN"
        "classpath:paohaijiao/dtd/Jquick-java.dtd">
<javas namespace="com.github.paohaijiao.demo.ClaimAuditRules">
 <!-- 等待期校验：等待期内不承担赔付责任 -->
    <java name="withinWaitingPeriod" returnClass="boolean">
        <![CDATA[
            boolean def withinWaitingPeriod(int:insuredDays, int:waitingPeriodDays) {
                if (insuredDays < waitingPeriodDays) {
                    return true;
                } else {
                    return false;
                }
            }
        ]]>
    </java>
 <!-- 赔付比例：产品 × 医院等级 × 意外与否 -->
    <java name="reimburseRatio" returnClass="double">
        <![CDATA[
            double def reimburseRatio(str:productType, str:hospitalLevel, boolean:isAccident) {
                double ratio = 0.6;
                if (productType == "MEDICAL") {
                    if (hospitalLevel == "THIRD_A") {
                        ratio = 0.85;
                    } else if (hospitalLevel == "SECOND_A") {
                        ratio = 0.75;
                    } else {
                        ratio = 0.6;
                    }
                } else if (productType == "CRITICAL_ILLNESS") {
                    ratio = 1.0;
                } else if (productType == "ACCIDENT") {
                    ratio = 0.9;
                } else if (productType == "AUTO") {
                    if (isAccident) {
                        ratio = 0.9;
                    } else {
                        ratio = 0.7;
                    }
                }
                return ratio;
            }
        ]]>
    </java>
 <!-- 实际免赔额：重疾免赔额为 0，意外险减半，且不超过申请金额 -->
    <java name="actualDeductible" returnClass="double">
        <![CDATA[
            double def actualDeductible(str:productType, double:deductible, double:claimAmount) {
                double actual = deductible;
                if (productType == "CRITICAL_ILLNESS") {
                    actual = 0.0;
                } else if (productType == "ACCIDENT") {
                    actual = deductible * 0.5;
                }
                if (actual > claimAmount) {
                    actual = claimAmount;
                }
                return actual;
            }
        ]]>
    </java>
 <!-- 赔付金额计算：以发票金额与申请金额的较小者为费用基数 -->
    <java name="payableAmount" returnClass="double">
        <![CDATA[
            double def payableAmount(double:claimAmount, double:invoiceAmount, double:ratio, double:deductibleAmount) {
                double base = claimAmount;
                if (invoiceAmount < claimAmount) {
                    base = invoiceAmount;
                }
                double payable = (base - deductibleAmount) * ratio;
                if (payable < 0.0) {
                    payable = 0.0;
                }
                return payable;
            }
        ]]>
    </java>
 <!-- 产品封顶线 -->
    <java name="applyCap" returnClass="double">
        <![CDATA[
            double def applyCap(double:payableAmount, str:productType) {
                double capped = payableAmount;
                if (productType == "MEDICAL" && payableAmount > 200000.0) {
                    capped = 200000.0;
                } else if (productType == "CRITICAL_ILLNESS" && payableAmount > 500000.0) {
                    capped = 500000.0;
                } else if (productType == "AUTO" && payableAmount > 300000.0) {
                    capped = 300000.0;
                } else if (productType == "ACCIDENT" && payableAmount > 100000.0) {
                    capped = 100000.0;
                }
                return capped;
            }
        ]]>
    </java>
 <!-- 理赔风险分 -->
    <java name="riskScore" returnClass="int">
        <![CDATA[
            int def riskScore(int:priorClaimCount, int:fraudFlagCount, double:claimAmount) {
                int score = 0;
                score = score + priorClaimCount * 10;
                score = score + fraudFlagCount * 25;
                if (claimAmount >= 100000.0) {
                    score = score + 20;
                } else if (claimAmount >= 50000.0) {
                    score = score + 10;
                }
                return score;
            }
        ]]>
    </java>
 <!-- 理赔风险等级 -->
    <java name="riskLevel" returnClass="java.lang.String">
        <![CDATA[
            str def riskLevel(int:riskScore) {
                if (riskScore >= 60) {
                    return "HIGH";
                } else if (riskScore >= 30) {
                    return "MEDIUM";
                } else {
                    return "LOW";
                }
            }
        ]]>
    </java>
 <!-- 是否转调查岗 -->
    <java name="needInvestigation" returnClass="boolean">
        <![CDATA[
            boolean def needInvestigation(int:fraudFlagCount, double:claimAmount) {
                if (fraudFlagCount >= 2) {
                    return true;
                } else if (fraudFlagCount >= 1 && claimAmount >= 50000.0) {
                    return true;
                } else {
                    return false;
                }
            }
        ]]>
    </java>
 <!-- 核赔结论 -->
    <java name="auditResult" returnClass="java.lang.String">
        <![CDATA[
            str def auditResult(boolean:withinWaitingPeriod, int:fraudFlagCount, boolean:documentComplete, double:payableAmount) {
                if (withinWaitingPeriod) {
                    return "REJECT";
                } else if (fraudFlagCount >= 2) {
                    return "MANUAL_AUDIT";
                } else if (payableAmount <= 0.0) {
                    return "REJECT";
                } else if (documentComplete) {
                    return "APPROVE";
                } else {
                    return "MANUAL_AUDIT";
                }
            }
        ]]>
    </java>
 <!-- 小额快赔通道 -->
    <java name="fastTrack" returnClass="boolean">
        <![CDATA[
            boolean def fastTrack(double:payableAmount, boolean:documentComplete, int:priorClaimCount) {
                if (documentComplete && payableAmount <= 5000.0 && priorClaimCount == 0) {
                    return true;
                } else {
                    return false;
                }
            }
        ]]>
    </java>
 style="--0:#7FDBCA"></javas>

ClaimAuditService.java