OJ 代码沙箱

holic-x...大约 26 分钟

06-代码沙箱

基于判题服务的构建，基本打通了用户提交问题记录的业务逻辑，前面的实现是基于Example代码沙箱，主要是为了打通业务逻辑而设定的存在，参考原有远程代码沙箱设计概念，可单独构建一个可执行程序用作用作远程代码沙箱执行操作

此处注意一个细节，ProcessUtils进程工具类中通过StopWatch设置计时监听，最终会将每个执行操作的执行时间返回并设置到ExecuteMessage中，考虑到不止一组执行参数，但代码响应参数时间只有一个，因此要选择这组执行参数中用时最长的作为参照用于判断是否超时。因此在拿到执行结果之后，需要对获取到的List<ExecuteMessage>集合进行整理，获取到最大的时间进行超时判断

1）通过for循环遍历执行结果，从中获取到输出列表

2）获取程序执行时间（可以使用Spring的StopWatch获取一段程序的执行时间），此处用最大值来统计时间（便于后续判题服务计算程序是否超时）

// ProcessUtils中runProcessAndGetMessage处理的时候定义
StopWatch stopWatch = new StopWatch();
stopWatch.start();
..... 程序逻辑操作 ......
stopWatch.stop();
executeMessage.setTime(stopWatch.getLastTaskTimeMillis());


// 收集整理
	    // 取用时最大值，便于判断是否超时
        long maxTime = 0;
        for (ExecuteMessage executeMessage : executeMessageList) {
            ......
            Long time = executeMessage.getTime();
            if (time != null) {
                maxTime = Math.max(maxTime, time);
            }
        }

3）获取内存信息（实现比较复杂，因为无法从Process对象中获取到子进程号，也不推荐在Java原生实现代码沙箱的过程中获取，不建议硬核钻这块的内容）

5）文件清理

		if (userCodeFile.getParentFile() != null) {
            boolean del = FileUtil.del(userCodeParentPath);
            System.out.println("删除" + (del ? "成功" : "失败"));
        }

6）错误处理：封装一个错误处理方法，当程序抛出异常的时候，直接返回错误响应

	/**
     * 获取错误响应
     *
     * @param e
     * @return
     */
    private ExecuteCodeResponse getErrorResponse(Throwable e) {
        ExecuteCodeResponse executeCodeResponse = new ExecuteCodeResponse();
        executeCodeResponse.setOutputList(new ArrayList<>());
        executeCodeResponse.setMessage(e.getMessage());
        // 表示代码沙箱错误
        executeCodeResponse.setStatus(2);
        executeCodeResponse.setJudgeInfo(new JudgeInfo());
        return executeCodeResponse;
    }


// 在异常处理try catch中捕获异常并处理，返回自定义的错误响应（参考示例如下）

 		try {
                ..... 逻辑处理 .....
            } catch (Exception e) {
                System.out.println("异常：" + getErrorResponse(e));
                return getErrorResponse(e);
            }

构建参考初版

public class JavaNativeCodeSandbox implements CodeSandbox {

    // 全局文件存储文件夹定义
    private static final String GLOBAL_CODE_DIR_NAME = "tmpCode";

    // 存储的文件名定义
    private static final String GLOBAL_JAVA_CLASS_NAME = "Main.java";

    public static void main(String[] args) {

        JavaNativeCodeSandbox javaNativeCodeSandbox = new JavaNativeCodeSandbox();
        ExecuteCodeRequest executeCodeRequest = new ExecuteCodeRequest();
        executeCodeRequest.setInputList(Arrays.asList("1 2", "1 3"));
        String code = ResourceUtil.readStr("testCode/simpleComputeArgs/Main.java", StandardCharsets.UTF_8);
        executeCodeRequest.setCode(code);
        executeCodeRequest.setLanguage("java");
        ExecuteCodeResponse executeCodeResponse = javaNativeCodeSandbox.executeCode(executeCodeRequest);
        System.out.println(executeCodeResponse);

    }


