【Spring Boot实战】在线学习平台

错误思路：直接将头像存到数据库中，需要头像时访问数据库，数据库将头像解析为字节流返回，最后写到本地的某一个文件。这种方法太耗费资源和时间。
正确思路：将头像保存在操作系统上，然后把这个文件路径记录下来存储到数据库。记录路径非常便捷和方便。如果要打开头像可以依据这个路径找到这个头像。稍微大一点的公司都会将所有的静态资源(图片,文件,其他资源文件)放到某台电脑上，再把这台电脑作为一台单独的服务器使用。

2.1.2 登录密码如何加密？

密码加密作用：后端不能直接看到用户的密码、忽略用户密码原来的强度，提升数据的安全性

如何对密码进行加密：使用盐值。盐值是使用UUID生成的一个随机字符串。盐值+用户输入的密码+盐值，对这个整体使用md5算法连续加密三次。将加密后的密码和盐值存储到数据库中。

为什么要存储盐值呢？当用户登录时，根据用户输入的密码和数据库存储的盐值，使用与注册时同样的加密算法，如果加密后的结果和数据库存储的密码一致，证明密码输入正确。


        String salt = UUID.randomUUID().toString().toUpperCase();
        String md5Password = getMD5Password(password,salt);
    private String getMD5Password(String password, String salt) {
        for (int i = 0; i < 3; i++) {
            password = DigestUtils.md5DigestAsHex((salt+password+salt).getBytes()).toUpperCase();
        }
        System.out.println(password);
        return password;
    }

2.2 创建实体类

2.2.1 @Data的作用？

提高代码的简洁性，可以省去代码中大量的get()、set()等方法。

2.2.2 设计实体类时不同表之间有很多公共字段，怎么处理？

假设每个表都有createdUser、createdTime、modifiedUser、emodifiedTime这四个属性。在设计实体类时，创建一个BaseEntity实体类基类，将四这个公共属性放入该类中。其他类继承该基类即可。就不用相同的属性在每个实体类中都写一遍，提高了代码的简洁性。

2.2.3 实体类需要加上@component吗？(Spring Boot和Spring MVC的区别)

ssm框架开发项目的时候需要在实体类上面加@Component然后spring才能自动进行对象的创建维护,而springboot不再需要,因为springboot遵循的原则是约定大于配置,如果字段名称相同那就可以自动完成字段的初始化

2.3 持久层

2.3.1 useGeneratedKeys="true" keyProperty="userId"的意义？

useGeneratedKeys="true"表示开启主键自增，keyProperty="userId"指明userId是主键。

2.3.2 resultType和ResultMap的区别？

select语句的查询语句有两种：一个对象或者多个对象

resultType：用来指定查询结果对应的实体类的类型，需要包含完整的包结构。这种写法要求表的字段的名字和类的属性名一模一样。
resultMap:当表的字段和类的对象属性名不一致时,来自定义查询结果集的映射规则。映射的好处:使SQL语句和java代码分离,解耦了,方便后期代码的维护

2.3.3 ResultMap的使用方式

数据库中字段：userId(主键)、username、is_delete、create_user

实体类的属性：userId、username、isDelete、createUser

可以看到，数据库中的字段和实体类的属性不一样，怎么使用resultMap表示查询结果呢？

step1：使用resultMap标签定义映射规则


<resultMap id="UserEntityMap" type="com.cy.store.entity.User">
    <id column="userId" property="userId">id>
    <result column="is_delete" property="isDelete">result>
    <result column="create_user" property="createUser">result>
resultMap>

注意事项：

id：给映射规则分配一个唯一的id值
type：是一个类，表示数据库的查询结果要映射Java中实体类的名称
将表的字段和类的属性名不一致的进行匹配指定,名称一致的也可以指定,但没必要
在定义映射规则时无论主键名称是否一致都不能省
column属性:表示表中的字段名称
property属性:表示类中的属性名称

step2：在select语句中应用该映射规则


<select id="getUserByName" resultMap="UserEntityMap">
    select * from user where username=#{username}
select>

2.4 如何进行单元测试

方法：Lesson 8: MyBatis_刘减减的博客-CSDN博客2.3.2小结

注意事项：

①加注解@SpringBootTest，表明当前单元测试的框架是SpringBoot，不是其他

②将需要测试的类引入


package com.example.demo.mapper;
 
import com.example.demo.model.User;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
 
import javax.annotation.Resource;
 
import static org.junit.jupiter.api.Assertions.*;
 
@SpringBootTest
class UserMapperTest {
 
    @Resource
    private UserMapper userMapper;
    @Test
    void register() {
        User user = new User();
        user.setUserName("a");
        user.setPassword("1111");
        userMapper.register(user);
    }
    @Test
    void getUserByName() {
        User user = userMapper.getUserByName("aaa");
        System.out.println(user);
    }
}

