每天一道面试题之架构篇｜如何设计防刷、防作弊的在线答题系统？-平芜编程栈

面试官："请设计一个在线答题系统，要求能够有效防止刷题和作弊行为，你会如何设计？"

在线答题系统的防刷防作弊设计是典型的业务安全架构问题，需要从多个维度构建防御体系。今天我们就来深入探讨如何设计一个安全可靠的在线答题系统。

一、系统架构设计

分层防御架构：

/**
* 在线答题系统安全架构
* 四层防御体系
*/
publicclassExamSecurityArchitecture{

// 1. 接入层安全
publicclassAccessLayerSecurity{
// IP频率限制
// 设备指纹识别
// 人机验证
// SSL加密传输
}

// 2. 业务层安全
publicclassBusinessLayerSecurity{
// 答题过程保护
// 时间控制机制
// 异常行为检测
// 答案防泄露
}

// 3. 数据层安全
publicclassDataLayerSecurity{
// 数据加密存储
// 操作日志审计
// 敏感信息脱敏
// 数据完整性校验
}

// 4. 监控层安全
publicclassMonitorLayerSecurity{
// 实时风险检测
// 行为模式分析
// 预警通知系统
// 应急处理机制
}
}

二、防刷策略设计

多层次频率限制：

/**
* 防刷频率限制服务
*/
@Service
@Slf4j
publicclassRateLimitService{

@Autowired
privateRedisTemplate<String, Object> redisTemplate;

// 多维度限流配置
privatestaticfinalMap<String, RateLimitConfig> LIMIT_CONFIGS = Map.of(
"ip:answer",newRateLimitConfig(10,60),// IP每60秒10次答题
"user:answer",newRateLimitConfig(30,300),// 用户每5分钟30次答题
"device:answer",newRateLimitConfig(20,600),// 设备每10分钟20次答题
"ip:request",newRateLimitConfig(100,60)// IP每60秒100次请求
);

/**
* 检查请求频率
*/
publicbooleancheckRateLimit(String dimension, String key, String operation){
String configKey = dimension +":"+ operation;
RateLimitConfig config = LIMIT_CONFIGS.get(configKey);

if(config ==null) {
returntrue;
}

String redisKey = String.format("rate_limit:%s:%s:%s",
dimension, key, operation);

Long count = redisTemplate.opsForValue().increment(redisKey,1);
if(count !=null&& count ==1) {
redisTemplate.expire(redisKey, config.getTimeWindow(), TimeUnit.SECONDS);
}

returncount !=null&& count <= config.getMaxRequests();
}

/**
* 滑动窗口限流
*/
publicbooleanslidingWindowLimit(String key,intmaxCount,intwindowSeconds){
longnow = System.currentTimeMillis();
longwindowStart = now - windowSeconds *1000L;

String redisKey ="sliding_window:"+ key;

// 使用ZSET实现滑动窗口
redisTemplate.opsForZSet().removeRangeByScore(redisKey,0, windowStart);

Long currentCount = redisTemplate.opsForZSet().zCard(redisKey);
if(currentCount !=null&& currentCount >= maxCount) {
returnfalse;
}

redisTemplate.opsForZSet().add(redisKey, String.valueOf(now), now);
redisTemplate.expire(redisKey, windowSeconds, TimeUnit.SECONDS);

returntrue;
}

@Data
@AllArgsConstructor
publicstaticclassRateLimitConfig{
privateintmaxRequests;
privateinttimeWindow;// 秒
}
}

三、防作弊技术实现

答题过程保护机制：

/**
* 答题过程安全服务
*/
@Service
publicclassExamProcessService{

@Autowired
privateTokenService tokenService;
@Autowired
privateBehaviorAnalysisService behaviorAnalysis;

/**
* 开始答题 - 生成安全令牌
*/
publicExamSessionstartExam(String userId, String examId){
// 1. 设备环境检查
if(!checkDeviceEnvironment(userId)) {
thrownewSecurityException("设备环境异常");
}

// 2. 生成防作弊令牌
String securityToken = tokenService.generateExamToken(userId, examId);

// 3. 创建监控会话
ExamSession session =newExamSession(userId, examId, securityToken);
session.setStartTime(System.currentTimeMillis());
session.setClientInfo(getClientInfo());

// 4. 初始化行为分析
behaviorAnalysis.startMonitoring(session);

returnsession;
}

/**
* 提交答案 - 安全验证
*/
publicSubmitResultsubmitAnswer(AnswerRequest request){
// 1. 令牌验证
if(!tokenService.validateToken(request.getToken())) {
thrownewSecurityException("无效的答题令牌");
}

// 2. 时间验证
if(!validateAnswerTime(request)) {
thrownewSecurityException("答题时间异常");
}

// 3. 行为分析
BehaviorAnalysisResult behaviorResult = behaviorAnalysis.analyzeBehavior(request);
if(behaviorResult.isSuspicious()) {
log.warn("检测到可疑行为: {}", behaviorResult.getReason());
// 记录风险事件，但不立即拒绝，避免误判
}

// 4. 答案相似度检查
checkAnswerSimilarity(request);

// 5. 处理提交
returnprocessSubmission(request, behaviorResult);
}

/**
* 设备环境检查
*/
privatebooleancheckDeviceEnvironment(String userId){
// 检查是否使用模拟器
// 检查浏览器指纹
// 检查IP地址信誉
// 检查设备历史行为
returntrue;
}
}

