Case 14: Resume screening

This case corresponds to Scenario 14 in the JQuick-Java repository’s USE-CASES.md, targeting two-stage intelligent resume pre-screening in the HR SaaS domain. The first stage uses five hard gates — education, relevant years of experience, skill coverage (80%), salary band, and work location — plus two veto items (frequent job hopping and over-long career gaps) to determine the candidate set. The second stage scores only candidates who pass the hard screening across five dimensions — education and school, experience, skills, stability, and certifications/English — routing them to interview recommendation (STRONG / NORMAL), talent reserve (RESERVE), or rejection (REJECT). All gate and scoring criteria are driven by JQuick-Java XML rule proxies.

Industry scenario

Recruiting systems receive large volumes of resumes daily from referral, headhunter, and online channels (REFERRAL / HEADHUNTER / ONLINE). When posting a position, HR defines the required education, required years of experience, the required skill list, the salary band (lower/upper bound), and the job city. The resume side provides the candidate’s education (PHD / MASTER / BACHELOR / COLLEGE), school tier (985 / 211 / ORDINARY), years of relevant experience, skill match count, expected salary, current city and willingness to relocate, plus the number of job changes in the last 5 years, career-gap months, professional certifications, and English level (CET6 / CET4 / NONE).

The first stage of screening is hard gates plus stability vetoes: education is first converted to ranks (PhD 4 / Master’s 3 / Bachelor’s 2 / College 1), and the candidate passes when their rank is no lower than the position’s requirement; relevant years pass when no less than the required years; skill coverage passes at 80% (compared via cross-multiplication to avoid integer division precision issues); expected salary passes when it does not exceed the band upper bound and is no lower than 80% of the lower bound (malicious low-balling is also blocked); same city or willingness to relocate passes. All five must be satisfied to pass the hard gates; ≥4 job changes in the last 5 years or a gap of ≥24 months directly hits the stability veto.

The second stage is five-dimension scoring with a full score of 100: the education/school score gives 20 for exceeding the requirement by 2+ ranks, 15 for 1 rank higher, 10 for exactly meeting it, plus another +5 for 985 and +3 for 211; the experience score gives 25/20/12 for exceeding the required years by ≥5/≥2/≥0 years; the skill score gives 20/14/8 for coverage of 100%/80%/60%; the stability score gives 15/10/5 for 0/1/2 job changes, plus another 5 for a gap ≤3 months; certification +5, CET6 +5, CET4 +3.

The conclusion routing is strictly two-stage: hitting a veto item or failing any hard gate means REJECT, and the score does not change the rejection; after passing the hard screening, ≥75 points goes to interview, ≥55 to talent reserve, and the rest are rejected. Recommendation levels are further subdivided: ≥85 STRONG, ≥75 NORMAL, ≥55 RESERVE, and rejected candidates are forcibly set to NONE on the Service side. The decision’s reasons list item by item the unmet gates, the hit veto items, and interview/reserve recommendation explanations.

Business pain points

Mixing hard gates with scoring causes misjudgment: without separating the two stages, you can get “high score but education below requirement still goes to interview” or “5 job changes passes just because the composite score is high” — recruiting red lines get diluted by scores.
Gate criteria scattered across recruiting-channel codebases: thresholds like 80% skill coverage, 80% of the salary lower bound, and the 24-month gap are hard-coded in different services; adjusting standards for a job family requires changes in multiple places and re-releasing the HR SaaS.
Integer division in skill coverage has precision risks: directly dividing match count by required count loses the fraction — 4/5 becomes 0 in integer division — making boundary coverage judgments unreliable.
The five scoring dimensions are hard to tune and explain independently: if school, experience, skills, stability, and bonus items are mixed into one large method, HR cannot tune a single dimension’s weight or explain the candidate’s score composition to the hiring department.
Salary must guard against both exceeding the cap and low-balling: only checking that the expected salary does not exceed the upper bound lets malicious low-ballers through; the lower bound’s 80% must also be constrained, and such compound gates are hard to express with plain configuration tables.
SaaS multi-tenant environments coexist with legacy deployments: different customers have very different JDK versions and infrastructure; some still run JDK 8 / IT-innovation environments and cannot introduce heavy rule platforms, so a lightweight, embeddable rule solution with auditable decisions is needed.

