点狮HRM-360度绩效评估系统设计与实现

一、业务背景与挑战

1.1 绩效管理的痛点

在企业人力资源管理中，绩效管理是最具挑战性的核心业务之一。传统的绩效管理模式存在诸多问题：

传统绩效评估的局限性：

• 单一视角：仅由上级评估，缺乏全面性
• 主观偏差：评估者个人偏好影响评估结果
• 反馈延迟：年度或季度评估，反馈周期过长
• 缺乏数据：凭印象评估，缺乏客观数据支撑
• 发展导向弱：重考核轻发展，难以促进员工成长
• 形式主义：评估流于形式，难以反映真实绩效

相关链接：

• 🌐 官网：http://www.dianshixinxi.com/
• 📱 演示站：http://cloud.dianshixinxi.com:90/
• 🎨 Gitee：https://gitee.com/glorylion/JFinalOA
• 💻 GitCode：https://gitcode.com/Glory_Lion/pointlion-cloud

1.2 360度评估的价值

什么是360度绩效评估： 360度绩效评估（360-Degree Feedback）是一种全方位的绩效评估方法，通过被评估者的上级、下级、同事、自评、客户等多维度角色进行评估，全面、客观地反映员工的工作表现和能力素质。

360度评估的价值：

1.3 技术挑战

实现360度评估系统面临的技术挑战：

二、整体架构设计

2.1 系统架构全景

┌─────────────────────────────────────────────────────────────────┐
│ 360度绩效评估系统 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 评估配置管理层 │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌─────────────────┐ │ │
│ │ │ 评估项目配置 │ │ 评估维度配置 │ │ 评估指标配置 │ │ │
│ │ │(Project) │ │(Dimension) │ │(Indicator) │ │ │
│ │ └──────────────┘ └──────────────┘ └─────────────────┘ │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌─────────────────┐ │ │
│ │ │ 评估流程配置 │ │ 权重规则配置 │ │ 评估者选择规则 │ │ │
│ │ │(Workflow) │ │(Weight Rule) │ │(Selector Rule) │ │ │
│ │ └──────────────┘ └──────────────┘ └─────────────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 评估执行引擎层 │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌─────────────────┐ │ │
│ │ │ 评估任务调度 │ │ 评估流程引擎 │ │ 进度监控引擎 │ │ │
│ │ │(Scheduler) │ │(Workflow) │ │(Monitor) │ │ │
│ │ └──────────────┘ └──────────────┘ └─────────────────┘ │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌─────────────────┐ │ │
│ │ │ 提醒通知引擎 │ │ 异常处理引擎 │ │ 权限控制引擎 │ │ │
│ │ │(Notifier) │ │(Handler) │ │(Permission) │ │ │
│ │ └──────────────┘ └──────────────┘ └─────────────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 数据计算分析层 │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌─────────────────┐ │ │
│ │ │ 评估数据聚合 │ │ 权重计算引擎 │ │ 异常值检测引擎 │ │ │
│ │ │(Aggregator) │ │(Weight Calc) │ │(Outlier Detect) │ │ │
│ │ └──────────────┘ └──────────────┘ └─────────────────┘ │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌─────────────────┐ │ │
│ │ │ 评分计算引擎 │ │ 结果排名引擎 │ │ 报表生成引擎 │ │ │
│ │ │(Score Calc) │ │(Ranking) │ │(Report) │ │ │
│ │ └──────────────┘ └──────────────┘ └─────────────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 结果应用层 │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌─────────────────┐ │ │
│ │ │ 结果反馈查看 │ │ 绩效改进计划 │ │ 人才盘点分析 │ │ │
│ │ │(Feedback) │ │(Improve Plan)│ │(Talent Review) │ │ │
│ │ └──────────────┘ └──────────────┘ └─────────────────┘ │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌─────────────────┐ │ │
│ │ │ 数据可视化 │ │ 趋势分析 │ │ 对比分析 │ │ │
│ │ │(Dashboard) │ │(Trend) │ │(Comparison) │ │ │
│ │ └──────────────┘ └──────────────┘ └─────────────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘

2.2 核心领域模型

评估项目模型（EvaluationProject）：

/**
* 360度评估项目
* 表示一次完整的360度评估活动
*/
@Data
@Entity
@Table(name = "hrm_evaluation_project")
public class EvaluationProject {
/**
* 项目ID
*/
@Id
@GeneratedValue(strategy = GenerationType.UUID)
private String id;

/**
* 项目名称
*/
private String name;

/**
* 项目编码
*/
@Column(unique = true, nullable = false)
private String code;

/**
* 项目描述
*/
@Lob
private String description;

/**
* 评估周期类型：ANNUAL(年度), QUARTERLY(季度),
* MONTHLY(月度), ON_DEMAND(按需)
*/
@Enumerated(EnumType.STRING)
private PeriodType periodType;

/**
* 评估开始时间
*/
private LocalDateTime startTime;

/**
* 评估结束时间
*/
private LocalDateTime endTime;

/**
* 项目状态：DRAFT(草稿), PENDING(待开始),
* IN_PROGRESS(进行中), COMPLETED(已完成), ARCHIVED(已归档)
*/
@Enumerated(EnumType.STRING)
private ProjectStatus status;

/**
* 适用范围类型：ALL(全员), DEPARTMENT(部门),
* POSITION(岗位), EMPLOYEE(指定员工)
*/
@Enumerated(EnumType.STRING)
private ScopeType scopeType;

/**
* 适用范围配置（JSON格式）
* 示例：{"departmentIds": ["dept001", "dept002"]}
*/
@Lob
private String scopeConfig;

/**
* 评估模板ID
*/
private String templateId;

/**
* 是否匿名评估
*/
private Boolean anonymous;

/**
* 是否启用自评
*/
private Boolean enableSelfEvaluation;

/**
* 是否启用上级评估
*/
private Boolean enableSuperiorEvaluation;

/**
* 是否启用下级评估
*/
private Boolean enableSubordinateEvaluation;

/**
* 是否启用同事评估
*/
private Boolean enablePeerEvaluation;

/**
* 是否启用客户评估
*/
private Boolean enableCustomerEvaluation;

/**
* 评估者最小数量
*/
private Integer minRaterCount;

/**
* 评估者最大数量
*/
private Integer maxRaterCount;

/**
* 创建人
*/
private String creator;

/**
* 创建时间
*/
private LocalDateTime createTime;

/**
* 更新时间
*/
private LocalDateTime updateTime;

/**
* 扩展配置（JSON格式）
*/
@Lob
private String extConfig;
}

/**
* 周期类型枚举
*/
public enum PeriodType {
/** 年度评估 */
ANNUAL,

/** 季度评估 */
QUARTERLY,

/** 月度评估 */
MONTHLY,

/** 按需评估 */
ON_DEMAND
}