2.5 异常处理

2.5.1 为什么会有异常

以注册业务为例，如果用户名已经注册过，此时需要抛一个异常。在往数据库插入数据时，因为数据库宕机等原因，导致插入失败，此处也需要抛一个异常。

2.5.2 怎么处理异常

抛异常时，不能直接抛出RuntimeException。原因是：太笼统了。开发者没办法定位到异常的具体位置。

在开发时，控制层和业务层都可能产生异常，为了更科学准确的定位到异常出现的位置，我们对异常进行分级，创建ServiceException业务层异常基类和ControllerException控制层异常基类，这两个异常继承RuntimeException。

2.5.3 具体思路

在ex包下创建ServiceException业务层异常基类，重写父类的所有构造方法，以便后期抛出自己定义的异常


package com.example.demo.service.exuser;
 
public class ServiceException extends RuntimeException{
    public ServiceException() {
        super();
    }
 
    public ServiceException(String message) {
        super(message);
    }
 
    public ServiceException(String message, Throwable cause) {
        super(message, cause);
    }
 
    public ServiceException(Throwable cause) {
        super(cause);
    }
 
    protected ServiceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

根据业务层需要实现的功能，分析可能存在的异常。对这些异常进行定义，并继承ServiceException。以注册功能为例，可能会出现用户名已经存在这种异常。创建DuplicatedUsernameException异常类，继承ServiceException，并重写所有的构造方法。


package com.example.demo.service.exuser;
 
public class DuplicatedUsernameException extends ServiceException{
    public DuplicatedUsernameException() {
        super();
    }
 
    public DuplicatedUsernameException(String message) {
        super(message);
    }
 
    public DuplicatedUsernameException(String message, Throwable cause) {
        super(message, cause);
    }
 
    public DuplicatedUsernameException(Throwable cause) {
        super(cause);
    }
 
    protected DuplicatedUsernameException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

正在执行数据插入操作的时候,服务器宕机或数据库宕机.这种情况是处于正在执行插入的过程中所产生的异常,起名InsertFailedException异常


package com.example.demo.service.exuser;
 
public class InsertFailedException extends ServiceException{
    public InsertFailedException() {
        super();
    }
 
    public InsertFailedException(String message) {
        super(message);
    }
 
    public InsertFailedException(String message, Throwable cause) {
        super(message, cause);
    }
 
    public InsertFailedException(Throwable cause) {
        super(cause);
    }
 
    protected InsertFailedException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

2.5.4 统一异常处理

step1：在控制层创建一个BaseController父类，在这个父类中统一处理异常。


public class BaseController {
    // 操作成功的状态码
    public static final int OK = 200;
 
    @ExceptionHandler({ServiceException.class, ControllerException.class})
    public JsonResult handleException(Throwable e){
        JsonResult result = new JsonResult<>();
        if(e instanceof DuplicatedUsernameException){
            result.setState(5000);
            result.setMessage(e.getMessage());
        }else if(e instanceof InsertFailedException){
            result.setState(5001);
            result.setMessage(e.getMessage());
        }else if(e instanceof IllegalParaException){
            result.setState(5002);
            result.setMessage(e.getMessage());
        }
        return result;
    }
 
}

Question1：@ExceptionHandler的作用？

该注解表示被修饰的方法用于处理捕获的异常。怎样的异常会被这个方法处理呢？ControllerException.class说明了异常的类型。

如果异常发生后，异常对象就会自动被传递到此方法的参数列表上，所以形参写的是Throwable。

step2：让UserController继承BaseController。此时，不需要关注异常的处理，只需要关注请求的处理过程。

2.6 规范响应格式

2.6.1 分析数据作用，对从数据库读出来的数据进行筛选

以登录为例，login返回的用户数据是为了辅助其他页面做数据展示使用(只会用到uid,username,avatar)，所以可以new一个新的user只赋这三个变量的值,这样使层与层之间传输时数据体量变小,后台层与层之间传输时数据量越小性能越高,前端也是的,数据量小了前端响应速度就变快了。

2.6.2 统一规范响应格式

当后端收到前端发来的请求时，需要返回响应。为了规范响应的格式。约定：响应中包含状态码、状态描述信息和数据三部分。将这三个参数封装到JsonResult类中，将这个类作为方法的返回值返回给前端。


package com.example.demo.controller;
 
import lombok.Data;
 
import java.io.Serializable;
 
@Data
public class JsonResult implements Serializable {
    // 状态码
    private int state;
    // 描述消息
    private String message;
    // 数据类型不确定。用E表示任何的数据类型
    // 如果类里有声明的泛型，数据类型，类也要声明为泛型类
    private E data;
    public JsonResult(){
    }
    public JsonResult(int state){
        this.state = state;
    }
    public JsonResult(int state, E data){
        this.state = state;
        this.data = data;
    }
    public JsonResult(int state, String message){
        this.state = state;
        this.message = message;
    }
}

2.7 session的使用

2.7.1 为什么要使用session

首次登录后，需要将用户的userId和userName信息保存在session中，也要保证其他类和方法要能访问到session中存储的对象。获取session中对象的属性值使用session.getAttribute(“key”)。因为很多功能都会访问session中存储的对象，因此，可以将从session中获取数据的方法进行封装。

可以封装在一个工具类中，在当前的项目中，只可能会在控制层使用session。controller包里的类都继承BaseController。所以，将从session获取uid和username的方法封装到BaseController这个类下。