    @Override
    public ExecuteCodeResponse executeCode(ExecuteCodeRequest executeCodeRequest) {
        List<String> inputList = executeCodeRequest.getInputList();
        String code = executeCodeRequest.getCode();
        String language = executeCodeRequest.getLanguage();

        // 1）把用户的代码保存为文件
        String userDir = System.getProperty("user.dir");
        String globalCodePathName = userDir + File.separator + GLOBAL_CODE_DIR_NAME;
        // 判断全局代码目录是否存在，没有则新建
        if (!FileUtil.exist(globalCodePathName)) {
            FileUtil.mkdir(globalCodePathName);
        }

        // 把用户的代码隔离存放
        String userCodeParentPath = globalCodePathName + File.separator + UUID.randomUUID();
        String userCodePath = userCodeParentPath + File.separator + GLOBAL_JAVA_CLASS_NAME;
        File userCodeFile = FileUtil.writeString(code, userCodePath, StandardCharsets.UTF_8);


        // 2）编译代码，得到 class 文件
        String compileCmd = String.format("javac -encoding utf-8 %s", userCodeFile.getAbsolutePath());
        try {
            Process compileProcess = Runtime.getRuntime().exec(compileCmd);
            // 自定义ProcessUtils获取控制台输出（通过 exitValue 判断程序是否正常返回，通过 inputStream 和 errorStream 获取控制台输出）
            // 方式1：通过args方式输入参数（项目核心）
            ExecuteMessage executeMessage = ProcessUtils.runProcessAndGetMessage(compileProcess, "编译");
            System.out.println(executeMessage);
        } catch (Exception e) {
            return getErrorResponse(e);
        }


        // 3）执行代码，得到输出结果（命令中指定 -Dfile.encoding=UTF-8 参数，解决中文乱码）
        List<ExecuteMessage> executeMessageList = new ArrayList<>();
        for (String inputArgs : inputList) {
            String runCmd = String.format("java -Dfile.encoding=UTF-8 -cp %s Main %s", userCodeParentPath, inputArgs);
            try {
                Process runProcess = Runtime.getRuntime().exec(runCmd);
                ExecuteMessage executeMessage = ProcessUtils.runProcessAndGetMessage(runProcess, "运行");
                System.out.println(executeMessage);
                // 将执行结果加入列表
                executeMessageList.add(executeMessage);
            } catch (Exception e) {
                System.out.println("异常：" + getErrorResponse(e));
                return getErrorResponse(e);
            }
        }

        // 4）收集整理输出结果
        ExecuteCodeResponse executeCodeResponse = new ExecuteCodeResponse();
        List<String> outputList = new ArrayList<>();
        // 取用时最大值，便于判断是否超时
        long maxTime = 0;
        for (ExecuteMessage executeMessage : executeMessageList) {
            String errorMessage = executeMessage.getErrorMessage();
            if (StrUtil.isNotBlank(errorMessage)) {
                executeCodeResponse.setMessage(errorMessage);
                // 用户提交的代码执行中存在错误
                executeCodeResponse.setStatus(3);
                break;
            }
            outputList.add(executeMessage.getMessage());
            Long time = executeMessage.getTime();
            if (time != null) {
                maxTime = Math.max(maxTime, time);
            }
        }
        // 正常运行完成
        if (outputList.size() == executeMessageList.size()) {
            executeCodeResponse.setStatus(1);
        }
        executeCodeResponse.setOutputList(outputList);
        JudgeInfo judgeInfo = new JudgeInfo();
        judgeInfo.setTime(maxTime);
        // todo 要借助第三方库来获取内存占用，非常麻烦，此处不做实现
        // judgeInfo.setMemory();
        executeCodeResponse.setJudgeInfo(judgeInfo);


        // 5）文件清理
        if (userCodeFile.getParentFile() != null) {
            boolean del = FileUtil.del(userCodeParentPath);
            System.out.println("删除" + (del ? "成功" : "失败"));
        }

        // 6）错误处理，提升程序健壮性（通过自定义封装getErrorResponse错误处理方法，当程序抛出异常时，直接返回错误响应）参考getErrorResponse方法

        // 返回执行代码结果响应
        return executeCodeResponse;
    }


    /**
     * 获取错误响应
     *
     * @param e
     * @return
     */
    private ExecuteCodeResponse getErrorResponse(Throwable e) {
        ExecuteCodeResponse executeCodeResponse = new ExecuteCodeResponse();
        executeCodeResponse.setOutputList(new ArrayList<>());
        executeCodeResponse.setMessage(e.getMessage());
        // 表示代码沙箱错误
        executeCodeResponse.setStatus(2);
        executeCodeResponse.setJudgeInfo(new JudgeInfo());
        return executeCodeResponse;
    }
}

