Agent简历项目架构设计与性能优化实战

1次阅读

没有评论

共计 4066 个字符，预计需要花费 11 分钟才能阅读完成。

传统简历处理系统通常采用单体架构，随着业务量增长逐渐暴露出三大致命伤：

数据库成为瓶颈 ：单机 MySQL 在每日千万级简历提交时，连接池爆满导致大量 504 超时
同步处理效率低下 ：简历解析耗时的 PDF 解析、NLP 处理等操作阻塞主线程，平均响应时间突破 8 秒
扩展性差 ：垂直扩容成本指数级增长，某次校招季临时增加 20 台服务器仍未能解决服务熔断问题

通过 APM 工具追踪发现，80% 的请求延迟发生在数据库 IO 和文件解析阶段，这正是我们需要重点突破的战场。

经过对三种架构的压测对比（单体 / 微服务 /Serverless），最终技术栈组合如下：

架构层面 ：
Spring Cloud Alibaba 2.2.6（注册中心 +Nacos 配置中心）
舍弃 Dubbo 选择 Spring Cloud OpenFeign（更适合内部 HTTP 通信场景）
异步处理 ：
RabbitMQ 3.8.16（经测试比 Kafka 节省 30% 内存资源）
定制化延迟队列插件实现简历状态更新
缓存系统 ：
Redis 6.2 集群模式（采用 CRC16 分片算法）
多级缓存设计：本地 Caffeine → Redis → 持久层
数据库 ：
MySQL 8.0 组复制（1 主 3 从）
ShardingSphere 5.1.1 实现按求职者 ID 分库

关键技术决策依据：

消息队列选型对比：

// RabbitMQ 与 Kafka 吞吐量测试数据（单节点 16C32G）| 中间件   | 10W 消息耗时 | 磁盘占用 |
|----------|------------|---------|
| RabbitMQ | 28s        | 1.2GB   |
| Kafka    | 19s        | 3.7GB   |

考虑到简历处理不需要消息持久化超过 24 小时，选择资源占用更优的方案

通过 RabbitMQ 实现简历处理全链路异步化：

简历上传接口仅做基本验证，立即返回 202 Accepted

核心生产者代码示例：

@RestController
public class ResumeController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostMapping("/resumes")
    public ResponseEntity<String> uploadResume(@RequestBody ResumeDTO dto) {
        // 基础校验（文件类型、大小等）ValidationUtils.validateResume(dto);

        // 构建延迟消息（30 分钟后检查处理状态）Message message = MessageBuilder
            .withBody(dto.toJson().getBytes())
            .setHeader("x-delay", 1800000)
            .build();

        // 发送到解析队列
        rabbitTemplate.convertAndSend(
            "resume.exchange", 
            "parse.queue", 
            message);

        return ResponseEntity.accepted().body("简历已进入处理队列");
    }
}

消费者服务独立部署，实现弹性扩容：

# 消费者集群配置示例
spring:
  rabbitmq:
    listener:
      simple:
        concurrency: 10 # 初始并发数
        max-concurrency: 50 # 最大扩容数
        prefetch: 2 # 防止单个消费者过载

针对简历数据的访问特点，设计三级缓存体系：

热点缓存 ：最近 7 天活跃用户的简历驻留 Redis
版本控制 ：通过 MD5 校验避免返回旧数据

关键实现代码：

public class ResumeCacheService {
    @Cacheable(value = "resume", key = "#userId", 
        unless = "#result == null || #result.isExpired()")
    public Resume getResume(Long userId) {
        // 先查本地缓存（Caffeine）Resume resume = localCache.get(userId);
        if (resume == null) {
            // Redis 查询（使用 Redisson 客户端）RMapCache<Long, Resume> cache = redisson.getMapCache("resumes");
            resume = cache.get(userId);

            // 回源数据库
            if (resume == null) {resume = resumeRepository.findById(userId)
                    .orElseThrow(() -> new NotFoundException("简历不存在"));

                // 异步更新缓存
                CompletableFuture.runAsync(() -> {cache.fastPutAsync(userId, resume, 1, TimeUnit.HOURS);
                    localCache.put(userId, resume);
                });
            }
        }
        return resume;
    }
}

基于 ShardingSphere 实现智能化路由：

配置示例：

spring:
  shardingsphere:
    datasource:
      names: master,slave0,slave1,slave2
    masterslave:
      load-balance-algorithm-type: round_robin
      name: ms-group
      master-data-source-name: master
      slave-data-source-names: slave0,slave1,slave2
    props:
      sql.show: true

通过 AOP 实现自动路由：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ReadOnly {
}

@Aspect
@Component
public class ReadOnlyAspect {@Before("@annotation(readOnly)")
    public void setReadDataSource(ReadOnly readOnly) {DynamicDataSourceHolder.markSlave();
    }
}

优化前后关键指标对比（压测工具：JMeter 5.4.1）：

场景	QPS	平均响应时间	错误率
原单体架构	312	4.7s	12.3%
优化后架构	1286	217ms	0.05%
极限压测 (100 并发)	2458	812ms	1.2%

特别说明：测试环境为阿里云 8C16G×3 节点，MySQL 配置 16C64G×4 节点

采用 Redis 原子操作实现去重：

public class ResumeMessageListener {@RabbitListener(queues = "parse.queue")
    public void processResume(Message message) {String msgId = message.getMessageProperties().getMessageId();

        // Redis 原子操作判重
        Boolean isProcessed = redisTemplate.opsForValue()
            .setIfAbsent("resume:msg:" + msgId, "1", 24, TimeUnit.HOURS);

        if (Boolean.FALSE.equals(isProcessed)) {log.warn("重复消息丢弃: {}", msgId);
            return;
        }

        // 实际处理逻辑...
    }
}

差异化过期时间 ：基础数据设置随机 TTL（30±5 分钟）

降级策略 ：

public Resume getResumeWithFallback(Long userId) {
    try {return resumeCacheService.getResume(userId);
    } catch (Exception e) {
        // 降级查询数据库
        log.warn("缓存故障，降级查询 DB: {}", userId);
        return resumeRepository.findById(userId).orElse(null);
    }
}

热点 Key 探测 ：实时监控 Redis 内存占用，自动触发本地缓存

采用最终一致性方案：

简历状态更新流程图：

[上传服务] --MQ--> [解析服务] --DB--> [通知服务]
    ↑_________________↓
     状态补偿 Job(每 5 分钟)

补偿 Job 核心逻辑：

@Scheduled(cron = "0 */5 * * * ?")
public void checkProcessingResumes() {
    // 查询超过 1 小时未更新的简历
    List<Resume> stuckResumes = resumeRepository
        .findByStatusAndUpdateTimeBefore(
            ProcessStatus.PROCESSING, 
            LocalDateTime.now().minusHours(1));

    // 重新投递消息
    stuckResumes.forEach(resume -> {
        rabbitTemplate.convertAndSend(
            "resume.dlx.exchange",
            "resume.retry.queue",
            resume.toJson());
    });
}

当前架构已稳定支撑日均 2000 万份简历处理，但仍有优化空间：