/**
* 项目状态枚举
*/
public enum ProjectStatus {
/** 草稿 */
DRAFT,

/** 待开始 */
PENDING,

/** 进行中 */
IN_PROGRESS,

/** 已完成 */
COMPLETED,

/** 已归档 */
ARCHIVED
}

/**
* 范围类型枚举
*/
public enum ScopeType {
/** 全员 */
ALL,

/** 部门 */
DEPARTMENT,

/** 岗位 */
POSITION,

/** 指定员工 */
EMPLOYEE
}

评估维度模型（EvaluationDimension）：

/**
* 评估维度
* 表示评估的一级分类，如：工作业绩、工作能力、工作态度等
*/
@Data
@Entity
@Table(name = "hrm_evaluation_dimension")
public class EvaluationDimension {
/**
* 维度ID
*/
@Id
@GeneratedValue(strategy = GenerationType.UUID)
private String id;

/**
* 维度编码
*/
@Column(unique = true, nullable = false)
private String code;

/**
* 维度名称
*/
private String name;

/**
* 维度描述
*/
@Lob
private String description;

/**
* 所属模板ID
*/
private String templateId;

/**
* 父维度ID（支持多级维度）
*/
private String parentId;

/**
* 维度类型：CORE(核心维度), OPTIONAL(可选维度), CUSTOM(自定义维度)
*/
@Enumerated(EnumType.STRING)
private DimensionType type;

/**
* 维度权重（0-100）
*/
private BigDecimal weight;

/**
* 最小分值
*/
private Integer minScore;

/**
* 最大分值
*/
private Integer maxScore;

/**
* 显示顺序
*/
private Integer sortOrder;

/**
* 是否启用
*/
private Boolean enabled;

/**
* 创建时间
*/
private LocalDateTime createTime;

/**
* 更新时间
*/
private LocalDateTime updateTime;

/**
* 扩展配置（JSON格式）
*/
@Lob
private String extConfig;
}

/**
* 维度类型枚举
*/
public enum DimensionType {
/** 核心维度 */
CORE,

/** 可选维度 */
OPTIONAL,

/** 自定义维度 */
CUSTOM
}

评估指标模型（EvaluationIndicator）：

/**
* 评估指标
* 表示具体的评估项，如：工作完成质量、团队协作能力等
*/
@Data
@Entity
@Table(name = "hrm_evaluation_indicator")
public class EvaluationIndicator {
/**
* 指标ID
*/
@Id
@GeneratedValue(strategy = GenerationType.UUID)
private String id;

/**
* 指标编码
*/
@Column(unique = true, nullable = false)
private String code;

/**
* 指标名称
*/
private String name;

/**
* 指标描述
*/
@Lob
private String description;

/**
* 所属维度ID
*/
private String dimensionId;

/**
* 指标类型：QUANTITATIVE(定量), QUALITATIVE(定性)
*/
@Enumerated(EnumType.STRING)
private IndicatorType type;

/**
* 评分方式：SCORE(打分制), RANKING(等级制),
* CHOICE(选择制), TEXT(文本制)
*/
@Enumerated(EnumType.STRING)
private ScoringType scoringType;

/**
* 指标权重（0-100）
*/
private BigDecimal weight;

/**
* 最小分值
*/
private Integer minScore;

/**
* 最大分值
*/
private Integer maxScore;

/**
* 评分等级定义（JSON格式）
* 示例：[{"level":5,"name":"优秀","description":"表现卓越"}]
*/
@Lob
private String scoreLevels;

/**
* 是否必填
*/
private Boolean required;

/**
* 显示顺序
*/
private Integer sortOrder;

/**
* 是否启用
*/
private Boolean enabled;

/**
* 创建时间
*/
private LocalDateTime createTime;

/**
* 更新时间
*/
private LocalDateTime updateTime;

/**
* 扩展配置（JSON格式）
*/
@Lob
private String extConfig;
}

/**
* 指标类型枚举
*/
public enum IndicatorType {
/** 定量指标 */
QUANTITATIVE,

/** 定性指标 */
QUALITATIVE
}

/**
* 评分方式枚举
*/
public enum ScoringType {
/** 打分制 */
SCORE,

/** 等级制 */
RANKING,

/** 选择制 */
CHOICE,

/** 文本制 */
TEXT
}

评估记录模型（EvaluationRecord）：

/**
* 评估记录
* 存储一次评估的完整数据
*/
@Data
@Entity
@Table(name = "hrm_evaluation_record")
public class EvaluationRecord {
/**
* 记录ID
*/
@Id
@GeneratedValue(strategy = GenerationType.UUID)
private String id;

/**
* 评估项目ID
*/
private String projectId;

/**
* 被评估者ID
*/
private String evaluateeId;

/**
* 被评估者姓名
*/
private String evaluateeName;

/**
* 评估者ID
*/
private String raterId;

/**
* 评估者姓名
*/
private String raterName;

/**
* 评估关系类型：SELF(自评), SUPERIOR(上级),
* SUBORDINATE(下级), PEER(同事), CUSTOMER(客户)
*/
@Enumerated(EnumType.STRING)
private RaterType raterType;

/**
* 是否匿名
*/
private Boolean anonymous;

/**
* 评估状态：PENDING(待评估), IN_PROGRESS(评估中),
* COMPLETED(已完成), SKIPPED(已跳过)
*/
@Enumerated(EnumType.STRING)
private EvaluationStatus status;

/**
* 评估开始时间
*/
private LocalDateTime startTime;

/**
* 评估完成时间
*/
private LocalDateTime completeTime;

/**
* 评估用时（秒）
*/
private Long duration;

/**
* 总分
*/
private BigDecimal totalScore;

/**
* 各维度得分（JSON格式）
*/
@Lob
private String dimensionScores;

/**
* 评估备注
*/
@Lob
private String remark;

/**
* 创建时间
*/
private LocalDateTime createTime;

/**
* 更新时间
*/
private LocalDateTime updateTime;

/**
* 扩展配置（JSON格式）
*/
@Lob
private String extConfig;

/**
* 评估明细列表
*/
@OneToMany(mappedBy = "evaluationRecord", cascade = CascadeType.ALL)
private List<EvaluationDetail> details;
}

/**
* 评估关系类型枚举
*/
public enum RaterType {
/** 自评 */
SELF,

/** 上级 */
SUPERIOR,

/** 下级 */
SUBORDINATE,

/** 同事 */
PEER,

/** 客户 */
CUSTOMER
}

/**
* 评估状态枚举
*/
public enum EvaluationStatus {
/** 待评估 */
PENDING,

/** 评估中 */
IN_PROGRESS,

/** 已完成 */
COMPLETED,

/** 已跳过 */
SKIPPED
}

评估明细模型（EvaluationDetail）：

/**
* 评估明细
* 存储对单个指标的评分
*/
@Data
@Entity
@Table(name = "hrm_evaluation_detail")
public class EvaluationDetail {
/**
* 明细ID
*/
@Id
@GeneratedValue(strategy = GenerationType.UUID)
private String id;

/**
* 评估记录ID
*/
private String evaluationRecordId;

/**
* 关联的评估记录
*/
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "evaluation_record_id")
private EvaluationRecord evaluationRecord;