测试流程：执行main方法进行测试，默认是编译执行resources/testCode/simpleComputeTrgs/Main.java文件

public class Main {
    public static void main(String[] args) {
        int a = Integer.parseInt(args[0]);
        int b = Integer.parseInt(args[1]);
        System.out.println("结果:" + (a + b));
    }
}

执行过程可以通过设置断点查看每一步的执行效果，例如生成文件=》编译=》执行=》结果整理=》文件清理=》返回响应结果

（3）沙箱优化

编写一些异常代码（在rsources/unsafeCode下编写多个异常代码，记得去掉包名），来针对性进行沙箱优化

去掉包名
且类名为Main

异常情况演示

编写Main方法，然后测试一些异常情况，查看会发生什么

1）执行阻塞，占用资源不释放

无限睡眠阻塞程序（提交的程序卡死了，就会占用沙箱资源）

/**
 * 无限睡眠（阻塞程序执行）
 */
public class Main {
    public static void main(String[] args) throws InterruptedException {
        long ONE_HOUR = 60 * 60 * 1000L;
        Thread.sleep(ONE_HOUR);
        System.out.println("睡完了");
    }
}

2）占用内存不释放

import java.util.ArrayList;
import java.util.List;

/**
 * 无限占用空间（浪费系统内存）
 */
public class Main {

    public static void main(String[] args) throws InterruptedException {
        List<byte[]> bytes = new ArrayList<>();
        while (true) {
            bytes.add(new byte[10000]);
        }
    }
}

实际运行中，会发现内存占用到达一定空间后，程序就自动报错：java.lang.OutOfMemoryError: Java heap space 。而不是无限增加内存占用，直到系统死机。例如当触发了内存溢出异常，程序报错，资源慢慢释放，这是 JVM 的一个保护机制。通过windows任务管理器查看idea的CPU占用率也是从一开始的一路飚高到慢慢释放、恢复正常状态

🚀🚀🚀推荐使用**JVisualVM 或 JConsole** 工具，都可以连接到 JVM 虚拟机上来可视化查看运行状态。

3）读文件（文件信息泄露）

直接通过相对路径获取文件信息

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

/**
 * 读取服务器文件（文件信息泄露）
 */
public class Main {
    public static void main(String[] args) throws IOException {
        String userDir = System.getProperty("user.dir");
        String filePath = userDir + File.separator + "src/main/resources/application.yml";
        List<String> allLines = Files.readAllLines(Paths.get(filePath));
        System.out.println(String.join("\n", allLines));
    }
}

4）写文件，越权植入木马

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;

/**
 * 向服务器写文件（植入危险程序）
 */
public class Main {

    public static void main(String[] args) throws InterruptedException, IOException {
        String userDir = System.getProperty("user.dir");
        String filePath = userDir + File.separator + "src/main/resources/木马程序.bat";
        String errorProgram = "java -version 2>&1";
        Files.write(Paths.get(filePath), Arrays.asList(errorProgram));
        System.out.println("写木马成功，你完了哈哈");
    }
}

5）运行其他程序

直接通过 Process 执行危险程序，或者电脑上的其他程序

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 运行其他程序（比如危险木马）
 */
public class Main {

    public static void main(String[] args) throws InterruptedException, IOException {
        String userDir = System.getProperty("user.dir");
        String filePath = userDir + File.separator + "src/main/resources/木马程序.bat";
        Process process = Runtime.getRuntime().exec(filePath);
        process.waitFor();
        // 分批获取进程的正常输出
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        // 逐行读取
        String compileOutputLine;
        while ((compileOutputLine = bufferedReader.readLine()) != null) {
            System.out.println(compileOutputLine);
        }
        System.out.println("执行异常程序成功");
    }
}

6）执行高危命令

甚至都不用写木马文件，直接执行系统自带的危险命令

比如删除服务器的所有文件

比如执行 dir （windows）、ls（linux）获取系统上的所有文件信息

🤡🤡快速测试

修改JavaNativeCodeSandbox的main方法，将code来源修改为指定的代码路径进行测试

String code = ResourceUtil.readStr("testCode/unsafeCode/RunFileError.java", StandardCharsets.UTF_8);

解决异常情况

1）超时控制（SleepError.java）