四、人机验证系统

智能验证码服务：

/**
* 多层次人机验证服务
*/
@Service
publicclassCaptchaService{

// 验证难度等级
publicenumDifficultyLevel {
LOW,// 简单图形验证码
MEDIUM,// 滑动验证码
HIGH,// 智能行为验证
EXTREME// 多因素认证
}

/**
* 根据风险等级选择合适的验证方式
*/
publicStringrequireCaptcha(String sessionId, RiskLevel riskLevel){
DifficultyLevel difficulty = calculateDifficulty(riskLevel);

switch(difficulty) {
caseLOW:
returngenerateImageCaptcha(sessionId);
caseMEDIUM:
returngenerateSlideCaptcha(sessionId);
caseHIGH:
returngenerateBehaviorCaptcha(sessionId);
caseEXTREME:
returnrequireMultiFactorAuth(sessionId);
default:
returngenerateImageCaptcha(sessionId);
}
}

/**
* 智能行为验证码
*/
privateStringgenerateBehaviorCaptcha(String sessionId){
// 记录用户鼠标移动轨迹
// 分析点击模式
// 检测自动化行为特征
return"behavior_captcha_"+ sessionId;
}

/**
* 验证码验证
*/
publicbooleanverifyCaptcha(String sessionId, String captchaCode,
String clientBehaviorData){
// 验证码正确性检查
booleancodeCorrect = verifyCaptchaCode(sessionId, captchaCode);

// 行为数据分析
booleanbehaviorNormal = analyzeClientBehavior(clientBehaviorData);

// 综合判断
returncodeCorrect && behaviorNormal;
}
}

五、行为分析引擎

异常行为检测：

/**
* 行为分析服务 - 检测作弊模式
*/
@Service
@Slf4j
publicclassBehaviorAnalysisService{

privatestaticfinaldoubleSUSPICIOUS_THRESHOLD =0.8;
privatestaticfinaldoubleCHEATING_THRESHOLD =0.95;

/**
* 分析答题行为
*/
publicBehaviorAnalysisResultanalyzeBehavior(AnswerRequest request){
doublesuspicionScore =0.0;
List<String> reasons =newArrayList<>();

// 1. 答题时间分析
doubletimeScore = analyzeAnswerTime(request);
if(timeScore >0.7) {
suspicionScore += timeScore *0.3;
reasons.add("答题时间模式异常");
}

// 2. 点击模式分析
doubleclickScore = analyzeClickPattern(request.getClickEvents());
if(clickScore >0.6) {
suspicionScore += clickScore *0.25;
reasons.add("鼠标点击模式异常");
}

// 3. 答案模式分析
doubleanswerScore = analyzeAnswerPattern(request);
if(answerScore >0.8) {
suspicionScore += answerScore *0.45;
reasons.add("答案选择模式异常");
}

// 4. 设备行为分析
doubledeviceScore = analyzeDeviceBehavior(request.getDeviceInfo());
if(deviceScore >0.5) {
suspicionScore += deviceScore *0.2;
reasons.add("设备行为异常");
}

RiskLevel riskLevel = calculateRiskLevel(suspicionScore);
returnnewBehaviorAnalysisResult(suspicionScore, riskLevel, reasons);
}

/**
* 答题时间模式分析
*/
privatedoubleanalyzeAnswerTime(AnswerRequest request){
// 计算答题速度（毫秒/题）
longtimePerQuestion = request.getTotalTime() / request.getQuestionCount();

// 与平均时间对比
doubledeviation = Math.abs(timePerQuestion - getAverageTime()) / getAverageTime();

// 异常时间模式检测
if(deviation <0.1) {
// 速度过于均匀，可能机器操作
return0.8;
}elseif(deviation >2.0) {
// 速度异常快，可能作弊
return0.9;
}

return0.0;
}

/**
* 答案模式分析
*/
privatedoubleanalyzeAnswerPattern(AnswerRequest request){
// 1. 连续相同选项检测
if(hasConsecutiveSameAnswers(request,10)) {
return0.7;
}

// 2. 准确率异常检测
if(isAccuracyTooHigh(request)) {
return0.85;
}

// 3. 与已知作弊模式匹配
if(matchKnownCheatingPattern(request)) {
return0.95;
}

return0.0;
}
}

六、数据安全与审计

安全审计日志：

