基于JSP+MyBatis+SpringMVC+Docker的作业管理系统

一、概念介绍

1.什么是JSP？

• JSP全称Java Server Pages，是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。标签通常以<%开头以%>结束。
• JSP是一种Java servlet，主要用于实现Java web应用程序的用户界面部分。网页开发者们通过结合HTML代码、XHTML代码、XML元素以及嵌入JSP操作和命令来编写JSP。
• JSP通过网页表单获取用户输入数据、访问数据库及其他数据源，然后动态地创建网页。
• JSP标签有多种功能，比如访问数据库、记录用户选择信息、访问JavaBeans组件等，还可以在不同的网页中传递控制信息和共享信息。

JSP具有以下优点：

• 性能更加优越，因为JSP可以直接在HTML网页中动态嵌入元素而不需要单独引用CGI文件。
• 服务器调用的是已经编译好的JSP文件，而不像CGI/Perl那样必须先载入解释器和目标脚本。
• JSP 基于Java Servlet API，因此，JSP拥有各种强大的企业级Java API，包括JDBC，JNDI，EJB，JAXP等等。
• JSP页面可以与处理业务逻辑的 Servlet 一起使用，这种模式被Java servlet 模板引擎所支持。

2.什么是MyBatis？

MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以对配置和原生Map使用简单的 XML 或注解，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。

Mybatis功能架构分为三层：
1.API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。
2.数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。
3.基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

Mybatis具有以下优点：

• 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
• 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql基本上可以实现我们不使用数据访问框架可以实现的所有功能，或许更多。
• 解除sql与程序代码的耦合：通过提供DAL层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
• 提供映射标签，支持对象与数据库的orm字段关系映射
• 提供对象关系映射标签，支持对象关系组建维护
• 提供xml标签，支持编写动态sql。

3.什么是SpringMVC？

Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常Web开发的。

SpringMVC具有以下优点：

• 清晰的角色划分：前端控制器（DispatcherServlet）、请求到处理器映射（HandlerMapping）、处理器适配器（HandlerAdapter）、视图解析器（ViewResolver）、处理器或页面控制器（Controller）、验证器（ Validator）、命令对象（Command 请求参数绑定到的对象就叫命令对象）、表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）。
• 分工明确，而且扩展点相当灵活，可以很容易扩展。
• 和Spring 其他框架无缝集成，是其它Web框架所不具备的。
• 可适配，通过HandlerAdapter可以支持任意的类作为处理器；
• 强大的JSP标签库，使JSP编写更容易。

SpringMVC架构图：

4.什么是Docker？

• Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从 Apache2.0 协议开源。
• Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。
• 容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。

Docker的优点：
Docker 是一个用于开发，交付和运行应用程序的开放平台。Docker 使您能够将应用程序与基础架构分开，从而可以快速交付软件。借助 Docker，您可以与管理应用程序相同的方式来管理基础架构。通过利用 Docker 的方法来快速交付，测试和部署代码，您可以大大减少编写代码和在生产环境中运行代码之间的延迟。

• 快速，一致地交付您的应用程序
  Docker 允许开发人员使用您提供的应用程序或服务的本地容器在标准化环境中工作，从而简化了开发的生命周期。

• 响应式部署和扩展
  Docker 是基于容器的平台，允许高度可移植的工作负载。Docker 容器可以在开发人员的本机上，数据中心的物理或虚拟机上，云服务上或混合环境中运行。
  Docker 的可移植性和轻量级的特性，还可以使您轻松地完成动态管理的工作负担，并根据业务需求指示，实时扩展或拆除应用程序和服务。

• 在同一硬件上运行更多工作负载
  Docker 轻巧快速。它为基于虚拟机管理程序的虚拟机提供了可行、经济、高效的替代方案，因此您可以利用更多的计算能力来实现业务目标。Docker 非常适合于高密度环境以及中小型部署，而您可以用更少的资源做更多的事情。

二、作业管理系统的功能介绍

下图为作业管理系统的功能图：

首先，进入系统后需要先注册，注册时选择自己的身份（老师/学生），注册成功后按照自己的身份登录。教师登录成功后进入教师界面，具有发布作业、已发布作业的功能；学生登录成功后进入学生界面，具有提交作业、重新提交作业的功能。