    public final int getUserIDFromSession(HttpSession session){
        // getAttribute返回的是Object对象，需要先转为String，再转为int
        return Integer.valueOf(session.getAttribute("userId").toString());
    }
 
    public final String getUsernameBySession(HttpSession session){
        return session.getAttribute("userName").toString();
    }

注意事项：getAttribute返回的是Object对象，如果向获取userId，需要先转为String，再转为int

2.7.2 如何获取session

自己创建：HttpSession session = req.getSession(true);
使用服务器创建的session：服务器本身会自动创建session，并且该session是全局的。如何获取这个session呢？将HttpSession作为处理请求方法的参数，SpringBoot会自动将全局的session对象注入到请求方法的形参上。


    @RequestMapping("/login")
    public JsonResult login(String username, String password, HttpSession session){
        if(!StringUtils.hasLength(username) || !StringUtils.hasLength(password)){
            throw new IllegalParaException("输入的用户名或者密码不能为空");
        }
        User user = userService.login(username,password);
        session.setAttribute("userId",user.getUserId());
        session.setAttribute("userName",user.getUserName());
        session.setAttribute("avatar",user.getAvatar());
        return new JsonResult<>(OK);
    }

2.8 拦截器的使用

博客系统中每个功能的实现都需要先判断用户是否登录，同样功能的代码写了多次，增加了程序的冗余度，同时增加了后期的修改成本和维修成本。

在用户登录之后，将用户的登录信息保存在session中，在实现其他的功能时，需要先读取session中的userId信息，如果可以无法读到登录的用户信息，则跳转到登录页面。

同时，并不是所有得方法都需要验证用户的登录信息，如登录和注册。将问题总结为以下两点：

我们可以使用Spring拦截器HandlerInterceptor，拦截器的实现分两个步骤：

setp1：创建自定义拦截器，实现HandlerInterceptor接口的preHandle方法。


public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession session = request.getSession(false);
        if(session == null || session.getAttribute("userId") == null){
            response.sendRedirect("login.html");
            // 如果是false,，访问到此结束
            return false;
        }
        // 如果时true，可以接着访问你想要访问的目标方法
        return true;
    }
}

step2：将自定义的拦截器加入WebMvcConfigure的addInterceptors方法中。


// 将拦截器添加到全局的配置的文件中
@Configuration
public class LoginInterceptorConfigue implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 自定义的拦截器
        HandlerInterceptor interceptor = new LoginInterceptor();
        // 将白名单放在一个List集合里
        List patterns = new ArrayList<>();
        patterns.add("/css/**");
        patterns.add("/editor.md/**");
        patterns.add("/images/**");
        patterns.add("/pictures/**");
        patterns.add("/regist.html");
        patterns.add("/login.html");
        patterns.add("/user/reg");
        patterns.add("/user/login");
        registry.addInterceptor(interceptor) // 指明拦截器
                .addPathPatterns("/**")  // 需要拦截的URL，**表示拦截任意方法
                .excludePathPatterns(patterns);  // 需要排除的URL和静态文件，如图片、css、js、登录、注册
    }
}

注意事项：

@Configuration不能少。如果没有这个注解，这个拦截器将不会被加到全局配置文件中，拦截器就会不起作用。

2.9 if和trim标签的使用，使用同一个sql语句实现多个功能


<update id="editBlog">
        update blog set
            <trim prefixOverrides="," suffixOverrides=",">
                <if test="blogTitle != null and blogTitle !=''">
                    blogTitle = #{blogTitle},
                if>
                <if test="blogContent != null and blogContent !=''">
                    blogContent = #{blogContent}
                if>
            trim>
        where
            blogId = #{blogId}
    update>

2.10 前端问题汇总

2.10.1 头像的展示

因为SpringBoot有内置的Tomcat服务器，上传的文件是存放在一个临时目录里。重启后会生成新的目录，这就会导致原来上传的图片重启后访问不到。

为了解决这个问题，使用配置本地资源映射路径的方案。可以将图片保存在本地