/**
* 指标ID
*/
private String indicatorId;

/**
* 维度ID
*/
private String dimensionId;

/**
* 指标名称
*/
private String indicatorName;

/**
* 维度名称
*/
private String dimensionName;

/**
* 评分
*/
private BigDecimal score;

/**
* 评语
*/
@Lob
private String comment;

/**
* 附件列表（JSON格式）
*/
@Lob
private String attachments;

/**
* 创建时间
*/
private LocalDateTime createTime;

/**
* 更新时间
*/
private LocalDateTime updateTime;
}

2.3 数据模型关系图

┌────────────────────────────────────────────────────────────────┐
│ 评估数据模型关系 │
├────────────────────────────────────────────────────────────────┤
│ │
│ EvaluationProject(评估项目) │
│ │ │
│ ├──► EvaluationTemplate(评估模板) │
│ │ │ │
│ │ ├──► EvaluationDimension(评估维度) │
│ │ │ │ │
│ │ │ └──► EvaluationIndicator(评估指标) │
│ │ │
│ └──► EvaluationRecord(评估记录) │
│ │ │
│ ├──► EvaluationDetail(评估明细) │
│ │ │ │
│ │ └──► Indicator, Dimension │
│ │ │
│ └──► EvaluationResult(评估结果) │
│ │ │
│ ├──► ResultDimension(维度结果) │
│ └──► ImprovementPlan(改进计划) │
│ │
└────────────────────────────────────────────────────────────────┘

三、核心模块实现

3.1 评估任务调度引擎

评估任务调度器：

/**
* 评估任务调度引擎
* 负责创建和分配评估任务
*/
@Component
@Slf4j
public class EvaluationTaskScheduler {

@Autowired
private EvaluationProjectRepository projectRepository;

@Autowired
private EvaluationRecordRepository recordRepository;

@Autowired
private RaterSelectorEngine raterSelectorEngine;

@Autowired
private ApplicationEventPublisher eventPublisher;

/**
* 启动评估项目
*
* @param projectId 项目ID
* @return 启动结果
*/
@Transactional(rollbackFor = Exception.class)
public LaunchResult launchProject(String projectId) {
log.info("启动评估项目: projectId={}", projectId);

try {
// 1. 获取项目信息
EvaluationProject project = projectRepository.findById(projectId)
.orElseThrow(() -> new BusinessException("评估项目不存在"));

// 2. 验证项目状态
if (project.getStatus() != ProjectStatus.PENDING) {
throw new BusinessException("项目状态不允许启动");
}

// 3. 获取被评估者列表
List<Employee> evaluatees = getEvaluatees(project);
log.info("获取被评估者列表: count={}", evaluatees.size());

// 4. 为每个被评估者创建评估任务
List<EvaluationRecord> allRecords = new ArrayList<>();
int successCount = 0;
int failCount = 0;

for (Employee evaluatee : evaluatees) {
try {
// 选择评估者
List<RaterSelectionResult> raterSelections =
raterSelectorEngine.selectRaters(project, evaluatee);

// 验证评估者数量
if (raterSelections.size() < project.getMinRaterCount()) {
log.warn("评估者数量不足: evaluateeId={}, raterCount={}",
evaluatee.getId(), raterSelections.size());
failCount++;
continue;
}

// 创建评估记录
for (RaterSelectionResult selection : raterSelections) {
EvaluationRecord record = createEvaluationRecord(
project, evaluatee, selection
);
allRecords.add(record);
}

successCount++;

} catch (Exception e) {
log.error("创建评估任务失败: evaluateeId={}, error={}",
evaluatee.getId(), e.getMessage());
failCount++;
}
}

// 5. 批量保存评估记录
if (!allRecords.isEmpty()) {
recordRepository.saveAll(allRecords);
}

// 6. 更新项目状态
project.setStatus(ProjectStatus.IN_PROGRESS);
project.setUpdateTime(LocalDateTime.now());
projectRepository.save(project);

// 7. 发布项目启动事件
eventPublisher.publishEvent(new ProjectLaunchedEvent(
projectId, evaluatees.size(), allRecords.size()
));

log.info("评估项目启动成功: projectId={}, successCount={}, failCount={}",
projectId, successCount, failCount);

return LaunchResult.builder()
.projectId(projectId)
.success(successCount)
.failed(failCount)
.totalRecords(allRecords.size())
.build();

} catch (Exception e) {
log.error("启动评估项目失败: projectId={}, error={}", projectId, e.getMessage());
throw new BusinessException("启动评估项目失败", e);
}
}

/**
* 获取被评估者列表
*/
private List<Employee> getEvaluatees(EvaluationProject project) {
ScopeType scopeType = project.getScopeType();
String scopeConfig = project.getScopeConfig();

// 解析范围配置
JSONObject scopeJson = JSON.parseObject(scopeConfig);

switch (scopeType) {
case ALL:
// 获取所有在职员工
return employeeRepository.findAllActiveEmployees();

case DEPARTMENT:
// 获取指定部门的员工
List<String> departmentIds = scopeJson.getJSONArray("departmentIds")
.toJavaList(String.class);
return employeeRepository.findByDepartmentIds(departmentIds);

case POSITION:
// 获取指定岗位的员工
List<String> positionIds = scopeJson.getJSONArray("positionIds")
.toJavaList(String.class);
return employeeRepository.findByPositionIds(positionIds);

case EMPLOYEE:
// 获取指定员工
List<String> employeeIds = scopeJson.getJSONArray("employeeIds")
.toJavaList(String.class);
return employeeRepository.findByEmployeeIds(employeeIds);

default:
throw new BusinessException("不支持的评估范围类型: " + scopeType);
}
}

/**
* 创建评估记录
*/
private EvaluationRecord createEvaluationRecord(
EvaluationProject project,
Employee evaluatee,
RaterSelectionResult selection
) {
EvaluationRecord record = new EvaluationRecord();
record.setProjectId(project.getId());
record.setEvaluateeId(evaluatee.getId());
record.setEvaluateeName(evaluatee.getName());
record.setRaterId(selection.getRater().getId());
record.setRaterName(selection.getRater().getName());
record.setRaterType(selection.getRaterType());
record.setAnonymous(project.getAnonymous() && selection.isAnonymous());
record.setStatus(EvaluationStatus.PENDING);
record.setCreateTime(LocalDateTime.now());

return record;
}

/**
* 发送评估提醒
*
* @param recordId 评估记录ID
*/
public void sendEvaluationReminder(String recordId) {
EvaluationRecord record = recordRepository.findById(recordId)
.orElseThrow(() -> new BusinessException("评估记录不存在"));

// 发送提醒通知
notificationService.sendEvaluationReminder(record);

// 记录提醒日志
reminderLogRepository.save(ReminderLog.builder()
.recordId(recordId)
.raterId(record.getRaterId())
.reminderTime(LocalDateTime.now())
.build());
}
}