三、数据库设计

数据库中一共创建四张表，具体如下：
1.Teacher表：用于存放教师注册登录相关信息。

2.Student表：用于存放学生登录注册相关信息。

3.Homework表：用于存放教师发布作业的相关信息。

4.Stu_homework表：用于存放学生提交作业的相关信息。

四、项目开展

1.首先使用IDEA创建项目，选择webapp框架。

然后在main文件夹中创建java文件夹用于存放java代码，在main文件夹中创建resources文件并且将其设置成resource源文件。
project structure->modules->web resource director中添加webapp文件路径，使其上面具有蓝色圆点。
2.相关配置
首先，下图为项目目录结构：

接下来是相关配置：
首先添加pom依赖，其中包括myBatis，springMVC，mysql等相关依赖。

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>finalproject</groupId>
  <artifactId>finalproject</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>fianlproject Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.15</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!--servlet/jsp api start-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>3.0-alpha-1</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2.1-b03</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.3.8.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.3.8.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>4.3.8.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.3.8.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.8.RELEASE</version>
    </dependency>
    <!--aspectj start-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.10</version>
    </dependency>
     <dependency>
      <groupId>com.zaxxer</groupId>
      <artifactId>HikariCP</artifactId>
      <version>3.4.2</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.6</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-simple</artifactId>
      <version>1.7.25</version>
      <scope>compile</scope>
    </dependency>

  </dependencies>

  <build>
    <finalName>JavaEE-MyBatis</finalName>
    <resources>
      <!--表示把java目录下的有关xml文件,properties文件编译/打包的时候放在resource目录下-->
      <resource>
        <directory>${basedir}/src/main/java</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
      </resource>
      <resource>
        <directory>${basedir}/src/main/resources</directory>
      </resource>
    </resources>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

然后在resources文件夹中创建config包，用于存放配置文件，mapper包用于存放myBatis映射。在config包中创建mybatis-config.xml，用于mybatis相关配置，代码如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <!-- Continue editing here -->
  <typeAliases>
    <package name="com.entity"></package>
  </typeAliases>

  <environments default="mybatis">
    <environment id="mybatis">
      <transactionManager type="JDBC"></transactionManager>
      <!-- mybatis提供了3种数据源类型，分别是：POOLED,UNPOOLED,JNDI -->
      <!-- POOLED 表示支持JDBC数据源连接池 -->
      <!-- UNPOOLED 表示不支持数据源连接池 -->
      <!-- JNDI 表示支持外部数据源连接池 -->
      <dataSource type="POOLED">
        <property name="driver" value="com.mysql.cj.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/finalproject?serverTimezone=GMT%2B8" />
        <property name="username" value="root" />
        <property name="password" value="123456" />
      </dataSource>
    </environment>
  </environments>

  <mappers>
    <mapper resource="mapper/TeacherMapper.xml"></mapper>
    <mapper resource="mapper/StudentMapper.xml"></mapper>
    <mapper resource="mapper/HomeworkMapper.xml"></mapper>
    <mapper resource="mapper/Stu_homeworkMapper.xml"></mapper>
  </mappers>


</configuration>

继续在config包中创建mysql.properties用于数据库相关配置。代码如下：

#JDBC Global Setting
#jdbc.driver=com.mysql.jdbc.Driver
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/finalproject?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=GMT%2B8
jdbc.username=root
jdbc.password=123456

##DataSource Global Setting
#配置初始化大小、最小、最大
ds.initialSize=1
ds.minIdle=1
ds.maxActive=20

#配置获取连接等待超时的时间
ds.maxWait=60000

#配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
ds.timeBetweenEvictionRunsMillis=60000

#配置一个连接在池中最小生存的时间，单位是毫秒
ds.minEvictableIdleTimeMillis=300000

在Resources文件夹中创建spring-mvc.xml，用于springMVC相关配置，代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
                         http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-4.3.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
  <!--启用spring的一些annotation -->
  <context:annotation-config/>

  <!-- 自动扫描该包，使SpringMVC认为包下用了@controller注解的类是控制器 -->
  <context:component-scan base-package="com">
    <!--<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>-->
  </context:component-scan>


  <!-- 配置注解驱动 可以将request参数与绑定到controller参数上 -->
  <mvc:annotation-driven/>