/**
* 安全审计服务 - 记录所有关键操作
*/
@Service
@Slf4j
publicclassAuditService{

@Autowired
privateAuditLogRepository auditLogRepository;

/**
* 记录安全事件
*/
publicvoidlogSecurityEvent(SecurityEvent event){
AuditLog log =newAuditLog();
log.setEventType(event.getType());
log.setUserId(event.getUserId());
log.setTimestamp(newDate());
log.setIpAddress(event.getIpAddress());
log.setDeviceId(event.getDeviceId());
log.setDetails(event.getDetails());
log.setRiskLevel(event.getRiskLevel());

auditLogRepository.save(log);

// 实时风险检测
if(event.getRiskLevel() >= RiskLevel.HIGH.getValue()) {
alertRiskManagement(event);
}
}

/**
* 查询用户行为日志
*/
publicList<AuditLog>getUserBehaviorLogs(String userId, Date startTime, Date endTime){
returnauditLogRepository.findByUserIdAndTimestampBetween(
userId, startTime, endTime);
}

/**
* 检测异常行为模式
*/
publicList<SecurityEvent>detectAnomalousPatterns(){
// 1. 检测批量操作
detectBatchOperations();

// 2. 检测时间异常
detectTimeAnomalies();

// 3. 检测地理异常
detectGeographicalAnomalies();

// 4. 检测设备异常
detectDeviceAnomalies();

returnnewArrayList<>();
}
}

七、系统监控与预警

实时监控系统：

/**
* 实时监控服务 - 动态风险检测
*/
@Service
publicclassRealTimeMonitorService{

privatefinalMap<String, UserBehaviorProfile> userProfiles =newConcurrentHashMap<>();
privatefinalRiskRuleEngine ruleEngine =newRiskRuleEngine();

/**
* 实时风险评分
*/
publicRiskScorecalculateRealTimeRisk(ExamAction action){
UserBehaviorProfile profile = getUserProfile(action.getUserId());

// 更新行为画像
profile.updateWithAction(action);

// 规则引擎评估
doubleruleScore = ruleEngine.evaluate(action, profile);

// 机器学习模型评估
doublemodelScore = machineLearningModel.predict(action);

// 综合风险评分
doublefinalScore = (ruleScore *0.6) + (modelScore *0.4);

returnnewRiskScore(finalScore, getRiskLevel(finalScore));
}

/**
* 风险预警处理
*/
publicvoidhandleRiskWarning(RiskWarning warning){
switch(warning.getSeverity()) {
caseLOW:
log.info("低风险警告: {}", warning.getMessage());
break;
caseMEDIUM:
log.warn("中风险警告: {}", warning.getMessage());
notifyExamSupervisor(warning);
break;
caseHIGH:
log.error("高风险警告: {}", warning.getMessage());
suspendExamSession(warning.getSessionId());
notifySecurityTeam(warning);
break;
caseCRITICAL:
log.error("严重风险警告: {}", warning.getMessage());
terminateExamSession(warning.getSessionId());
blockUserTemporarily(warning.getUserId());
notifySecurityTeam(warning);
break;
}
}
}

八、应急处理机制

作弊处理流程：

/**
* 作弊处理服务 - 分级处置
*/
@Service
publicclassCheatingHandleService{

/**
* 处理确认的作弊行为
*/
publicvoidhandleConfirmedCheating(CheatingCase cheatingCase){
// 1. 立即终止考试
terminateExam(cheatingCase.getSessionId());

// 2. 记录作弊证据
saveCheatingEvidence(cheatingCase);

// 3. 根据严重程度处理
switch(cheatingCase.getSeverity()) {
caseMILD:
handleMildCheating(cheatingCase);
break;
caseMODERATE:
handleModerateCheating(cheatingCase);
break;
caseSEVERE:
handleSevereCheating(cheatingCase);
break;
}

// 4. 通知相关方
notifyStakeholders(cheatingCase);
}

/**
* 轻度作弊处理
*/
privatevoidhandleMildCheating(CheatingCasecase){
// 警告用户
sendWarningNotification(case.getUserId());
// 记录诚信档案
updateIntegrityRecord(case.getUserId(),1);
}

/**
* 中度作弊处理
*/
privatevoidhandleModerateCheating(CheatingCasecase){
// 取消本次成绩
invalidateExamResult(case.getExamId(),case.getUserId());
// 短期禁考（7天）
suspendExamPermission(case.getUserId(),7);
// 记录诚信档案
updateIntegrityRecord(case.getUserId(),3);
}

/**
* 严重作弊处理
*/
privatevoidhandleSevereCheating(CheatingCasecase){
// 取消所有相关成绩
invalidateAllResults(case.getUserId());
// 长期禁考（180天）
suspendExamPermission(case.getUserId(),180);
// 列入黑名单
addToBlacklist(case.getUserId());
// 法律程序（如需要）
initiateLegalProcedure(case);
}
}