/**
* 评估者选择结果
*/
@Data
@Builder
public class RaterSelectionResult {
/**
* 评估者
*/
private Employee rater;

/**
* 评估关系类型
*/
private RaterType raterType;

/**
* 是否匿名
*/
private boolean anonymous;

/**
* 权重
*/
private BigDecimal weight;
}

评估者选择引擎：

/**
* 评估者选择引擎
* 根据配置规则选择合适的评估者
*/
@Component
@Slf4j
public class RaterSelectorEngine {

@Autowired
private EmployeeRepository employeeRepository;

@Autowired
private OrganizationService organizationService;

/**
* 选择评估者
*
* @param project 评估项目
* @param evaluatee 被评估者
* @return 评估者选择结果列表
*/
public List<RaterSelectionResult> selectRaters(
EvaluationProject project,
Employee evaluatee
) {
List<RaterSelectionResult> results = new ArrayList<>();

// 1. 自评
if (project.getEnableSelfEvaluation()) {
results.add(RaterSelectionResult.builder()
.rater(evaluatee)
.raterType(RaterType.SELF)
.anonymous(false)
.weight(BigDecimal.ZERO) // 自评不参与加权计算
.build());
}

// 2. 上级评估
if (project.getEnableSuperiorEvaluation()) {
List<Employee> superiors = getSuperiors(evaluatee);
for (Employee superior : superiors) {
results.add(RaterSelectionResult.builder()
.rater(superior)
.raterType(RaterType.SUPERIOR)
.anonymous(false) // 上级评估不匿名
.weight(new BigDecimal("0.4")) // 上级权重40%
.build());
}
}

// 3. 下级评估
if (project.getEnableSubordinateEvaluation()) {
List<Employee> subordinates = getSubordinates(evaluatee);
int maxCount = Math.min(subordinates.size(), project.getMaxRaterCount() / 3);
for (int i = 0; i < maxCount; i++) {
results.add(RaterSelectionResult.builder()
.rater(subordinates.get(i))
.raterType(RaterType.SUBORDINATE)
.anonymous(true) // 下级评估匿名
.weight(new BigDecimal("0.2")) // 下级权重20%
.build());
}
}

// 4. 同事评估
if (project.getEnablePeerEvaluation()) {
List<Employee> peers = getPeers(evaluatee);
int maxCount = Math.min(peers.size(), project.getMaxRaterCount() / 3);
// 随机选择同事
Collections.shuffle(peers);
for (int i = 0; i < maxCount; i++) {
results.add(RaterSelectionResult.builder()
.rater(peers.get(i))
.raterType(RaterType.PEER)
.anonymous(true) // 同事评估匿名
.weight(new BigDecimal("0.2")) // 同事权重20%
.build());
}
}

// 5. 客户评估
if (project.getEnableCustomerEvaluation()) {
List<Employee> customers = getCustomers(evaluatee);
for (Employee customer : customers) {
results.add(RaterSelectionResult.builder()
.rater(customer)
.raterType(RaterType.CUSTOMER)
.anonymous(true) // 客户评估匿名
.weight(new BigDecimal("0.2")) // 客户权重20%
.build());
}
}

// 验证评估者数量
if (results.size() < project.getMinRaterCount()) {
log.warn("评估者数量不足: evaluateeId={}, count={}, min={}",
evaluatee.getId(), results.size(), project.getMinRaterCount());
}

return results;
}

/**
* 获取上级
*/
private List<Employee> getSuperiors(Employee employee) {
// 获取直接上级
Employee directSuperior = employeeRepository.findById(employee.getSuperiorId())
.orElse(null);

if (directSuperior == null) {
return Collections.emptyList();
}

List<Employee> superiors = new ArrayList<>();
superiors.add(directSuperior);

// 可选：获取更高级别的上级
if (directSuperior.getSuperiorId() != null) {
Employee grandSuperior = employeeRepository.findById(directSuperior.getSuperiorId())
.orElse(null);
if (grandSuperior != null) {
superiors.add(grandSuperior);
}
}

return superiors;
}

/**
* 获取下级
*/
private List<Employee> getSubordinates(Employee employee) {
return employeeRepository.findBySuperiorId(employee.getId());
}

/**
* 获取同事
*/
private List<Employee> getPeers(Employee employee) {
// 获取同一部门的其他同事
List<Employee> departmentEmployees = employeeRepository
.findByDepartmentId(employee.getDepartmentId());

// 排除自己和上级下级关系
return departmentEmployees.stream()
.filter(e -> !e.getId().equals(employee.getId()))
.filter(e -> !e.getSuperiorId().equals(employee.getId()))
.filter(e -> !employee.getId().equals(e.getSuperiorId()))
.collect(Collectors.toList());
}

/**
* 获取客户
*/
private List<Employee> getCustomers(Employee employee) {
// 根据业务场景获取客户
// 这里简化处理，实际可能需要从客户管理系统获取
return Collections.emptyList();
}
}

3.2 评估数据聚合引擎

评估数据聚合器：

