编写测试类(代理模式)

实现示例的代码沙箱

package com.dduo.dduoj.judge.codesandbox.impl;

import com.dduo.dduoj.judge.codesandbox.CodeSandbox;
import com.dduo.dduoj.judge.codesandbox.model.ExecuteCodeRequest;
import com.dduo.dduoj.judge.codesandbox.model.ExecuteCodeResponse;
import com.dduo.dduoj.model.dto.questionsubmit.JudgeInfo;
import com.dduo.dduoj.model.enums.JudgeInfoMessageEnum;
import com.dduo.dduoj.model.enums.QuestionSubmitStatusEnum;
import lombok.extern.slf4j.Slf4j;

import java.util.List;

//示例代码沙箱 (仅供测试 跑通业务流程)
@Slf4j
public class ExampleCodeSandbox implements CodeSandbox {
    @Override
    public ExecuteCodeResponse executeCode(ExecuteCodeRequest executeCodeRequest) {

        List<String> inputList = executeCodeRequest.getInputList();
        String code = executeCodeRequest.getCode();
        String language = executeCodeRequest.getLanguage();

        ExecuteCodeResponse executeCodeResponse = new ExecuteCodeResponse();
        executeCodeResponse.setOutputList(inputList);
        executeCodeResponse.setMessage("测试执行成功");
        executeCodeResponse.setStatus(QuestionSubmitStatusEnum.SUCCESS.getValue());

        JudgeInfo judgeInfo=new JudgeInfo();
        judgeInfo.setMessage(JudgeInfoMessageEnum.Accepted.getText());
        judgeInfo.setMemoryLimit(100L);
        judgeInfo.setTime(100L);

        executeCodeResponse.setJudgeInfo(judgeInfo);

        return executeCodeResponse;
    }
}

我们先把示例代码沙箱跑通 然后再直接把远程代码沙箱接进去

我们在调用代码沙箱前 输出请求参数日志 在代码沙箱调用后 输出响应结果日志 便于管理员去分析

每一个代码沙箱类都会写一遍log.info 难道每次调用代码沙箱前后都要执行log吗

我的理解是使用代理模式 提供一个Proxy 来增强代码沙箱的能力

代理模式的本质就是增强能力

原本：需要用户自己去调用多次

实现核心业务判题流程

在之前问题提交实现类里面加上判题服务

先写一个JudgeService

梳理一下判题服务的逻辑