Solution architecture

This case adopts the six-piece structure of “input model + decision result model + rule interface + XML rule script + Service orchestration + JUnit tests”. Hard gates, veto items, five-dimension scoring, and routing thresholds are all externalized in XML; the Service handles gate-by-gate determination, score aggregation, and rejection-reason assembly:

Layer	Responsibility	Files
Domain model	Resume elements, screening decision (hard-check result / total score / conclusion / recommendation level / reasons)	Resume.java, ScreeningDecision.java
Rule set & XML	5 hard gates + veto item + 5-dimension scoring + conclusion routing (14 methods)	ResumeScreeningRules.java, resume-screening.xml
Orchestration service	Gate-by-gate determination with veto reasons, score aggregation, recommendation level effective only for passers	ResumeScreeningService.java
Tests	6 candidate profiles (ideal, education below requirement, salary out of band, reserve, veto, relocation)	ResumeScreeningServiceTest.java

Rule method breakdown

The rule interface has 14 methods in total, with gate, veto, scoring, and routing methods each doing their own job:

Rule method	Criterion	Score / output
`eduRank`	Education ranking: PhD 4 / Master’s 3 / Bachelor’s 2 / College and others 1	1 ~ 4
`educationPass`	Passes when candidate’s education rank ≥ the position’s required rank	boolean
`experiencePass`	Passes when years of relevant experience ≥ the position’s required years	boolean
`skillPass`	Passes directly when required skill count ≤0; otherwise passes when match count ×100 ≥ required count ×80 (80% coverage)	boolean
`salaryPass`	Passes only when expected salary ≤ band upper bound and ≥ lower bound ×0.8	boolean
`locationPass`	Passes when the current city equals the job city, or the candidate accepts relocation	boolean
`hardReject`	Returns true for ≥4 job changes in the last 5 years or a gap of ≥24 months	boolean
`scoreEducation`	Exceeds by 2+ ranks 20 / 1 rank higher 15 / exactly meets 10; 985 adds +5, 211 adds +3	0 ~ 25
`scoreExperience`	Exceeding years ≥5 gives 25 / ≥2 gives 20 / ≥0 gives 12 / below gives 0	0 ~ 25
`scoreSkills`	Required count ≤0 or full coverage gives 20; coverage ≥80% gives 14; ≥60% gives 8; otherwise 0	0 ~ 20
`scoreStability`	0/1/2 job changes gives 15/10/5; gap ≤3 months adds +5	0 ~ 20
`scoreBonus`	Certification +5; CET6 +5; CET4 +3	0 ~ 10
`screeningResult`	Veto item or failed hard gate → REJECT; after passing, ≥75 INTERVIEW, ≥55 RESERVE, otherwise REJECT	Conclusion string
`recommendLevel`	≥85 STRONG; ≥75 NORMAL; ≥55 RESERVE; otherwise NONE	Recommendation level string

Code implementation (complete & runnable)

Place the following six files into the JQuick-Java test project using the original package names from the source: the two models go into com.github.paohaijiao.demo.model, the rule interface and test class go into com.github.paohaijiao.demo, the orchestration service goes into com.github.paohaijiao.demo.service, and the XML script goes into src/test/resources/demo/. Keeping directories and package names unchanged, run mvn test -Dtest=ResumeScreeningServiceTest at the project root.

Resume.java

package com.github.paohaijiao.demo.model;

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