/**
* 评估数据聚合引擎
* 负责聚合多个评估者的评分，计算最终得分
*/
@Component
@Slf4j
public class EvaluationDataAggregator {

@Autowired
private EvaluationRecordRepository recordRepository;

@Autowired
private EvaluationDetailRepository detailRepository;

/**
* 聚合评估数据
*
* @param projectId 项目ID
* @param evaluateeId 被评估者ID
* @return 聚合结果
*/
@Transactional(rollbackFor = Exception.class)
public EvaluationAggregationResult aggregateEvaluation(
String projectId,
String evaluateeId
) {
log.info("开始聚合评估数据: projectId={}, evaluateeId={}", projectId, evaluateeId);

try {
// 1. 获取所有已完成的评估记录
List<EvaluationRecord> records = recordRepository
.findByProjectIdAndEvaluateeIdAndStatus(
projectId, evaluateeId, EvaluationStatus.COMPLETED
);

if (records.isEmpty()) {
log.warn("没有已完成的评估记录: projectId={}, evaluateeId={}",
projectId, evaluateeId);
return EvaluationAggregationResult.empty();
}

// 2. 聚合维度得分
Map<String, DimensionAggregation> dimensionAggregations =
aggregateDimensionScores(records);

// 3. 聚合指标得分
Map<String, IndicatorAggregation> indicatorAggregations =
aggregateIndicatorScores(records);

// 4. 按评估关系类型聚合
Map<RaterType, RaterTypeAggregation> raterTypeAggregations =
aggregateByRaterType(records);

// 5. 计算总分
BigDecimal totalScore = calculateTotalScore(dimensionAggregations);

// 6. 聚合评语
List<String> comments = aggregateComments(records);

// 7. 构建聚合结果
EvaluationAggregationResult result = EvaluationAggregationResult.builder()
.projectId(projectId)
.evaluateeId(evaluateeId)
.totalScore(totalScore)
.dimensionAggregations(new ArrayList<>(dimensionAggregations.values()))
.indicatorAggregations(new ArrayList<>(indicatorAggregations.values()))
.raterTypeAggregations(new ArrayList<>(raterTypeAggregations.values()))
.comments(comments)
.raterCount(records.size())
.aggregateTime(LocalDateTime.now())
.build();

log.info("评估数据聚合完成: projectId={}, evaluateeId={}, totalScore={}",
projectId, evaluateeId, totalScore);

return result;

} catch (Exception e) {
log.error("聚合评估数据失败: projectId={}, evaluateeId={}, error={}",
projectId, evaluateeId, e.getMessage());
throw new AggregationException("聚合评估数据失败", e);
}
}

/**
* 聚合维度得分
*/
private Map<String, DimensionAggregation> aggregateDimensionScores(
List<EvaluationRecord> records
) {
Map<String, DimensionAggregation> aggregations = new LinkedHashMap<>();

// 按维度分组聚合
for (EvaluationRecord record : records) {
String dimensionScores = record.getDimensionScores();
if (StringUtils.isBlank(dimensionScores)) {
continue;
}

// 解析维度得分
JSONObject scoresJson = JSON.parseObject(dimensionScores);

for (String dimensionId : scoresJson.keySet()) {
BigDecimal score = scoresJson.getBigDecimal(dimensionId);

DimensionAggregation aggregation = aggregations.computeIfAbsent(
dimensionId,
k -> DimensionAggregation.builder()
.dimensionId(dimensionId)
.scores(new ArrayList<>())
.build()
);

aggregation.getScores().add(score);
}
}

// 计算统计值
for (DimensionAggregation aggregation : aggregations.values()) {
List<BigDecimal> scores = aggregation.getScores();

if (!scores.isEmpty()) {
// 计算平均分（加权平均）
BigDecimal avgScore = calculateWeightedAverage(scores);
aggregation.setAverageScore(avgScore);

// 计算最高分
BigDecimal maxScore = scores.stream().max(BigDecimal::compareTo)
.orElse(BigDecimal.ZERO);
aggregation.setMaxScore(maxScore);

// 计算最低分
BigDecimal minScore = scores.stream().min(BigDecimal::compareTo)
.orElse(BigDecimal.ZERO);
aggregation.setMinScore(minScore);

// 计算标准差
BigDecimal stdDev = calculateStandardDeviation(scores, avgScore);
aggregation.setStandardDeviation(stdDev);
}
}

return aggregations;
}

/**
* 聚合指标得分
*/
private Map<String, IndicatorAggregation> aggregateIndicatorScores(
List<EvaluationRecord> records
) {
Map<String, IndicatorAggregation> aggregations = new LinkedHashMap<>();

// 获取所有评估明细
List<String> recordIds = records.stream()
.map(EvaluationRecord::getId)
.collect(Collectors.toList());

List<EvaluationDetail> details = detailRepository.findByRecordIds(recordIds);

// 按指标分组聚合
Map<String, List<EvaluationDetail>> groupedDetails = details.stream()
.collect(Collectors.groupingBy(EvaluationDetail::getIndicatorId));

for (Map.Entry<String, List<EvaluationDetail>> entry : groupedDetails.entrySet()) {
String indicatorId = entry.getKey();
List<EvaluationDetail> indicatorDetails = entry.getValue();

// 提取评分
List<BigDecimal> scores = indicatorDetails.stream()
.map(EvaluationDetail::getScore)
.filter(Objects::nonNull)
.collect(Collectors.toList());

if (scores.isEmpty()) {
continue;
}

IndicatorAggregation aggregation = IndicatorAggregation.builder()
.indicatorId(indicatorId)
.indicatorName(indicatorDetails.get(0).getIndicatorName())
.dimensionId(indicatorDetails.get(0).getDimensionId())
.dimensionName(indicatorDetails.get(0).getDimensionName())
.scores(scores)
.build();

// 计算统计值
BigDecimal avgScore = calculateWeightedAverage(scores);
aggregation.setAverageScore(avgScore);

BigDecimal maxScore = scores.stream().max(BigDecimal::compareTo)
.orElse(BigDecimal.ZERO);
aggregation.setMaxScore(maxScore);

BigDecimal minScore = scores.stream().min(BigDecimal::compareTo)
.orElse(BigDecimal.ZERO);
aggregation.setMinScore(minScore);

aggregations.put(indicatorId, aggregation);
}

return aggregations;
}

/**
* 按评估关系类型聚合
*/
private Map<RaterType, RaterTypeAggregation> aggregateByRaterType(
List<EvaluationRecord> records
) {
Map<RaterType, RaterTypeAggregation> aggregations = new LinkedHashMap<>();

// 按评估关系类型分组
Map<RaterType, List<EvaluationRecord>> groupedRecords = records.stream()
.collect(Collectors.groupingBy(EvaluationRecord::getRaterType));

for (Map.Entry<RaterType, List<EvaluationRecord>> entry : groupedRecords.entrySet()) {
RaterType raterType = entry.getKey();
List<EvaluationRecord> typeRecords = entry.getValue();

// 提取总分
List<BigDecimal> scores = typeRecords.stream()
.map(EvaluationRecord::getTotalScore)
.filter(Objects::nonNull)
.collect(Collectors.toList());

if (scores.isEmpty()) {
continue;
}

// 计算平均分
BigDecimal avgScore = scores.stream()
.reduce(BigDecimal.ZERO, BigDecimal::add)
.divide(new BigDecimal(scores.size()), 2, RoundingMode.HALF_UP);

RaterTypeAggregation aggregation = RaterTypeAggregation.builder()
.raterType(raterType)
.raterCount(typeRecords.size())
.averageScore(avgScore)
.scores(scores)
.build();

aggregations.put(raterType, aggregation);
}

return aggregations;
}

/**
* 计算总分
*/
private BigDecimal calculateTotalScore(
Map<String, DimensionAggregation> dimensionAggregations
) {
// 获取维度权重配置
// 这里简化处理，实际应从配置获取
Map<String, BigDecimal> dimensionWeights = getDimensionWeights();

BigDecimal totalScore = BigDecimal.ZERO;
BigDecimal totalWeight = BigDecimal.ZERO;

for (DimensionAggregation aggregation : dimensionAggregations.values()) {
BigDecimal weight = dimensionWeights.getOrDefault(
aggregation.getDimensionId(),
new BigDecimal("1.0")
);

totalScore = totalScore.add(
aggregation.getAverageScore().multiply(weight)
);
totalWeight = totalWeight.add(weight);
}

// 归一化
if (totalWeight.compareTo(BigDecimal.ZERO) > 0) {
totalScore = totalScore.divide(totalWeight, 2, RoundingMode.HALF_UP);
}

return totalScore;
}

/**
* 聚合评语
*/
private List<String> aggregateComments(List<EvaluationRecord> records) {
List<String> comments = new ArrayList<>();

// 获取所有评估明细
List<String> recordIds = records.stream()
.map(EvaluationRecord::getId)
.collect(Collectors.toList());

List<EvaluationDetail> details = detailRepository.findByRecordIds(recordIds);

// 提取评语
for (EvaluationDetail detail : details) {
if (StringUtils.isNotBlank(detail.getComment())) {
comments.add(detail.getComment());
}
}

return comments;
}

/**
* 计算加权平均
*/
private BigDecimal calculateWeightedAverage(List<BigDecimal> values) {
if (values.isEmpty()) {
return BigDecimal.ZERO;
}

BigDecimal sum = values.stream()
.reduce(BigDecimal.ZERO, BigDecimal::add);

return sum.divide(
new BigDecimal(values.size()),
2,
RoundingMode.HALF_UP
);
}

/**
* 计算标准差
*/
private BigDecimal calculateStandardDeviation(
List<BigDecimal> values,
BigDecimal mean
) {
if (values.isEmpty()) {
return BigDecimal.ZERO;
}

// 计算方差
BigDecimal variance = values.stream()
.map(value -> value.subtract(mean).pow(2))
.reduce(BigDecimal.ZERO, BigDecimal::add)
.divide(new BigDecimal(values.size()), 2, RoundingMode.HALF_UP);

// 计算标准差（方差开方）
return new BigDecimal(Math.sqrt(variance.doubleValue()))
.setScale(2, RoundingMode.HALF_UP);
}

/**
* 获取维度权重
*/
private Map<String, BigDecimal> getDimensionWeights() {
// 从配置或数据库获取
// 这里返回默认权重
Map<String, BigDecimal> weights = new HashMap<>();
weights.put("WORK_PERFORMANCE", new BigDecimal("0.4")); // 工作业绩40%
weights.put("WORK_ABILITY", new BigDecimal("0.3")); // 工作能力30%
weights.put("WORK_ATTITUDE", new BigDecimal("0.2")); // 工作态度20%
weights.put("TEAM_COLLABORATION", new BigDecimal("0.1")); // 团队协作10%
return weights;
}
}

