问卷考试系统设计（三）：评分引擎--维度计分、公式 DSL 与常模

public class Dimension {
    private String id;           // 维度ID,如 "anxiety"
    private String name;         // 维度名称,如 "焦虑"
    private String parentId;     // 父维度ID,null表示顶层
    private WeightStrategy weightStrategy; // 加权策略
}

public enum WeightStrategy {
    SUM,       // 简单求和,最常用
    AVERAGE,   // 平均值,题目数不等时用
    WEIGHTED   // 加权求和
}

public class DimensionScoreCalculator {

    public DimensionScoreResult calculate(String dimensionId,
                                          List<QuestionScore> questionScores,
                                          Dimension dimension) {
        List<QuestionScore> dimScores = questionScores.stream()
            .filter(q -> q.getDimensionId().equals(dimensionId))
            .collect(Collectors.toList());

        if (dimScores.isEmpty()) {
            return DimensionScoreResult.empty(dimensionId);
        }

        double rawScore;
        switch (dimension.getWeightStrategy()) {
            case SUM:
                rawScore = dimScores.stream()
                    .mapToDouble(QuestionScore::getScore).sum();
                break;
            case AVERAGE:
                rawScore = dimScores.stream()
                    .mapToDouble(QuestionScore::getScore)
                    .average().orElse(0.0);
                break;
            case WEIGHTED:
                rawScore = dimScores.stream()
                    .mapToDouble(q -> q.getScore() * q.getWeight()).sum();
                break;
            default:
                rawScore = dimScores.stream()
                    .mapToDouble(QuestionScore::getScore).sum();
        }

        DimensionScoreResult result = new DimensionScoreResult();
        result.setDimensionId(dimensionId);
        result.setRawScore(rawScore);
        result.setQuestionCount(dimScores.size());
        return result;
    }
}

public DimensionScoreResult calculateHierarchical(
        String dimensionId,
        Map<String, DimensionScoreResult> allScores,
        List<Dimension> allDimensions) {

    List<Dimension> children = allDimensions.stream()
        .filter(d -> dimensionId.equals(d.getParentId()))
        .collect(Collectors.toList());

    if (children.isEmpty()) {
        return allScores.get(dimensionId);  // 叶子节点
    }

    double parentScore = 0;
    int totalQuestions = 0;
    for (Dimension child : children) {
        DimensionScoreResult childResult =
            calculateHierarchical(child.getId(), allScores, allDimensions);
        parentScore += childResult.getRawScore();
        totalQuestions += childResult.getQuestionCount();
    }

    DimensionScoreResult result = new DimensionScoreResult();
    result.setDimensionId(dimensionId);
    result.setRawScore(parentScore);
    result.setQuestionCount(totalQuestions);
    return result;
}

public class QuestionScoreCalculator {

    public QuestionScore calculate(Question question, Answer answer) {
        if (answer == null || answer.isBlank()) {
            return QuestionScore.unanswered(question.getId());
        }

        int rawValue = answer.getSelectedValue();
        int minOption = question.getMinOptionValue();
        int maxOption = question.getMaxOptionValue();

        // 反向计分:score = minValue + maxValue - rawValue
        // 1-5 量表就是 6 - rawValue,0-3 量表就是 3 - rawValue
        int score;
        if (question.isReverse()) {
            score = minOption + maxOption - rawValue;
        } else {
            score = rawValue;
        }

        QuestionScore qs = new QuestionScore();
        qs.setQuestionId(question.getId());
        qs.setDimensionId(question.getDimensionId());
        qs.setRawValue(rawValue);     // 保留原始值
        qs.setScore(score);           // 计分后的值
        qs.setReversed(question.isReverse());
        return qs;
    }
}

{
  "questionnaire_code": "SAS",
  "norms": [
    {
      "name": "中国成人常模(2020)",
      "population": "18-65岁中国成人",
      "sample_size": 3200,
      "established": "2020",
      "dimensions": {
        "anxiety": { "mean": 29.78, "sd": 10.07 },
        "total": { "mean": 33.80, "sd": 12.54 }
      }
    },
    {
      "name": "大学生常模(2022)",
      "population": "18-25岁中国大学生",
      "sample_size": 1800,
      "established": "2022",
      "dimensions": {
        "anxiety": { "mean": 31.20, "sd": 9.85 },
        "total": { "mean": 35.60, "sd": 11.90 }
      }
    }
  ]
}

public ScoreResult score(Scale scale, AnswerSession session) {
    List<Question> questions = scale.getQuestions();
    Map<String, Answer> answers = session.getAnswersMap();

    // Step 1: 单题计分(含反向题处理)
    List<QuestionScore> questionScores = questions.stream()
        .map(q -> questionCalc.calculate(q, answers.get(q.getId())))
        .collect(Collectors.toList());

    // Step 2: 维度分计算(先叶子后父节点)
    Map<String, DimensionScoreResult> dimensionScores = new LinkedHashMap<>();
    for (Dimension dim : scale.getDimensions()) {
        boolean isLeaf = scale.getDimensions().stream()
            .noneMatch(d -> dim.getId().equals(d.getParentId()));
        if (isLeaf) {
            dimensionScores.put(dim.getId(),
                dimensionCalc.calculate(dim.getId(), questionScores, dim));
        }
    }
    for (Dimension dim : scale.getDimensions()) {
        if (dim.getParentId() == null) {
            dimensionScores.put(dim.getId(),
                hierarchicalCalc.calculateHierarchical(
                    dim.getId(), dimensionScores, scale.getDimensions()));
        }
    }

    // Step 3: 质量检测(测谎题、配对题一致性、模式检测)
    LieScaleResult lieResult = lieCalc.calculate(...);
    ConsistencyResult consistencyResult = consistencyChecker.checkPairedItems(...);
    PatternDetectionResult patternResult = patternDetector.detect(...);
    AnswerValidity validity = patternDetector.assessValidity(...);

    // Step 4: 标准分转换(使用常模)
    Map<String, StandardScoreResult> standardScores = new LinkedHashMap<>();
    Norm norm = normService.selectNorm(session.getUserId(), scale);
    for (Map.Entry<String, DimensionScoreResult> entry : dimensionScores.entrySet()) {
        double raw = entry.getValue().getRawScore();
        DimensionNorm dimNorm = norm.getDimensionNorm(entry.getKey());
        if (dimNorm != null) {
            double zScore = (raw - dimNorm.getMean()) / dimNorm.getSd();
            double tScore = 50 + 10 * zScore;
            standardScores.put(entry.getKey(),
                StandardScoreResult.of(raw, zScore, tScore, classifyTScore(tScore)));
        }
    }

    // Step 5: 组装最终结果
    ScoreResult result = new ScoreResult();
    result.setQuestionScores(questionScores);
    result.setDimensionScores(dimensionScores);
    result.setStandardScores(standardScores);
    result.setLieScaleResult(lieResult);
    result.setConsistencyResult(consistencyResult);
    result.setPatternResult(patternResult);
    result.setValidity(validity);
    return result;
}