</beans>

在WEB-INF文件中创建applicationContext.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd">

  <!-- 自动扫描SpringMVC包 ,将带有注解的类 纳入spring容器管理 -->
  <context:component-scan base-package="com"/>

  <!-- 引入jdbc配置文件 -->
  <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
      <list>
        <value>classpath*:config/mysql.properties</value>
      </list>
    </property>
  </bean>

  <!-- dataSource 配置 -->
  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
    <!-- 基本属性 url、user、password -->
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="123456"/>

    <!-- 配置初始化大小、最小、最大 -->
    <property name="initialSize" value="${ds.initialSize}"/>
    <property name="minIdle" value="${ds.minIdle}"/>
    <property name="maxActive" value="${ds.maxActive}"/>

    <!-- 配置获取连接等待超时的时间 -->
    <property name="maxWait" value="${ds.maxWait}"/>

    <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
    <property name="timeBetweenEvictionRunsMillis" value="${ds.timeBetweenEvictionRunsMillis}"/>

    <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
    <property name="minEvictableIdleTimeMillis" value="${ds.minEvictableIdleTimeMillis}"/>

    <property name="validationQuery" value="SELECT 'x'"/>
    <property name="testWhileIdle" value="true"/>
    <property name="testOnBorrow" value="false"/>
    <property name="testOnReturn" value="false"/>

    <!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
    <property name="poolPreparedStatements" value="false"/>
    <property name="maxPoolPreparedStatementPerConnectionSize" value="20"/>

    <!-- 配置监控统计拦截的filters -->
    <property name="filters" value="stat"/>
  </bean>
  
  <!-- 事务管理 通知 -->
  <tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
      <!-- 对insert,update,delete 开头的方法进行事务管理,只要有异常就回滚 -->
      <tx:method name="insert*" propagation="REQUIRED" rollback-for="java.lang.Throwable"/>
      <tx:method name="update*" propagation="REQUIRED" rollback-for="java.lang.Throwable"/>
      <tx:method name="delete*" propagation="REQUIRED" rollback-for="java.lang.Throwable"/>
      <!-- select,count开头的方法,开启只读,提高数据库访问性能 -->
      <tx:method name="select*" read-only="true"/>
      <tx:method name="count*" read-only="true"/>
      <!-- 对其他方法 使用默认的事务管理 -->
      <tx:method name="*"/>
    </tx:attributes>
  </tx:advice>

  <aop:config>
    <aop:pointcut id="serviceMethods" expression="execution(* com.service..*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethods"/>
  </aop:config>

  <!-- 配置使Spring采用CGLIB代理 -->
  <aop:aspectj-autoproxy proxy-target-class="true"/>

  <!-- 对dataSource 数据源进行事务管理 -->
  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
        p:dataSource-ref="dataSource"/>

  <!-- 使用annotation注解方式配置事务,启用对事务注解的支持 -->
  <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

综上所述，项目环境配置完成，接下来进行功能实现。

3.功能实现：以注册功能为例
首先编写jsp界面：代码中使用form表单将前端数据提交给后端，action设置为register（与后端requestMapping的value相匹配才可传值）。register.jsp

<%--
  Created by IntelliJ IDEA.
  User: 11795
  Date: 2020/6/17
  Time: 8:31
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>注册</title>
</head>
<body>
<div style="text-align: center;">
  <form action="register" method="post">
    请输入您的工号/学号：
    <input type="text" name="id" width="600px">
    <br>
    <br>
    请设置密码：
    <input type="password" name="password" width="600px">
    <br>
    <br>
    请输入您的电话：
    <input type="text" name="phone" width="600px">
    <br>
    <br>
    请输入您的邮箱：
    <input type="text" name="email" width="600px">
    <br>
    <br>
    请选择您的身份：
    <label><input name="identity" type="radio" value="1" />老师 </label>
    <label><input name="identity" type="radio" value="2" />学生 </label>
    <br><br>
    <a href="index.jsp">返回</a>
    <%--<button onclick="window.location.href('index.jsp')">返回</button>--%>
    <input type="submit" value="确定">
  </form>