/**
* 评估聚合结果
*/
@Data
@Builder
public class EvaluationAggregationResult {
/**
* 项目ID
*/
private String projectId;

/**
* 被评估者ID
*/
private String evaluateeId;

/**
* 总分
*/
private BigDecimal totalScore;

/**
* 维度聚合结果列表
*/
private List<DimensionAggregation> dimensionAggregations;

/**
* 指标聚合结果列表
*/
private List<IndicatorAggregation> indicatorAggregations;

/**
* 评估关系类型聚合结果列表
*/
private List<RaterTypeAggregation> raterTypeAggregations;

/**
* 评语列表
*/
private List<String> comments;

/**
* 评估者数量
*/
private Integer raterCount;

/**
* 聚合时间
*/
private LocalDateTime aggregateTime;

public static EvaluationAggregationResult empty() {
return EvaluationAggregationResult.builder()
.totalScore(BigDecimal.ZERO)
.dimensionAggregations(Collections.emptyList())
.indicatorAggregations(Collections.emptyList())
.raterTypeAggregations(Collections.emptyList())
.comments(Collections.emptyList())
.raterCount(0)
.build();
}
}

/**
* 维度聚合结果
*/
@Data
@Builder
public class DimensionAggregation {
/**
* 维度ID
*/
private String dimensionId;

/**
* 维度名称
*/
private String dimensionName;

/**
* 评分列表
*/
private List<BigDecimal> scores;

/**
* 平均分
*/
private BigDecimal averageScore;

/**
* 最高分
*/
private BigDecimal maxScore;

/**
* 最低分
*/
private BigDecimal minScore;

/**
* 标准差
*/
private BigDecimal standardDeviation;
}

/**
* 指标聚合结果
*/
@Data
@Builder
public class IndicatorAggregation {
/**
* 指标ID
*/
private String indicatorId;

/**
* 指标名称
*/
private String indicatorName;

/**
* 维度ID
*/
private String dimensionId;

/**
* 维度名称
*/
private String dimensionName;

/**
* 评分列表
*/
private List<BigDecimal> scores;

/**
* 平均分
*/
private BigDecimal averageScore;

/**
* 最高分
*/
private BigDecimal maxScore;

/**
* 最低分
*/
private BigDecimal minScore;
}

/**
* 评估关系类型聚合结果
*/
@Data
@Builder
public class RaterTypeAggregation {
/**
* 评估关系类型
*/
private RaterType raterType;

/**
* 评估者数量
*/
private Integer raterCount;

/**
* 平均分
*/
private BigDecimal averageScore;

/**
* 评分列表
*/
private List<BigDecimal> scores;
}

3.3 异常值检测与处理

异常值检测引擎：