第一步是获取到传入题目的id 获取到对应的题目信息 提交信息(代码 编程语言

第二步调用沙箱 获取到执行结果

第三步是根据沙箱的执行结果 设置题目的判题状态

我们接下来在实现类里面补全代码

根据沙箱的执行结果 我们设置题目的判题状态和信息

节约系统资源 解决一些不一致的问题

更改判题(题目提交)状态为判题中 防止重复执行

判断逻辑

先判断沙箱的执行结果输出数量是否和预期输出的数量相等

依次判断每一项输出和预期输出是否相等

判断题目的限制是否满足要求

可能还有其他的情况

首先我们拿到题目提交信息 拿到题目

进行简单的判断

证明了题目存在 我们开始判题 首先我们要更改题目的状态

之后我我们要把我们代码放入代码沙箱

根据代码沙箱的执行结果

我们首先要设置题目的判题状态和信息是否正确

从之前注入的两个对象中拿到输入用例 和预计输出用例

开始校验

首先我们校验输出的用例数量和预计输出是否相等

再去判断每一项输出的具体内容和预计输出是否相等

通过循环校验

到最后拿到题目限制

进行判断

可能还会有其他的异常情况

package com.dduo.dduoj.judge;

import cn.hutool.json.JSONUtil;
import com.dduo.dduoj.common.ErrorCode;
import com.dduo.dduoj.exception.BusinessException;
import com.dduo.dduoj.judge.codesandbox.CodeSandbox;
import com.dduo.dduoj.judge.codesandbox.CodeSandboxFactory;
import com.dduo.dduoj.judge.codesandbox.CodeSandboxProxy;
import com.dduo.dduoj.judge.codesandbox.model.ExecuteCodeRequest;
import com.dduo.dduoj.judge.codesandbox.model.ExecuteCodeResponse;
import com.dduo.dduoj.model.dto.question.JudgeCase;
import com.dduo.dduoj.model.dto.question.JudgeConfig;
import com.dduo.dduoj.model.dto.questionsubmit.JudgeInfo;
import com.dduo.dduoj.model.entity.Question;
import com.dduo.dduoj.model.entity.QuestionSubmit;
import com.dduo.dduoj.model.enums.JudgeInfoMessageEnum;
import com.dduo.dduoj.model.enums.QuestionSubmitLanguageEnum;
import com.dduo.dduoj.model.enums.QuestionSubmitStatusEnum;
import com.dduo.dduoj.model.vo.QuestionSubmitVO;
import com.dduo.dduoj.service.QuestionService;
import com.dduo.dduoj.service.QuestionSubmitService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class JudgeServiceImpl implements JudgeService {

    // 题目服务
    @Resource
    private QuestionService questionService;

    // 题目提交服务
    @Resource
    private QuestionSubmitService questionSubmitService;


    @Value("${codesandbox.type:example}")
    private String value;

    @Override
    public QuestionSubmitVO doJudge(Long questionSubmitId) {

        QuestionSubmit questionSubmit = questionSubmitService.getById(questionSubmitId);
        if (questionSubmit == null) {
            throw new BusinessException(ErrorCode.NOT_FOUND_ERROR, "提交信息不存在");
        }

        //拿到题目提交信息
        Long questionId = questionSubmit.getQuestionId();

        //拿到题目
        Question question = questionService.getById(questionId);

        if (question == null) {
            throw new BusinessException(ErrorCode.NOT_FOUND_ERROR, "题目不存在");
        }

        // 题目存在
        // 开始判题
        // 更改题目的状态 status

        // 如果不为等待状态
        if (questionSubmit.getStatus().equals(QuestionSubmitStatusEnum.WAITING.getValue())) {
            throw new BusinessException(ErrorCode.OPERATION_ERROR, "题目正在判题中");
        }

        // 重新设置
        QuestionSubmit questionSubmitUpdate = new QuestionSubmit();
        questionSubmitUpdate.setId(questionSubmitId);
        questionSubmitUpdate.setStatus(QuestionSubmitStatusEnum.RUNNING.getValue());
        boolean judge = questionSubmitService.updateById(questionSubmitUpdate);

        if (!judge) {
            throw new BusinessException(ErrorCode.SYSTEM_ERROR, "题目状态更新错误");
        }

        // 接下来放代码沙箱
        CodeSandbox codeSandbox = CodeSandboxFactory.NewInstance(value);
        codeSandbox = new CodeSandboxProxy(codeSandbox);

        // 拿出数据
        String code = questionSubmit.getCode();

        String language = questionSubmit.getLanguage();

        // 获取输入用例
        String judgeCaseStr = question.getJudgeCase();
        List<JudgeCase> judgeCaselist = JSONUtil.toList(judgeCaseStr, JudgeCase.class);
        List<String> inputList = judgeCaselist.stream().map(JudgeCase::getInput).collect(Collectors.toList());

        ExecuteCodeRequest executeRequest = ExecuteCodeRequest.builder().code(code).language(language).inputList(inputList).build();
        ExecuteCodeResponse executeCodeResponse=codeSandbox.executeCode(executeRequest);

        // 根据沙箱的执行结果 设置题目的判题状态和信息是否正确
        JudgeInfoMessageEnum judgeInfoMessageEnum=JudgeInfoMessageEnum.Waiting;

        // 校验输出数量是否和预计输出数量相等
        List<String> outputList = executeCodeResponse.getOutputList();
        if(outputList.size()!=inputList.size()){
            judgeInfoMessageEnum=judgeInfoMessageEnum.Wrong_Answer;
            return null;
        }

        // 校验每一项输出和预期输出是否相等
        for(int i=0;i<judgeCaselist.size();i++){
            JudgeCase judgeCase = judgeCaselist.get(i);
            if(judgeCase.getOutput().equals(outputList.get(i))){
                judgeInfoMessageEnum=JudgeInfoMessageEnum.Wrong_Answer;
                return null;
            }
        }

        // 判断题目的限制
        JudgeInfo judgeInfo = executeCodeResponse.getJudgeInfo();
        Long memory = judgeInfo.getMemoryLimit();
        Long time = judgeInfo.getTime();
        String judgeConfigStr = question.getJudgeConfig();
        JudgeConfig judgeConfig = JSONUtil.toBean(judgeConfigStr, JudgeConfig.class);
        Long memoryLimit = judgeConfig.getMemoryLimit();
        Long timeLimit = judgeConfig.getTimeLimit();
        // 内存限制
        if(memory>memoryLimit){
            judgeInfoMessageEnum=JudgeInfoMessageEnum.Memory_Limit_Exceeded;
            return null;
        }
        // 时间限制
        if(time>timeLimit){
            judgeInfoMessageEnum=JudgeInfoMessageEnum.Time_Limit_Exceeded;
            return null;
        }

        return null;
    }
}