通过创建一个守护线程，超时后自动中断 process 实现：其原理在于在程序执行的时候创建一个守护线程（睡一段时间），当守护线程自动唤醒之后，如果发现代码还没执行完返回结果，就直接把执行代码的进程给杀掉。（这是一种基础的构建思路，需要思考如果这个进程还在正常运行的话需要做什么处理，结合实际场景分析）

// 设置超时控制时长
private static final long TIME_OUT = 5000L;

// 超时控制
new Thread(() -> {
    try {
        Thread.sleep(TIME_OUT);
        System.out.println("超时了，中断");
        runProcess.destroy();
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}).start();

此处针对SleepError的攻击防守，设置了5s超时时长限定，由于SleepError设置了超长时长睡眠，所以基于这个逻辑，新建的线程sleep 5s之后会中断这个runProcess线程，那么这里就会存在一个问题，是否要对runProcess的状态进行一个额外的判断，判断它是否执行完成，那么此处可以切换到正常执行的Code（testCode/simpleComputeArgs/Main.java）进行确认，会发现程序正常执行之后，会有超时提示，说明这里对正常情况下处理的逻辑需要进一步调整。

2）限制资源的分配（MemoryError.java）

不能让每个 java 进程的执行占用的 JVM 最大堆内存空间和系统的一致，实际上应该小一点，比如说 256 MB

在启动 Java 时，可以指定 JVM 的参数：-Xmx256吗（最大堆空间大小）-Xms（初始堆空间大小）

java -Xmx256m

查看效果，会发现它报错比以前更快了，是因为限制了它最大的资源，所以超出这个限额就会触发JVM的保护机制，中断程序

String code = ResourceUtil.readStr("testCode/unsafeCode/MemoryError.java", StandardCharsets.UTF_8);
String runCmd = String.format("java -Xmx256m -Dfile.encoding=UTF-8 -cp %s Main %s", userCodeParentPath, inputArgs);

可以试着将参数调大一点（4G：java -Xmx4096m），然后打开任务管理器跟踪idea的内存状态，会发现其cpu占用率慢慢升高，甚至可能超出设定的大小

String code = ResourceUtil.readStr("testCode/unsafeCode/MemoryError.java", StandardCharsets.UTF_8);
String runCmd = String.format("java -Xmx4096m -Dfile.encoding=UTF-8 -cp %s Main %s", userCodeParentPath, inputArgs);

注意！ -Xmx 参数、JVM 的堆内存限制，不等同于系统实际占用的最大资源，可能会超出。

因此如果需要更严格的内存限制，要在系统层面去限制，而不是 JVM 层面的限制

如果是 Linux 系统，可以使用 cgroup 来实现对某个进程的 CPU、内存等资源的分配。

补充：常用JVM启动参数

内存相关参数:

-Xms: 设置 JVM 的初始堆内存大小
-Xmx: 设置 JVM 的最大堆内存大小
-Xss: 设置线程的栈大小
-XX:MaxMetaspaceSize:设置 Metaspace(元空间)的最大大小
-XX:MaxDirectMemorySize:设置直接内存(Direct Memory)的最大大小

垃圾回收相关参数:

-XX:+UseSerialGC: 使用串行垃圾回收器。-XX:+UseParallelGC: 使用并行垃圾回收器
-XX:+UseConcMarkSweepGC: 使用 CMS 垃圾回收器,。-XX:+UseG1GC: 使用 G1 垃圾回收器

线程相关参数:

-XX:ParallelGCThreads: 设置并行垃圾回收的线程数
-XX:ConcGCThreads:设置并发垃圾回收的线程数
-XX:ThreadStackSize:设置线程的栈大小

JT 编译器相关参数:

-XX:TieredStopAtLevel: 设置JT 编译器停止编译的层次

其他资源限制参数:

-XX:MaxRAM: 设置 JVM 使用的最大内存

3）限制代码 - 黑白名单（ReadFileError.java、RunFileError.java）

定义一个黑名单，例如那些操作是禁止的，可以列一个列表

// 定义黑名单
public static final List<String> blackList = Arrays.asList("Files", "exec");

像是一些危险代码，可以在一开始就进行校验，不满足则剔除、不允许操作（甚至不需要走后面的编译，直接从源头扼杀）

基本思路构建：定义黑白名单列表，校验代码是否存在敏感字段，进而选择过滤

优化思考：引入Hutool的字典树代替存储单词

使用字典树代替表存储单词，用 更少的空间 存储更多的敏感词汇，并且实现 更高效的 敏感词查找。

🚀字典树原理：

字典树应用：使用HuTool工具类的字典树工具类，WordTree（不用自己手写）

先初始化字典树，插入禁用词

public static final WordTree WORD_TREE;

static {
    //初始化字典树
    WORD_TREE = new WordTree();
    WORD_TREE.addWords(blackList);
}

检验用户代码是否包含禁用词

//校验代码中是否可包含黑名单中的命令
FoundWord foundWord = WORD_TREE.matchWord(code);
if (foundWord != null) {
    System.out.println("包含禁止词：" + foundWord.getFoundWord());
    return null;
}

缺点：

无法遍历所有的黑名单
不同的编程语言，对应的领域、关键词都不一样，限制人工成本很大

4）限制权限-Java安全管理器（实现更严格的校验）

目标：限制用户对文件、内存、CPU、网络等资源的操作和访问

Java 安全管理器（Security Manager）是 Java 提供的保护 JVM、Java 安全的机制，可以实现更严格的资源和操作限制。

编写安全管理器，只需要继承SecurityManager：

所有权限放开

定义DefaultSecurityManager继承SecurityManager

package com.leeoj.leeojcodesandbox.security;

import java.security.Permission;

/**
 * 默认安全管理器
 */
public class DefaultSecurityManager extends SecurityManager{

    /**
     * 检查所有的权限
     * @param perm   the requested permission.
     */
    @Override
    public void checkPermission(Permission perm) {
        System.out.println("默认不做任何权限限制");
        System.out.println(perm);
        // super.checkPermission(perm);
    }
}

测试：在executeCode方法最开始设定安全管理器，然后查看效果。因为执行指令会涉及到资源访问、分配等，都需要SecurityManager管理，所以执行操作会被进行控制

所有权限拒绝

public class DenySecurityManager extends SecurityManager{

    /**
     * 检查所有的权限
     * @param perm   the requested permission.
     */
    @Override
    public void checkPermission(Permission perm) {
        throw new SecurityException("权限异常：" + perm.toString());
    }
}

DenySecurityManager：当触发到JAVA安全管理器控制范围，就会提示拒绝。例如此处到了读取文件（可以先注释掉前面黑白名单校验，进一步检测Java安全管理器的作用）部分就会提示报错

限制读权限

创建一个MySecurityManager，继承SecurityManager。自定义配置自己的权限规则（需要注意多个权限规则的影响），例如此处设定一个checkRead权限。

创建一个TestSecurityManager，测试MySecurityManager的校验规则

@Override
public void checkRead(String file, Object context) {
    throw new SecurityException("checkRead 权限异常：" + file);
}

经由checkRead限制，直接不允许hutool包使用，因此需要一步步进行放行，确认是否还有其他禁止读取的内容

	@Override
    public void checkRead(String file) {
        System.out.println(file);
        // 设置放行名单
        if (file.contains("hutool")) {
            return;
        }
        throw new SecurityException("checkRead 权限异常：" + file);
    }

调整后再次执行，提示 checkRead异常，不允许访问resources.jar，在读取真正目的文件前就做了层层限制。

PS：实际如果要使用SecurityManager的话，需要自行严格关注权限的使用，使用起来还是具备一定限制

SecurityManager应用

实际情况下，不应该在主类（开发者自己写的程序）中做限制，只需要限制子程序的权限即可。启动子进程执行命令时，设置安全管理器，而不是在外层设置（会限制住测试用例的读写和子命令的执行）

例如此处在executeCode方法开始就设定安全管理器System.setSecurityManager(new DenySecurityManager());，这个配置会限制当前程序的所有操作，但实际上目前的需求只希望限制住用户传入的代码，因此可以在运行java程序的时候就进行安全校验，指定相应的安全管理器。且每个代码不需要单独编译自己的一个安全管理器，将安全管理器放在程序项目指定位置，在执行代码的时候指定要引用的自定义安全管理器即可，可以节省空间

具体操作如下：（例如此处测试执行程序的操作限制RunFileError.java）

1）根据需要开发自定义的安全管理器（比如 MySecurityManager）

2）复制 MySecurityManager 类到 resources/security 目录下，移除类的包名

3）手动输入命令编译 MySecurityManager 类，得到 class 文件（javac -encoding utf-8 .\MySecurityManager.java，指令执行完成确认是否生成MySecurityManager.class）

4）在运行 java 程序时，指定安全管理器 class 文件的路径、安全管理器的名称。命令参考如下：

java -Dfile.encoding=UTF-8 -cp %s;%s -Djava.security.manager=MySecurityManager Main

回归程序代码设计：JavaNativeCodeSandbox（先取消掉前面的优化项，测试Java安全管理器的作用，此处主要测试RunFileError.java执行程序攻击是否生效）

修改指令：java -Dfile.encoding=UTF-8 -cp %s;%s -Djava.security.manager=%s Main %s，此处剖析指令中需要填充的参数依次分别是【执行程序代码根路径】、【安全管理器所在路径】、【安全管理器类名】、【执行参数】

// 自定义安全管理器存储路径
private static final String SECURITY_MANAGER_PATH = "E:\\workspace\\Git\\github\\PROJECT\\noob\\oj-platform\\oj-code-sandbox\\src\\main\\resources\\security";

// 自定义安全管理器类名
private static final String SECURITY_MANAGER_CLASS_NAME = "MySecurityManager";

// 指令
String runCmd = String.format("java -Dfile.encoding=UTF-8 -cp %s;%s -Djava.security.manager=%s Main %s", userCodeParentPath,SECURITY_MANAGER_PATH,SECURITY_MANAGER_CLASS_NAME, inputArgs);

安全管理器优缺点

优点：

权限控制很灵活
实现简单

缺点：

如果要做比较严格的权限控制，需要自己去判断哪些文件、包名需要允许读写。粒度太细了，难以精细化控制
安全管理器本身也是 Java 代码，也有可能存在漏洞。本质上还是程序层面的限制，没深入系统的层面

PS：JDK安全管理器不建议在Java9以上使用，后面安全管理器可能会有优化替代的计划

5）运行环境隔离

原理：操作系统层面上，把用户程序封装到沙箱里，和宿主机（我们的电脑 / 服务器）隔离开，使得用户的程序无法影响宿主机

实现方式：Docker 容器技术（底层是用 cgroup、namespace 等方式实现的），也可以直接使用 cgroup 实现

编译错误排查方案

细节1：javac 检查本地javac 指令执行是否正常，如果不是需要配置本地java环境

细节2：断点确认，查看当前上传的代码在哪个文件夹，然后去对应文件夹看生成的文件（默认写死都是Main,java(默认生成文件名都是这个)），如果说输入代码执行的时候自己写的public class类和Main不一样就提示

Main.java:1: 错误: 类Test是公共的, 应在名为 Test.java 的文件中声明
public class Test{
       ^
1 个错误

编译错误还需要注意：除了package部分不需要引入，其他依赖包和相关类定义都需要引入

编译错误提示信息：

2024-05-02 23:24:31.701 ERROR 14900 --- [nio-8090-exec-4] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.lang.RuntimeException: java.lang.RuntimeException: 编译错误] with root cause

java.lang.RuntimeException: 编译错误
	at com.yupi.yuojcodesandbox.JavaCodeSandboxTemplate.compileFile(JavaCodeSandboxTemplate.java:89) ~[classes/:na]
	at com.yupi.yuojcodesandbox.JavaCodeSandboxTemplate.executeCode(JavaCodeSandboxTemplate.java:40) ~[classes/:na]
	at com.yupi.yuojcodesandbox.JavaNativeCodeSandbox.executeCode(JavaNativeCodeSandbox.java:15) ~[classes/:na]
	at com.yupi.yuojcodesandbox.controller.MainController.executeCode(MainController.java:49) ~[classes/:na]
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:na]
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:77) ~[na:na]
	at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:na]
	at java.base/java.lang.reflect.Method.invoke(Method.java:568) ~[na:na]
	at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:205) ~[spring-web-5.3.29.jar:5.3.29]

状态status：判题状态（2-成功）

通过率的计算规则：

<template #acceptedRate="{ record }">
        {{
          `${
            record.submitNum ? record.acceptedNum / record.submitNum : "0"
          }% (${record.acceptedNum}/${record.submitNum})`
        }}
      </template>

异步执行判题服务，然后判题服务中需要根据响应结果修改内容（例如题目提交数、题目的通过数等信息）（暂时还没开发）

昵称

邮箱

网址

按正序
按倒序
按热度