/**
* 评估异常值检测引擎
* 检测和处理异常的评估数据
*/
@Component
@Slf4j
public class EvaluationOutlierDetector {

/**
* 检测异常值
*
* @param values 数值列表
* @return 异常值检测结果
*/
public OutlierDetectionResult detectOutliers(List<BigDecimal> values) {
if (values == null || values.isEmpty()) {
return OutlierDetectionResult.empty();
}

OutlierDetectionResult result = new OutlierDetectionResult();
result.setTotalCount(values.size());

// 1. 使用IQR方法检测异常值
List<BigDecimal> iqrOutliers = detectByIQR(values);
result.setIqrOutliers(iqrOutliers);

// 2. 使用Z-Score方法检测异常值
List<BigDecimal> zScoreOutliers = detectByZScore(values);
result.setZScoreOutliers(zScoreOutliers);

// 3. 合并异常值
Set<BigDecimal> allOutliers = new HashSet<>();
allOutliers.addAll(iqrOutliers);
allOutliers.addAll(zScoreOutliers);
result.setAllOutliers(new ArrayList<>(allOutliers));

// 4. 计算异常值比例
double outlierRatio = (double) allOutliers.size() / values.size();
result.setOutlierRatio(outlierRatio);

return result;
}

/**
* 使用IQR（四分位距）方法检测异常值
*
* @param values 数值列表
* @return 异常值列表
*/
private List<BigDecimal> detectByIQR(List<BigDecimal> values) {
List<BigDecimal> sortedValues = new ArrayList<>(values);
Collections.sort(sortedValues);

// 计算四分位数
int n = sortedValues.size();
BigDecimal q1 = sortedValues.get(n / 4);
BigDecimal q3 = sortedValues.get(3 * n / 4);

// 计算IQR
BigDecimal iqr = q3.subtract(q1);

// 计算上下限
BigDecimal lowerBound = q1.subtract(iqr.multiply(new BigDecimal("1.5")));
BigDecimal upperBound = q3.add(iqr.multiply(new BigDecimal("1.5")));

// 找出异常值
List<BigDecimal> outliers = sortedValues.stream()
.filter(value -> value.compareTo(lowerBound) < 0 ||
value.compareTo(upperBound) > 0)
.collect(Collectors.toList());

log.debug("IQR异常值检测: count={}, outliers={}", n, outliers.size());

return outliers;
}

/**
* 使用Z-Score方法检测异常值
*
* @param values 数值列表
* @return 异常值列表
*/
private List<BigDecimal> detectByZScore(List<BigDecimal> values) {
// 计算平均值
BigDecimal mean = values.stream()
.reduce(BigDecimal.ZERO, BigDecimal::add)
.divide(new BigDecimal(values.size()), 2, RoundingMode.HALF_UP);

// 计算标准差
BigDecimal variance = values.stream()
.map(value -> value.subtract(mean).pow(2))
.reduce(BigDecimal.ZERO, BigDecimal::add)
.divide(new BigDecimal(values.size()), 2, RoundingMode.HALF_UP);

BigDecimal stdDev = new BigDecimal(Math.sqrt(variance.doubleValue()));

// 计算Z-Score阈值（通常使用3作为阈值）
BigDecimal threshold = new BigDecimal("3.0");

// 找出异常值
List<BigDecimal> outliers = new ArrayList<>();
for (BigDecimal value : values) {
BigDecimal zScore = value.subtract(mean)
.divide(stdDev, 2, RoundingMode.HALF_UP);

if (zScore.abs().compareTo(threshold) > 0) {
outliers.add(value);
}
}

log.debug("Z-Score异常值检测: count={}, outliers={}", values.size(), outliers.size());

return outliers;
}

/**
* 处理异常值
*
* @param values 原始数值列表
* @param strategy 处理策略
* @return 处理后的数值列表
*/
public List<BigDecimal> handleOutliers(
List<BigDecimal> values,
OutlierHandlingStrategy strategy
) {
OutlierDetectionResult detectionResult = detectOutliers(values);
List<BigDecimal> outliers = detectionResult.getAllOutliers();

if (outliers.isEmpty()) {
return values;
}

switch (strategy) {
case REMOVE:
// 移除异常值
return values.stream()
.filter(value -> !outliers.contains(value))
.collect(Collectors.toList());

case REPLACE_WITH_MEAN:
// 用平均值替换异常值
BigDecimal mean = values.stream()
.filter(value -> !outliers.contains(value))
.reduce(BigDecimal.ZERO, BigDecimal::add)
.divide(
new BigDecimal(values.size() – outliers.size()),
2,
RoundingMode.HALF_UP
);

return values.stream()
.map(value -> outliers.contains(value) ? mean : value)
.collect(Collectors.toList());

case REPLACE_WITH_MEDIAN:
// 用中位数替换异常值
List<BigDecimal> normalValues = values.stream()
.filter(value -> !outliers.contains(value))
.sorted()
.collect(Collectors.toList());

BigDecimal median = normalValues.get(normalValues.size() / 2);

return values.stream()
.map(value -> outliers.contains(value) ? median : value)
.collect(Collectors.toList());

case CAP:
// 用上下限替换异常值
List<BigDecimal> sortedValues = new ArrayList<>(values);
Collections.sort(sortedValues);

BigDecimal lowerBound = sortedValues.get(1); // 使用次小值作为下限
BigDecimal upperBound = sortedValues.get(sortedValues.size() – 2); // 使用次大值作为上限

return values.stream()
.map(value -> {
if (value.compareTo(lowerBound) < 0) {
return lowerBound;
} else if (value.compareTo(upperBound) > 0) {
return upperBound;
} else {
return value;
}
})
.collect(Collectors.toList());

default:
return values;
}
}
}

/**
* 异常值检测结果
*/
@Data
public class OutlierDetectionResult {
/**
* 总数量
*/
private Integer totalCount;

/**
* IQR方法检测出的异常值
*/
private List<BigDecimal> iqrOutliers;

/**
* Z-Score方法检测出的异常值
*/
private List<BigDecimal> zScoreOutliers;

/**
* 所有异常值
*/
private List<BigDecimal> allOutliers;

/**
* 异常值比例
*/
private Double outlierRatio;

public static OutlierDetectionResult empty() {
OutlierDetectionResult result = new OutlierDetectionResult();
result.setTotalCount(0);
result.setIqrOutliers(Collections.emptyList());
result.setZScoreOutliers(Collections.emptyList());
result.setAllOutliers(Collections.emptyList());
result.setOutlierRatio(0.0);
return result;
}
}

/**
* 异常值处理策略枚举
*/
public enum OutlierHandlingStrategy {
/** 移除异常值 */
REMOVE,

/** 用平均值替换异常值 */
REPLACE_WITH_MEAN,

/** 用中位数替换异常值 */
REPLACE_WITH_MEDIAN,

/** 用上下限替换异常值 */
CAP,

/** 不处理 */
NONE
}

3.4 评估结果排名与分析

评估结果排名引擎：