</div>
</body>
</html>

然后创建学生实体，在java文件夹中创建entity包。Student.java

package com.entity;

public class Student {

  private int studentID;

  private String password;

  private String phone;

  private String email;

  public int getStudentID() {
    return studentID;
  }

  public void setStudentID(int studentID) {
    this.studentID = studentID;
  }

  public String getPassword() {
    return password;
  }

  public void setPassword(String password) {
    this.password = password;
  }

  public String getPhone() {
    return phone;
  }

  public void setPhone(String phone) {
    this.phone = phone;
  }

  public String getEmail() {
    return email;
  }

  public void setEmail(String email) {
    this.email = email;
  }

}

然后创建Controller，在java文件夹中创建controller包，其中，使用HttpServlet进行前后端传值操作，使用getParameter函数获取前端数据，其中的参数名要与jsp文件中的文本框id一致。RegisterController.java

package com.controller;

import com.entity.Student;
import com.entity.Teacher;
import com.jdbc.StudentHomeworkJdbc;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Controller
public class RegisterController {
  @RequestMapping("/register")
  public void register(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    if(req.getParameter("identity").equals("1")){
      Teacher teacher = new Teacher();
      teacher.setTeacherID(Integer.parseInt(req.getParameter("id")));
      teacher.setPassword(req.getParameter("password"));
      teacher.setPhone(req.getParameter("phone"));
      teacher.setEmail(req.getParameter("email"));
      StudentHomeworkJdbc.addTeacher(teacher);
      resp.sendRedirect("/index.jsp");
    }else if(req.getParameter("identity").equals("2")){
      Student student = new Student();
      student.setStudentID(Integer.parseInt(req.getParameter("id")));
      student.setPassword(req.getParameter("password"));
      student.setPhone(req.getParameter("phone"));
      student.setEmail(req.getParameter("email"));
      StudentHomeworkJdbc.addStudent(student);
      resp.sendRedirect("/index.jsp");
    }
  }

}

接着编写myBatis映射：
在java文件夹中创建dao包，用于存放映射接口。例：StudentMapper.java

package com.dao;

import com.entity.Student;

import java.util.List;

public interface StudentMapper {
  void addStudent(Student student);
  List<Student> selectStudent();
}

在resource文件夹中的mapper包创建StudentMapper.xml用于对数据库进行增删改查：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.dao.StudentMapper">
  <resultMap id="student" type="Student">
    <id property="studentID" column="studentID"></id>
    <result property="password" column="password"></result>
    <result property="phone" column="phone"></result>
    <result property="email" column="email"></result>
  </resultMap>
  <insert id="addStudent"  parameterType="Student">
        insert into student(studentID,password,phone,email)values(#{studentID},#{password},#{phone},#{email})
  </insert>

  <select id="selectStudent" resultType="Student">
        SELECT * FROM student
  </select>

</mapper>

在myBatis-config.xml文件中添加映射。

<mappers>
  <mapper resource="mapper/StudentMapper.xml"></mapper>
 </mappers>

接下来是数据库的增删改查：创建DBTools.java文件调用mybatis配置文件，创建工厂。

package com.jdbc;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.Reader;

public class DBTools {

  private static SqlSessionFactory sqlSessionFactory;
  static {
    try {
      Reader reader = Resources.getResourceAsReader("config/mybatis-conf.xml");
      sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
  public static SqlSessionFactory getSqlSessionFactory(){
    return sqlSessionFactory;
  }
}

接着编写调用添加学生信息的函数：

public static void addStudent(Student student){
  SqlSessionFactory sqlSessionFactory = DBTools.getSqlSessionFactory();
  //2.创建SqlSession
  SqlSession session = sqlSessionFactory.openSession();

  StudentMapper studentMapper = session.getMapper(StudentMapper.class);

  studentMapper.addStudent(student);

  session.commit();
}

综上所述，可以实现学生注册功能，其他功能与该功能类似，不再赘述。

五、Docker部署

上传成功截图：

六、部分界面展示

登录界面：

注册界面：

教师端主界面：

发布作业：

查看已发布的作业：

学生提交作业：