第一步：

静态资源路径是指系统可以直接访问的路径，且路径下的所有文件均可被用户直接读取。

Springboot中默认的静态资源路径有：classpath:/META-INF/resources/，classpath:/resources/，classpath:/static/，classpath:/public/，从这里可以看出这里的静态资源路径都是在classpath中（也就是在项目路径下指定的这几个文件夹）

如果将上传的文件存放在静态资源路径下，会导致以下问题：

网站数据和程序代码不能有效分离、网站数据会很难备份这些问题。

为了解决这个问题，可以将静态资源设置到本地磁盘的某个目录。

创建WebAppConfig类，实现WebMvcConfigurer接口，重写addResourceHandlers方法。


package com.example.demo.config;
 
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
@Configuration
public class WebAppConfig implements WebMvcConfigurer {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/image/**").addResourceLocations("file:C:\\Users\\Desktop\\Java\\images\\");
    }
}

addResourceHandler：访问的映射路径

addResourceLocations：资源的绝对路径(打算在本地磁盘上存储的位置)

将图片存储在"C:\\Users\\Desktop\\Java\\images\\"这个目录下，使用"/image/"+fileName来访问这个图片。


    @RequestMapping("/updateAvatar")
    public JsonResult updateAvatar(HttpServletRequest request, MultipartFile file){
        if(file.isEmpty()){
            throw new FileEmptyException("文件为空");
        }
        if(file.getSize() > AVATAR_MAX_SIZE){
            throw new FileSizeException("文件大小超出了限制");
        }
        if(!AVATAR_TYPE.contains(file.getContentType())){
            throw new FileTypeException("文件类型不支持");
        }
        HttpSession session = request.getSession(false);
//        // 创建存储头像的目录
        String rootPath = "C:\\Users\\LIUJIA\\Desktop\\Java\\images\\";  //上传后的路径
 
        File dir = new File(rootPath);
        if(!dir.exists()){
            dir.mkdirs();
        }
        // 确定保存的文件名，用uuid生成一个新的文件名
        String oriFileName = file.getOriginalFilename();
        int lastIndex = oriFileName.lastIndexOf(".");
        String suffix = oriFileName.substring(lastIndex);
        System.out.println(suffix);
        String fileName = UUID.randomUUID().toString().toUpperCase(Locale.ROOT)+suffix;
        System.out.println(fileName);
        // 在dir目录下创建文件，第一个参数表示存储的文件夹，第二个表示存储的文件
        File destFile = new File(dir,fileName);
        try {
            // 保存上传文件
            file.transferTo(destFile);  // 将file文件中的数据写入到dest文件中
        } catch (FileStateException e){
            throw new FileStateException("文件状态异常");
        } catch (IOException e) {
            throw new FileLoadException("文件读写异常");
        }
        Integer userId = getUserIDFromSession(session);
        String avator = "/image/"+fileName;
        userService.uploadAvatar(userId,avator);
        return new JsonResult<>(OK,avator);
    }

2.10.1 使用form表单实现上传文件的的注意事项

form表单的请求方式必须设置为POST，并配置属性enctype="multipart/form-data"，文件上传input控件的name属性值需设置为file值。

2.10.2 将页面按照markdown的形式显示

先在博客编辑区的div中放一个隐藏的text area。再在初始化editor对象的时候，指定一个特殊的选项saveHTMLToTextArea:true,这个选项的功能就是editor.md把用户编辑的正文放到这个text area里面。


<div class="container">
        <div class="container-edit">
            
            <form action="edit" method="post" style="height: 100%">
                <div class="container-edit-title">
                    <input type="text"  id="title" autocomplete="off" placeholder="在这里输入标题" name="title">
                    
                    <input type="submit" value="发布文章" class="submit-button">
                div>
                <div id="editor" >
                    <textarea name="content" style="display: none">textarea>
                div>
            form>
            
        div>
    div>
    <script>
            // 初始化 editor.md
            var editor = editormd("editor", {
            // 这里的尺寸必须在这里设置. 设置样式会被 editormd 自动覆盖掉. 
            width: "1000px",
            // 设定编辑器高度
            height: "calc(100% - 60px)",
            // 编辑器中的初始内容
            markdown: "# 在这里写下一篇博客",
            // 指定 editor.md 依赖的插件路径
            path: "./editor.md/lib/",
            saveHTMLToTextArea:true
        });
    script>

借助editor.md的内置功能，将博客显示出来。


    <script>
        // 先从html中拿到要渲染的字符串
        var markdown = document.querySelector("#content").innerHTML;
        // 清空原来的div
        document.querySelector("#content").innerHTML = "";
        // 通过内置的方式完成渲染,要想能够调用, 也需要先引入 editor.md 的 js 
        editormd.markdownToHTML('content',{markdown:markdown})
    script>

2.10.3 博客的内容太多，超过设置的背景

给背景加上个css属性：overflow:auto 如果当前元素的内容溢出，就会自动加个滚动条。此时指的是给标签加上滚动条，而不是给页面加上滚动条。

三、在线OJ模块

3.1 实现思路

有一个服务器的进程一直运行着，用户的代码从前端传来。服务器的进程先创建一个子进程对该代码进行编译。随后，再创建一个子进程对编译好的代码进行运行。随后，服务器返回运行结果。

3.2 前期准备

3.2.1 为什么创建的是进程不是线程？

因为每个用户提供的代码是一个独立的逻辑，同时，我们无法控制用户输入的代码，很可能代码运行会导致系统崩溃。考虑到进程的稳定性，所以采用多进程编程的思路。

3.2.2 如何创建进程？

首先，被创建的进程称为子进程，创建子进程的进程称为父进程。在该项目中，服务器进程相当于父进程，根据用户的代码创建的进程称为子进程。一个父进程可以有多个子进程。(谈到多进程，会经常涉及到父进程和子进程，但是线程没有父线程和子线程的说法)。

其次，关于多进程编程，JAVA提供了两个操作。第一个是进程创建，第二个是进程等待。

Process process = Runtime.getRuntime().exec(cmd);

①通过Runtime获取到Runtime对象，此对象是一个单例对象。然后exec得到Process对象。通过这个代码，可以创建出子进程。此时父子进程之间，是并发执行的关系。但是，在该项目中，当用户提交的代码编译运行完毕了后，需要将结果返回给用户。因此，我们需要让父进程知道子进程的执行状态。因此，需要加上进程等待的语句

int exitCode = process.waitFor();

②执行Runtime.getRuntime().exec(cmd)这行代码，就相当于在cmd输入一条命令。当在cmd输入一条命令。操作系统会去一些特定的目录中查找这个可执行文件，找到才能执行。怎么确保能够找到？将javac所在的目录加到PATH环境变量中。

③Javac是一个控制台程序，他的输出是存放在“标准输出”和“标准错误”这两个特殊的文件中。要想看到这个程序的运行效果，就需要获得标准输出和标准错误的内容。

3.2.3 如何获取标准输出和标准错误？

当一个进程在启动时，会自动打开三个文件。标准输入(对应到键盘)、标准输出(对应到显示器)、标准错误(对应到显示器)。虽然子进程启动后同样也打开这三个文件，但是由于子进程没有和IDEA的终端关联，因此在IDEA中看不到子进程的输出的。要想获得输出，就需要在代码中手动获取到。

获取标准输出：

InputStream stdoutFrom = process.getInputStream();

获取标准错误：

InputStream stderrFrom = process.getErrorStream();

获取到标准输出和标准错误后，我们需要将其写入到文件中。随后通过读文件，就可以看到程序的执行效果。

3.3 实现FileUtil类(封装读写文件的操作)

3.3.1 实现代码

在第四小结，将进程的标准输出和标准错误写到文件中，在QuestionController模块，我们需要将编译子进程、运行子进程的标准输入和标准输入从文件中读取出来。虽然Java本身已经提供了很多关于文件读写操作的方法，但是使用稍微麻烦一点。为了便于使用，对这些操作进一步封装为一个类FileUtil，创建两个方法，第一个方法是将文件的内容读出来，第二个方法是将String写入文件中。


package com.example.demo.compile;
 
import org.springframework.stereotype.Component;
 
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
@Component
public class FileUtil {
    // 将文件的值读到一个String里面
    public static String readFile(String path){
        StringBuilder content = new StringBuilder();
        try(FileReader fileReader = new FileReader(path)){
            while (true){
                int ch = fileReader.read();
                if(ch == -1){
                    break;
                }
                content.append((char)ch);
            }
 
        }catch (IOException e){
            e.printStackTrace();
        }
        return content.toString();
    }
    // 将String写入文件中
    public static void writeFile(String content,String path){
        try(FileWriter fileWriter = new FileWriter(path)){
            fileWriter.write(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        String path = "E:\\hello.txt";
        String content = readFile(path);
        System.out.println(content);
        writeFile("mybatis","E:\\hello.txt");
    }
}

3.3.2 注意事项

①对于文本文件来说，字节流和字符流都可以进行读写，为什么选择字符流？

与字符流相比，字节流会更麻烦一点，体现为：当文件中包含中文的时候，需要手动的处理编码格式。

②返回的类型是一个字节byte，为什么使用int来接收？

Java中不存在无符号数，byte也是有符号的，范围是[-128,127]。byte占一个字节空间，最高位是符号位，剩余7位能表示0-127，加上符号位的正负，就是-127至+127，但负0没必要，为充分利用，就用负零表示-128（即原码1000，0000）。（计算机转补码后存储）

但是在实际中，因为读出来的只是表示一个单纯的字符，并不是要进行加减运算，因此期望读到的是一个无符号的数字，将范围改为(0,255)使用int表示，文件还没读完时，返回一个int。如果读到末尾返回EOF，end of file，用-1表示，证明文件已经读完。

③文件读写完需要关闭，否则会导致文件资源泄露

受限于操作系统内核里面的实现，一个进程能够同时打开的文件个数是存在上限的。对于Linux来说，进程PCB中的文件操作符表属性，大小是存在上限的。可以通过ulimit命令来查看和修改进程能够支持的最大文件个数。

④为什么不使用StringBuffer

因为String是不可变对象，为了方便对String的修改。可以使用StringBuilder(线程不安全)和StringBuffer(线程安全)。当多个线程同时修改同一个变量，会触发线程安全问题。刚刚创建的StringBuilder是函数里面的局部变量在栈上，由于每个线程都有自己的栈。所以不会引起线程安全问题。没必要使用StringBuffer。

3.4 实现CommandUtil类(利用cmd执行命令)

根据传入的语句创建进程——》获取进程的标准输出，并将其写入到特定文件中——》获取进程的标准错误，并将其写入到特定文件中——》返回进程的状态码。


package com.example.demo.compile;
 
import org.springframework.stereotype.Component;
 
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
@Component
public class CommandUtil {
    public static int run(String cmd,String stdoutFilePath,String stderrFilePath){
        try {
            Process process = Runtime.getRuntime().exec(cmd);
            if(stdoutFilePath != null){
                // 获取运行的标准输出
                InputStream stdoutFrom = process.getInputStream();
                // 将标准输出写入到文件中
                OutputStream stdoutTo = new FileOutputStream(stdoutFilePath);
                while (true){
                    int ch = stdoutFrom.read();
                    if(ch == -1){
                        break;
                    }
                    stdoutTo.write(ch);
                }
                stdoutFrom.close();
                stdoutTo.close();
            }
            if(stderrFilePath != null){
                // 获取运行的标准错误
                InputStream stderrFrom = process.getErrorStream();
                // 将标准错误写入到文件中
                OutputStream stderrTo = new FileOutputStream(stderrFilePath);
                while (true){
                    int ch = stderrFrom.read();
                    if(ch == -1){
                        break;
                    }
                    stderrTo.write(ch);
                }
                stderrFrom.close();
                stderrTo.close();
            }
            // 等到子进程结束，拿到子进程的状态码，并返回
            int exitCode = process.exitValue();
            return exitCode;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return 1;
    }
 
    public static void main(String[] args) {
        run("javac","E://stdout.txt","E://stderr.txt");
    }
}

3.5 创建Task类，实现编译运行的全过程

3.5.1 实现思路

实现一个Task类。基于CommandUtil，Task类主要是实现一个完整的编译和运行这样的模块。该模块的输入是用户提交的代码，输出是代码的编译结果和运行结果。该模块的执行逻为：

前置条件：服务器进程一直在运行

第一步：服务器收到用户发送的代码，判断其安全性。主要检查代码中是否包含Runtime、exec(这两个防止提交的代码运行恶意程序)、java.io（禁止提交的代码读写文件）、java.net（禁止提交的代码访问网络）这三个关键字。
第二步：服务器进程创建子进程，执行javac命令进行编译。需要指定.class文件的位置，免得运行时找不到。
第三步：服务器进程读取编译生成的标准错误的内容，判断是否为空。不为空则证明编译不通过，返回编译出错结果。如果为空，证明编译成功，进入下一步运行。
第四步：服务器进程创建子进程，执行java命令进行运行。.class文件的位置与第二步保存的位置一致。
第五步：服务器进程读取运行的标准错误的内容，如果为空证明运行错误，返回运行出错信息。
第六步：服务器进程读取运行的标准输出的内容，返回运行结果。

注意：

①javac进程和Java这两个进程需要通信。Linux系统提供管道、消息队列、信号量、信号、socket、文件等通信方式，在该项目中，使用文件来进行通信。因此，我们需要约定一个临时文件。

②因为在JAVA中，类名和文件名需要一致，我们约定好类名和文件名都是Solution。

③约定

error = 0，编译运行都通过

error = 1，编译错误

error = 2，运行错误

reason：存放错误信息

stdout：存放标准输出

stderr：存放标准错误

3.5.2 检查用户提交代码安全性的补充（使用docker）

目前使用的这个黑名单的方式，只能简单粗暴的处理掉一批明显的安全漏洞，但是还是存在安全隐患。有一种更彻底的解决这个问题的方式：

docker相当于一个轻量级虚拟机，每次用户提交的代码，都会给这个代码分配一个docker容器，让用户提交的代码在容器中执行，如果这个容器中有恶意代码，最多也就是将docker容器搞坏了，对物理机没有任何影响。同时docker的设计天然就是很轻量的，一个容器可以随时创建随时删除。

该容器和tomcat、servlet容器没有关系，和Spring中的bean容器也没有关系，也和c++STL里的容器没有关系。


package com.example.demo.compile;
 
import com.example.demo.model.Answer;
import com.example.demo.model.UserCode;
import org.springframework.stereotype.Component;
 
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
 
@Component
public class Task {
    // 用一组常量来约定临时变量的名字
    private String WORK_DIR = null;  // 目录
    private String CLASSNAME = null; // 类名
    private String CODE = null; //代码的文件名
    private String COMPILE_ERROR = null; // 编译错误
    private String STDOUT = null; //  标准输出
    private String STDERR = null;  // 标准输入
 
    public Task(){
        WORK_DIR = "E://OJ//"+ UUID.randomUUID()+"//";
        CLASSNAME = "Solution";
        CODE = WORK_DIR+"Solution.java";
        COMPILE_ERROR = WORK_DIR + "compileError.txt";
        STDOUT = WORK_DIR + "stdout.txt";
        STDERR = WORK_DIR + "stderr.txt";
    }
 
    public Answer compileAndRun(UserCode userCode){
        Answer answer = new Answer();
        // 准备用来存放临时文件的目录
        File workFile = new File(WORK_DIR);
        if(!workFile.exists()){
            workFile.mkdirs();
        }
 
        // 对代码的安全性进行判定
        if(!checkCodeSafe(userCode.getUserCode())){
            System.out.println("用户提交了不安全的代码");
            answer.setError(3);
            answer.setReason("\"您提交的代码可能会危害到服务器, 禁止运行!\"");
            return answer;
        }
        // 将question中的code写入到CODE中
        FileUtil.writeFile(userCode.getUserCode(),CODE);
 
        // 进行编译，javac -d 用来指定生成的 .class 文件的位置
        String compileCmd = String.format("javac -encoding utf8 %s -d %s",CODE,WORK_DIR);
        System.out.println("编译的命令"+compileCmd);
        CommandUtil.run(compileCmd,null,COMPILE_ERROR);
        String compileError = FileUtil.readFile(COMPILE_ERROR);
        if(!compileError.equals("")){
            System.out.println("编译出错");
            answer.setError(1);
            answer.setReason(compileError);
            return answer;
        }
        //进行运行
        String runCmd = String.format("java -classpath %s %s",WORK_DIR,CLASSNAME);
        System.out.println("编译命令"+runCmd);
        CommandUtil.run(runCmd,STDOUT,STDERR);
        String stdErr = FileUtil.readFile(STDERR);
        if(!stdErr.equals("")){
            System.out.println("运行出错");
            answer.setError(2);
            answer.setReason(stdErr);
            return answer;
        }
        answer.setError(0);
        answer.setStdout(FileUtil.readFile(STDOUT));
        return answer;
    }
 
    private boolean checkCodeSafe(String code) {
        List blackList = new ArrayList<>();
        // 防止提交的代码运行恶意程序
        blackList.add("Runtime");
        blackList.add("exec");
        // 禁止提交的代码读写文件
        blackList.add("java.io");
        // 禁止提交的代码访问网络
        blackList.add("java.net");
        for(String str:blackList){
            int pos = code.indexOf(str);
            if(pos >= 0){
                return false; // 找到任意的恶意代码特征, 返回 false 表示不安全
            }
        }
        return true;
 
    }
 
    public static void main(String[] args) {
        Task task = new Task();
        UserCode userCode = new UserCode();
        userCode.setUserCode("public class Solution {\n" +
                "    public static void main(String[] args) {\n" +
                "        System.out.println(\"hello\");\n" +
                "    }\n" +
                "}");
        Answer answer = task.compileAndRun(userCode);
        System.out.println(answer.toString());
    }
}

3.6 前端问题汇总

3.6.1 向服务器发送当前用户编写的代码，并且获取运行结果

思路为：从请求中获取题目id—》根据id去数据库查题目——》获取该题目的测试代码——》从请求中获取用户提交的代码——》将两个代码组合，并判断是否为空——》实例化一个Task，进行编译运行该代码——》构造响应，并返回。

注意：@RequestBody注解指明返回的数据类型是json。


    @RequestMapping("/compile")
    public CompileResponse solve(@RequestBody RequestCode requestCode){
        try{
            // 获取题目id
            int questionId = requestCode.questionId;
            // 去数据库查询题目
            QuestionInfo questionInfo = questionMapper.selectQuestionById(questionId);
            // 没找到，报异常
            if(questionInfo == null){
                throw new QuestionNotFountException();
            }
            // 获取用户提交的代码
            String userCode = requestCode.code;
//            String userCode = "public class Solution {\n" +
//                    "    public static int sum(int a,int b){\n" +
//                    "        return a+b;\n" +
//                    "    }\n" +
//                    "}";
            // 获取题目的测试代码
            String testCode = questionInfo.getTestCode();
//            String testCode = "    public static void main(String[] args) {\n" +
//                    "        int a = 1;\n" +
//                    "        int b = 2;\n" +
//                    "        int c = sum(a,b);\n" +
//                    "        System.out.println(c);\n" +
//                    "    }";
            // 将两个代码组合
            String finalCode = merge(userCode,testCode);
            System.out.println(finalCode);
            // 判断代码是否合法
            if(finalCode == null){
                throw new CodeInvalidException();
            }
            // 实例化一个Task，编译运行代码
            Task task = new Task();
            UserCode userCode1 = new UserCode();
            userCode1.setUserCode(finalCode);
            Answer answer = task.compileAndRun(userCode1);
            System.out.println(answer);
 
            // 构造响应
            compileResponse.error = answer.getError();
            compileResponse.reason = answer.getReason();
            compileResponse.stdout = answer.getStdout();
 
        }catch (QuestionNotFountException e){
            compileResponse.error = 3;
            compileResponse.reason = "没有找到指定的题目! id="+requestCode.questionId;
            e.printStackTrace();
        }catch (CodeInvalidException e){
            compileResponse.error = 3;
            compileResponse.reason = "提交的代码不符合要求!"+requestCode.questionId;
            e.printStackTrace();
        }finally {
            return compileResponse;
        }
    }

3.6.2 引入代码编辑器组件ace.js


// 引入ace.js
<script src="https://cdn.bootcss.com/ace/1.2.9/ace.js">script>
<script src="https://cdn.bootcss.com/ace/1.2.9/ext-language_tools.js">script>
 
// 将页面编辑框外面套一层 div, id 设为 editor, 并且一定要设置 min-height 属性.
<div id="editor" style="min-height:400px">
    <textarea style="width: 100%; height: 200px">textarea>
div>
 
// 对编译器进行初始化
function initAce() {
    // 参数 editor 就对应到刚才在 html 里加的那个 div 的 id
    let editor = ace.edit("editor");
    editor.setOptions({
        enableBasicAutocompletion: true,
        enableSnippets: true,
        enableLiveAutocompletion: true
    });
    editor.setTheme("ace/theme/twilight");
    editor.session.setMode("ace/mode/java");
    editor.resize();
    document.getElementById('editor').style.fontSize = '20px';
 
    return editor;
}
 
//获取刚刚初始化好的编译器
let editor = initAce();
 
// 由于ace.js会重新绘制页面，导致之前弄得textarea没了。因此需要换种方式
// 将代码设置到编译器中
editor.setValue(question.templateCode);
 
// 获取编译器中得代码
editor.getValue()

四、总结

本项目基于SpringMVC和MyBatis框架，实现了一个在线学习平台。该平台由博客模块和在线OJ模块组成。其中，在线OJ模块：

编译运行子模块：创建了CommandUtil类、FileUtil类和Task类。在CommandUtil类中实现了创建进程并将进程的标准输出和标准错误写入到文件中的方法。在FileUtil类中封装了读写文件的操作。在Task类，基于多进程编程，实现编译运行的全过程。

题目管理子模块：基于MyBatis，创建了QuestionMapper接口，在该接口中实现了增删查操作。

API子模块：首先设计了前后端交互的接口，创建QuestionController类，实现了获取题目列表、获取题目详情、编译运行、增加题目信息、删除题目这5个api接口。

前端子模块：创建了题目列表页、题目详情页、题目信息在线录入页面。引入代码编辑器组件ace.js使得编辑框变得更加好用。通过js代码，实现了调用后端HTTP API的过程。

相关阅读:
〔020〕Stable Diffusion 之骨骼姿势篇
 Android Studio Giraffe | 2022.3.1
spring接口多实现类，该依赖注入哪一个？
CDMP考试难度怎么样？
大数据可视化模块竞赛Vue项目文件结构与注意事项
 医学主题词表(Medical Subject Headings, MeSH)
Android遗漏的动画-矢量动画AnimatedVectorDrawable(上)
c语言进阶部分详解（详细解析字符串常用函数，并进行模拟实现）
spug-机器管理平台
 “errcode“:40164,“errmsg“:“invalid ip ...微信公众号开发调用失败的解决办法
原文地址：https://blog.csdn.net/weixin_44258092/article/details/126657491