/**
* 评估结果排名引擎
* 对评估结果进行排名和对比分析
*/
@Component
@Slf4j
public class EvaluationRankingEngine {

@Autowired
private EvaluationResultRepository resultRepository;

/**
* 计算排名
*
* @param projectId 项目ID
* @return 排名结果
*/
public RankingResult calculateRanking(String projectId) {
log.info("开始计算评估排名: projectId={}", projectId);

// 1. 获取所有评估结果
List<EvaluationResult> results = resultRepository.findByProjectId(projectId);

if (results.isEmpty()) {
return RankingResult.empty();
}

// 2. 按总分排序
List<EvaluationResult> sortedResults = results.stream()
.sorted(Comparator.comparing(EvaluationResult::getTotalScore).reversed())
.collect(Collectors.toList());

// 3. 计算排名
List<RankingItem> rankingItems = new ArrayList<>();
int rank = 1;

for (int i = 0; i < sortedResults.size(); i++) {
EvaluationResult result = sortedResults.get(i);

// 处理并列排名
if (i > 0) {
EvaluationResult prevResult = sortedResults.get(i – 1);
if (result.getTotalScore().compareTo(prevResult.getTotalScore()) == 0) {
// 分数相同，排名相同
// rank保持不变
} else {
// 分数不同，排名更新
rank = i + 1;
}
}

RankingItem item = RankingItem.builder()
.rank(rank)
.evaluateeId(result.getEvaluateeId())
.evaluateeName(result.getEvaluateeName())
.departmentId(result.getDepartmentId())
.departmentName(result.getDepartmentName())
.positionId(result.getPositionId())
.positionName(result.getPositionName())
.totalScore(result.getTotalScore())
.dimensionScores(result.getDimensionScores())
.build();

rankingItems.add(item);
}

// 4. 计算百分位排名
for (RankingItem item : rankingItems) {
int percentile = calculatePercentile(rank, sortedResults.size());
item.setPercentile(percentile);
}

// 5. 构建排名结果
RankingResult rankingResult = RankingResult.builder()
.projectId(projectId)
.rankingItems(rankingItems)
.totalCount(sortedResults.size())
.averageScore(calculateAverageScore(sortedResults))
.medianScore(calculateMedianScore(sortedResults))
.maxScore(sortedResults.get(0).getTotalScore())
.minScore(sortedResults.get(sortedResults.size() – 1).getTotalScore())
.build();

log.info("评估排名计算完成: projectId={}, count={}", projectId, sortedResults.size());

return rankingResult;
}

/**
* 计算百分位
*/
private int calculatePercentile(int rank, int totalCount) {
if (totalCount == 0) {
return 0;
}

// 百分位 = (1 – rank/totalCount) * 100
double percentile = (1.0 – (double) rank / totalCount) * 100;
return (int) Math.round(percentile);
}

/**
* 计算平均分
*/
private BigDecimal calculateAverageScore(List<EvaluationResult> results) {
BigDecimal sum = results.stream()
.map(EvaluationResult::getTotalScore)
.reduce(BigDecimal.ZERO, BigDecimal::add);

return sum.divide(
new BigDecimal(results.size()),
2,
RoundingMode.HALF_UP
);
}

/**
* 计算中位数
*/
private BigDecimal calculateMedianScore(List<EvaluationResult> results) {
int size = results.size();
if (size == 0) {
return BigDecimal.ZERO;
}

if (size % 2 == 0) {
// 偶数个，取中间两个数的平均值
BigDecimal score1 = results.get(size / 2 – 1).getTotalScore();
BigDecimal score2 = results.get(size / 2).getTotalScore();
return score1.add(score2)
.divide(new BigDecimal("2"), 2, RoundingMode.HALF_UP);
} else {
// 奇数个，取中间数
return results.get(size / 2).getTotalScore();
}
}

/**
* 部门排名对比
*
* @param projectId 项目ID
* @return 部门排名对比结果
*/
public DepartmentRankingComparison compareDepartmentRanking(String projectId) {
log.info("开始部门排名对比: projectId={}", projectId);

// 1. 获取所有评估结果
List<EvaluationResult> results = resultRepository.findByProjectId(projectId);

// 2. 按部门分组
Map<String, List<EvaluationResult>> departmentGroups = results.stream()
.collect(Collectors.groupingBy(EvaluationResult::getDepartmentId));

// 3. 计算各部门的平均分
List<DepartmentRankingItem> departmentRankings = new ArrayList<>();

for (Map.Entry<String, List<EvaluationResult>> entry : departmentGroups.entrySet()) {
String departmentId = entry.getKey();
List<EvaluationResult> departmentResults = entry.getValue();

BigDecimal avgScore = calculateAverageScore(departmentResults);
BigDecimal maxScore = departmentResults.stream()
.map(EvaluationResult::getTotalScore)
.max(BigDecimal::compareTo)
.orElse(BigDecimal.ZERO);
BigDecimal minScore = departmentResults.stream()
.map(EvaluationResult::getTotalScore)
.min(BigDecimal::compareTo)
.orElse(BigDecimal.ZERO);

DepartmentRankingItem item = DepartmentRankingItem.builder()
.departmentId(departmentId)
.departmentName(departmentResults.get(0).getDepartmentName())
.averageScore(avgScore)
.maxScore(maxScore)
.minScore(minScore)
.participantCount(departmentResults.size())
.build();

departmentRankings.add(item);
}

// 4. 按平均分排序
departmentRankings.sort(
Comparator.comparing(DepartmentRankingItem::getAverageScore).reversed()
);

// 5. 构建对比结果
return DepartmentRankingComparison.builder()
.projectId(projectId)
.departmentRankings(departmentRankings)
.build();
}
}

/**
* 排名结果
*/
@Data
@Builder
public class RankingResult {
/**
* 项目ID
*/
private String projectId;

/**
* 排名列表
*/
private List<RankingItem> rankingItems;

/**
* 总人数
*/
private Integer totalCount;

/**
* 平均分
*/
private BigDecimal averageScore;

/**
* 中位数
*/
private BigDecimal medianScore;

/**
* 最高分
*/
private BigDecimal maxScore;

/**
* 最低分
*/
private BigDecimal minScore;

public static RankingResult empty() {
return RankingResult.builder()
.rankingItems(Collections.emptyList())
.totalCount(0)
.averageScore(BigDecimal.ZERO)
.medianScore(BigDecimal.ZERO)
.maxScore(BigDecimal.ZERO)
.minScore(BigDecimal.ZERO)
.build();
}
}

/**
* 排名项
*/
@Data
@Builder
public class RankingItem {
/**
* 排名
*/
private Integer rank;

/**
* 百分位
*/
private Integer percentile;

/**
* 被评估者ID
*/
private String evaluateeId;

/**
* 被评估者姓名
*/
private String evaluateeName;

/**
* 部门ID
*/
private String departmentId;

/**
* 部门名称
*/
private String departmentName;

/**
* 岗位ID
*/
private String positionId;

/**
* 岗位名称
*/
private String positionName;

/**
* 总分
*/
private BigDecimal totalScore;

/**
* 各维度得分（JSON格式）
*/
private String dimensionScores;
}

/**
* 部门排名对比结果
*/
@Data
@Builder
public class DepartmentRankingComparison {
/**
* 项目ID
*/
private String projectId;

/**
* 部门排名列表
*/
private List<DepartmentRankingItem> departmentRankings;
}

/**
* 部门排名项
*/
@Data
@Builder
public class DepartmentRankingItem {
/**
* 部门ID
*/
private String departmentId;

/**
* 部门名称
*/
private String departmentName;

/**
* 平均分
*/
private BigDecimal averageScore;

/**
* 最高分
*/
private BigDecimal maxScore;

/**
* 最低分
*/
private BigDecimal minScore;

/**
* 参与人数
*/
private Integer participantCount;
}

3.5 绩效改进计划生成

改进计划生成引擎：

/**
* 绩效改进计划生成引擎
* 根据评估结果自动生成改进建议
*/
@Component
@Slf4j
public class ImprovementPlanGenerator {

@Autowired
private EvaluationResultRepository resultRepository;

@Autowired
private ImprovementAdviceRepository adviceRepository;

/**
* 生成改进计划
*
* @param projectId 项目ID
* @param evaluateeId 被评估者ID
* @return 改进计划
*/
@Transactional(rollbackFor = Exception.class)
public ImprovementPlan generateImprovementPlan(
String projectId,
String evaluateeId
) {
log.info("生成改进计划: projectId={}, evaluateeId={}", projectId, evaluateeId);

// 1. 获取评估结果
EvaluationResult result = resultRepository.findByProjectIdAndEvaluateeId(
projectId, evaluateeId
).orElseThrow(() -> new BusinessException("评估结果不存在"));