/**
 * 候选人简历要素（初筛所需的硬性条件与画像）
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Resume {

    /**
     * 候选人姓名
     */
    private String candidateName;

    /**
     * 应聘岗位
     */
    private String positionName;

    /**
     * 候选人学历：PHD / MASTER / BACHELOR / COLLEGE
     */
    private String educationLevel;

    /**
     * 岗位要求学历
     */
    private String requiredEducation;

    /**
     * 毕业院校层次：985 / 211 / ORDINARY
     */
    private String schoolTier;

    /**
     * 相关工作年限
     */
    private int yearsExperience;

    /**
     * 岗位要求年限
     */
    private int requiredYears;

    /**
     * 技能匹配数
     */
    private int skillMatchCount;

    /**
     * 岗位要求技能数
     */
    private int requiredSkillCount;

    /**
     * 期望薪资
     */
    private double expectedSalary;

    /**
     * 薪资带宽下限
     */
    private double salaryMin;

    /**
     * 薪资带宽上限
     */
    private double salaryMax;

    /**
     * 所在城市
     */
    private String currentCity;

    /**
     * 工作城市
     */
    private String jobCity;

    /**
     * 是否接受异地调动
     */
    private boolean willingToRelocate;

    /**
     * 近 5 年跳槽次数
     */
    private int jobHoppingCount;

    /**
     * 职业空窗月数
     */
    private int gapMonths;

    /**
     * 是否持有岗位相关资格证
     */
    private boolean certified;

    /**
     * 英语水平：CET6 / CET4 / NONE
     */
    private String englishLevel;

    /**
     * 招聘渠道：REFERRAL / HEADHUNTER / ONLINE
     */
    private String channel;
}

ScreeningDecision.java

package com.github.paohaijiao.demo.model;

import lombok.Data;

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

/**
 * 简历初筛决策结果
 */
@Data
public class ScreeningDecision {

    /**
     * 候选人姓名
     */
    private String candidateName;

    /**
     * 综合评分（0-100）
     */
    private int totalScore;

    /**
     * 硬性条件是否全部满足
     */
    private boolean hardCheckPass;

    /**
     * 初筛结论：INTERVIEW-推荐面试 / RESERVE-人才储备 / REJECT-不通过
     */
    private String result;

    /**
     * 推荐等级：STRONG / NORMAL / RESERVE / NONE
     */
    private String recommendLevel;

    /**
     * 命中与不满足条件说明
     */
    private List<String> reasons = new ArrayList<String>();

    public void addReason(String reason) {
        this.reasons.add(reason);
    }
}

ResumeScreeningRules.java

package com.github.paohaijiao.demo;

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

/**
 * 场景 14：招聘简历智能初筛规则集
 * <p>
 * 规则按「硬性门槛 → 多维评分 → 结论路由」两段式拆分：
 * <ul>
 *     <li>门槛类：学历、年限、技能覆盖率、薪资带宽、工作地，任一不满足即淘汰</li>
 *     <li>评分类：学历院校、经验、技能、稳定性、资质英语五个维度</li>
 * </ul>
 * 规则脚本见 {@code src/test/resources/demo/resume-screening.xml}。
 */
public interface ResumeScreeningRules {

    int eduRank(@Param("education") String education);

    boolean educationPass(@Param("actualRank") int actualRank,
                          @Param("requiredRank") int requiredRank);

    boolean experiencePass(@Param("yearsExperience") int yearsExperience,
                           @Param("requiredYears") int requiredYears);

    boolean skillPass(@Param("skillMatchCount") int skillMatchCount,
                      @Param("requiredSkillCount") int requiredSkillCount);

    boolean salaryPass(@Param("expectedSalary") double expectedSalary,
                       @Param("salaryMin") double salaryMin,
                       @Param("salaryMax") double salaryMax);

    boolean locationPass(@Param("currentCity") String currentCity,
                         @Param("jobCity") String jobCity,
                         @Param("willingToRelocate") boolean willingToRelocate);

    boolean hardReject(@Param("jobHoppingCount") int jobHoppingCount,
                       @Param("gapMonths") int gapMonths);

    int scoreEducation(@Param("actualRank") int actualRank,
                       @Param("requiredRank") int requiredRank,
                       @Param("schoolTier") String schoolTier);

    int scoreExperience(@Param("yearsExperience") int yearsExperience,
                        @Param("requiredYears") int requiredYears);

    int scoreSkills(@Param("skillMatchCount") int skillMatchCount,
                    @Param("requiredSkillCount") int requiredSkillCount);

    int scoreStability(@Param("jobHoppingCount") int jobHoppingCount,
                       @Param("gapMonths") int gapMonths);

    int scoreBonus(@Param("certified") boolean certified,
                   @Param("englishLevel") String englishLevel);

    String screeningResult(@Param("totalScore") int totalScore,
                           @Param("hardCheckPass") boolean hardCheckPass,
                           @Param("hardReject") boolean hardReject);

    String recommendLevel(@Param("totalScore") int totalScore);
}

sume-screening.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.ResumeScreeningRules">
 <!-- 学历档位：博士 4 / 硕士 3 / 本科 2 / 大专 1 -->
    <java name="eduRank" returnClass="int">
        <![CDATA[
            int def eduRank(str:education) {
                if (education == "PHD") {
                    return 4;
                } else if (education == "MASTER") {
                    return 3;
                } else if (education == "BACHELOR") {
                    return 2;
                } else {
                    return 1;
                }
            }
        ]]>
    </java>
 <!-- 学历门槛 -->
    <java name="educationPass" returnClass="boolean">
        <![CDATA[
            boolean def educationPass(int:actualRank, int:requiredRank) {
                if (actualRank >= requiredRank) {
                    return true;
                } else {
                    return false;
                }
            }
        ]]>
    </java>
 <!-- 年限门槛 -->
    <java name="experiencePass" returnClass="boolean">
        <![CDATA[
            boolean def experiencePass(int:yearsExperience, int:requiredYears) {
                if (yearsExperience >= requiredYears) {
                    return true;
                } else {
                    return false;
                }
            }
        ]]>
    </java>
 <!-- 技能门槛：覆盖率达到 80% 即通过（交叉相乘避免除法精度问题） -->
    <java name="skillPass" returnClass="boolean">
        <![CDATA[
            boolean def skillPass(int:skillMatchCount, int:requiredSkillCount) {
                if (requiredSkillCount <= 0) {
                    return true;
                } else if (skillMatchCount * 100 >= requiredSkillCount * 80) {
                    return true;
                } else {
                    return false;
                }
            }
        ]]>
    </java>
 <!-- 薪资门槛：期望不超带宽上限，且不低于下限八成（恶意低报也不通过） -->
    <java name="salaryPass" returnClass="boolean">
        <![CDATA[
            boolean def salaryPass(double:expectedSalary, double:salaryMin, double:salaryMax) {
                if (expectedSalary <= salaryMax && expectedSalary >= salaryMin * 0.8) {
                    return true;
                } else {
                    return false;
                }
            }
        ]]>
    </java>
 <!-- 工作地门槛：同城或接受调动 -->
    <java name="locationPass" returnClass="boolean">
        <![CDATA[
            boolean def locationPass(str:currentCity, str:jobCity, boolean:willingToRelocate) {
                if (currentCity == jobCity || willingToRelocate) {
                    return true;
                } else {
                    return false;
                }
            }
        ]]>
    </java>
 <!-- 硬性否决：高频跳槽或超长空窗 -->
    <java name="hardReject" returnClass="boolean">
        <![CDATA[
            boolean def hardReject(int:jobHoppingCount, int:gapMonths) {
                if (jobHoppingCount >= 4 || gapMonths >= 24) {
                    return true;
                } else {
                    return false;
                }
            }
        ]]>
    </java>
 <!-- 学历院校评分：超档 20 / 高一档 15 / 达标 10，另加院校层次分 -->
    <java name="scoreEducation" returnClass="int">
        <![CDATA[
            int def scoreEducation(int:actualRank, int:requiredRank, str:schoolTier) {
                int score = 0;
                if (actualRank - requiredRank >= 2) {
                    score = 20;
                } else if (actualRank - requiredRank == 1) {
                    score = 15;
                } else if (actualRank == requiredRank) {
                    score = 10;
                }
                if (schoolTier == "985") {
                    score = score + 5;
                } else if (schoolTier == "211") {
                    score = score + 3;
                }
                return score;
            }
        ]]>
    </java>
 <!-- 经验评分：超出要求越多分越高 -->
    <java name="scoreExperience" returnClass="int">
        <![CDATA[
            int def scoreExperience(int:yearsExperience, int:requiredYears) {
                int extra = yearsExperience - requiredYears;
                if (extra >= 5) {
                    return 25;
                } else if (extra >= 2) {
                    return 20;
                } else if (extra >= 0) {
                    return 12;
                } else {
                    return 0;
                }
            }
        ]]>
    </java>
 <!-- 技能覆盖率评分：100% 得 20，80% 得 14，60% 得 8 -->
    <java name="scoreSkills" returnClass="int">
        <![CDATA[
            int def scoreSkills(int:skillMatchCount, int:requiredSkillCount) {
                if (requiredSkillCount <= 0) {
                    return 20;
                } else if (skillMatchCount >= requiredSkillCount) {
                    return 20;
                } else if (skillMatchCount * 100 >= requiredSkillCount * 80) {
                    return 14;
                } else if (skillMatchCount * 100 >= requiredSkillCount * 60) {
                    return 8;
                } else {
                    return 0;
                }
            }
        ]]>
    </java>
 <!-- 稳定性评分：跳槽 0/1/2 次得 15/10/5，空窗 3 个月内加 5 -->
    <java name="scoreStability" returnClass="int">
        <![CDATA[
            int def scoreStability(int:jobHoppingCount, int:gapMonths) {
                int score = 0;
                if (jobHoppingCount == 0) {
                    score = 15;
                } else if (jobHoppingCount == 1) {
                    score = 10;
                } else if (jobHoppingCount == 2) {
                    score = 5;
                }
                if (gapMonths <= 3) {
                    score = score + 5;
                }
                return score;
            }
        ]]>
    </java>
 <!-- 资质与英语加分：资格证 5 分，CET6 5 分 / CET4 3 分 -->
    <java name="scoreBonus" returnClass="int">
        <![CDATA[
            int def scoreBonus(boolean:certified, str:englishLevel) {
                int score = 0;
                if (certified) {
                    score = score + 5;
                }
                if (englishLevel == "CET6") {
                    score = score + 5;
                } else if (englishLevel == "CET4") {
                    score = score + 3;
                }
                return score;
            }
        ]]>
    </java>
 <!-- 初筛结论：硬否决与门槛优先，评分只决定面试与储备 -->
    <java name="screeningResult" returnClass="java.lang.String">
        <![CDATA[
            str def screeningResult(int:totalScore, boolean:hardCheckPass, boolean:hardReject) {
                if (hardReject) {
                    return "REJECT";
                } else if (hardCheckPass == false) {
                    return "REJECT";
                } else if (totalScore >= 75) {
                    return "INTERVIEW";
                } else if (totalScore >= 55) {
                    return "RESERVE";
                } else {
                    return "REJECT";
                }
            }
        ]]>
    </java>
 <!-- 推荐等级 -->
    <java name="recommendLevel" returnClass="java.lang.String">
        <![CDATA[
            str def recommendLevel(int:totalScore) {
                if (totalScore >= 85) {
                    return "STRONG";
                } else if (totalScore >= 75) {
                    return "NORMAL";
                } else if (totalScore >= 55) {
                    return "RESERVE";
                } else {
                    return "NONE";
                }
            }
        ]]>
    </java>
 style="--0:#7FDBCA"></javas>

ava">ResumeScreeningService.java