作业管理系统终版（Mybatis,Springboot,maven,Mysql)

• 本系统进行过多次改进，每次整合不同的内容，之前的几次整合博文如下，可以点击进行查看

1. 开发基于Mysql、Servlet、JSP的作业管理系统
   https://blog.csdn.net/weixin_43751194/article/details/104737644
2. 作业管理系统改造成maven工程，使用project/module模式，添加数据库连接池
   https://blog.csdn.net/weixin_43751194/article/details/104991773
3. spring webmvc重构项目：serlvet注册、IoC容器创建、bean初始化、MVC的流程
   https://blog.csdn.net/weixin_43751194/article/details/105523596
4. 整合SpringCloud等内容
   https://blog.csdn.net/weixin_44051217/article/details/106390179
5. 作业管理系统终版：Mybatis
   本文

基于Mysql、Servlet、JSP的作业管理系统

• 要实现的功能有：
• 老师：登录、添加学生、删除学生、查看作业表、学生名单、批改作业（查看学生提交的作业并评分）,添加作业
• 学生：登录、根据老师添加的作业进行提交、查看老师给的评分

本项目数据库设计

• 包含四个表

• s_teacher
  

• s_student_homework
  

• s_homework
  

• s_student

界面展示

• 老师登录界面

• 老师注册界面
  键入教师id及密码，可以进行注册
  

• 学生登陆界面
  学生键入学生id后，进行登录
  老师添加学生后，自动为学生进行注册，没有被老师添加到学生名单的人，无法用其学生账号进行登录
  

• 学生登陆后主页界面

  • 未提交的作业排在前排
  • 已提交的作业排在最下面，可以查看分数（null表示还没有批阅），学生也可以更新作业
  • 未提交的作业：“作业内容”就是老师布置的作业要求
  • 已提交的作业：“作业内容”是上一次调教的作业内容

• 老师选择功能界面
  

• 老师添加学生（键入学生id、name）
  

• 老师删除学生（会一并删除学生提交过的作业
  

• 老师查询学生名单、布置的作业
  

• 老师查阅批改作业

• 点击“check”按钮，进入查看提交此作业的学生作业
  
• 点击“check”可批改学生作业
  
• 添加新作业
  

（一）创建项目

1. File —> New —> Project
   (我这里是在之前的新项目中建了一个新的module，步骤一样）
   
2. 一直next即可完成
3. 添加pom依赖

• 整合MyBatis的核心依赖MyBatis-Spring-Boot-Starter提供：

  • 自动检测现有的DataSource
  • 将创建并注册SqlSessionFactory的实例，该实例使用SqlSessionFactoryBean将该DataSource作为输入进行传递
  • 将创建并注册从SqlSessionFactory中获取的SqlSessionTemplate的实例。
  • 自动扫描您的mappers，将它们链接到SqlSessionTemplate并将其注册到Spring上下文，以便将它们注入到您的bean中。

• 因此，引入该Starter之后，只需要定义一个DataSource即可（application.properties中可配置），它会自动创建使用该DataSource的SqlSessionFactoryBean以及SqlSessionTemplate。会自动扫描你的Mappers，连接到SqlSessionTemplate，并注册到Spring上下文中。

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <docker.image.prefix>registry.cn-beijing.aliyuncs.com/springwinter/17301111-JavaeeFinalProject</docker.image.prefix>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--用于编译jsp-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <version>8.5.56</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>

        <!-- servlet依赖 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <scope>compile</scope>
        </dependency>

        <!--token-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.4.0</version>
        </dependency>
        <!--aop-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.5.4</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>1.7.30</version>
        </dependency>

    </dependencies>

    <build>

        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <!-- spring-boot:run 中文乱码解决 -->
                <configuration>
                    <fork>true</fork>
                    <!--增加jvm参数-->
                    <jvmArguments>-Dfile.encoding=UTF-8</jvmArguments>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>springloaded</artifactId>
                        <version>1.2.5.RELEASE</version>
                    </dependency>
                </dependencies>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <testFailureIgnore>true</testFailureIgnore>
                </configuration>
            </plugin>


            <plugin>

                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.2.0</version>
                <configuration>
                    <imageName>${docker.image.prefix}/${project.artifactId}</imageName>
                    <dockerDirectory>src/main/docker</dockerDirectory>
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <directory>${project.build.directory}</directory>
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

（二）Controller包

（2.1）ApiController.java

• 系统主流程为，ApiController调用后台系统，后台系统通过约定获取MyBatis的Mapper配置，生成动态SQL，实现数据操作接口
• @RestController是ResponseBody和Controller的集合，意思是return的数据都变成json的格式，返回到前端，不会跳转界面
• 如果想带着数据返回到重新定义的页面去，建议使用“视图解释器解析”——ModelAndVIew
• @RequestMapping则是表明请求的路径，根据路径执行对应的方法。
• 通常情况下，controller处理完业务后会返回结果数据给view层。为此，SpringMVC提供了Model类来封装结果数据，封装的过程是自动的，我们只需要在方法中加入Model参数即可。
• @Autowired注解调用mybatis的接口

package com.example.mybatis.controller;

import com.example.mybatis.model.Homework;
import com.example.mybatis.model.Student;
import com.example.mybatis.model.StudentHomework;
import com.example.mybatis.service.AllSServiceImpl;
import com.example.mybatis.service.AllTServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@Controller
public class ApiController {
    private final AllSServiceImpl allSService;
    private final AllTServiceImpl allTService;

    @Autowired
    public ApiController(AllSServiceImpl allSService,AllTServiceImpl allTService) {

        this.allSService = allSService;
        this.allTService = allTService;
    }
///学生更新页面
    public void update1(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String s=req.getParameter("sId");
        long l = Long.parseLong(s);
        List<Homework> list2 = allSService.selectAll3();
        if(null == list2 || list2.size() <= 0){
            req.setAttribute("flag",false);
        }else{
            req.setAttribute("flag",true);
            List<StudentHomework> list3=new ArrayList<StudentHomework>();
            List<Homework> list4=new ArrayList<Homework>();
            for (Homework h : list2){
                StudentHomework sh=allSService.find1(l,h.getId());
                if(sh==null){
                    //w未提交的作业
                    list4.add(h);
                }else{
                    list3.add(sh);
                }
            }
                req.setAttribute("list3",list3);
                req.setAttribute("list4",list4);
            }
        req.getRequestDispatcher("/SSubmit.jsp").forward(req,resp);
    }


    @RequestMapping("/login")

    public void login (HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        System.out.println("11");
        List<Student> list= allSService.login(req);
        if(null == list || list.size() <= 0){
            req.getRequestDispatcher("/Login.jsp").forward(req,resp);
           // return "login";
        }else{
            update1(req,resp);
            req.getRequestDispatcher("/SSubmit.jsp").forward(req,resp);
          //  return "login";
        }

    }
    @RequestMapping("/Tlogin")
    public void Tlogin (HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        System.out.println("22");
       // List<Student> list= allSService.login(req);
        boolean b=allTService.login(req);
        if(b==true){
            req.getRequestDispatcher("/TChoose.jsp").forward(req,resp);
           // return "TChoose";

        }else{
            req.getRequestDispatcher("/TLogin.jsp").forward(req,resp);
         //   return "TLogin";
        }

    }

    @RequestMapping("/TRegister")
    public void TRegister (HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        System.out.println("33");
        // List<Student> list= allSService.login(req);
        boolean b=allTService.addTeacher(req);
        if(b==true){
            req.getRequestDispatcher("/TChoose.jsp").forward(req,resp);
            //return "TRegister";
        }else{
            //update1(req,resp);
            req.getRequestDispatcher("/TRegister.jsp").forward(req,resp);
           // return "TRegister";
        }

    }

    //学生选择功能界面跳转到作业列表
    @RequestMapping("/submit1")
    public void submit1 (HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        update1(req,resp);
    //    return "submit";
        //req.getRequestDispatcher("/SSubmit.jsp").forward(req,resp);
    }

    //学生查看的作业列表跳转到提交界面
    @RequestMapping("/submit2")
    public void submit2 (HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        req.getRequestDispatcher("/SSubmit2.jsp").forward(req,resp);
       // return "submit2";
    }

    //作业提交执行
    @RequestMapping("/SubmitHomeworkServlet")
    public void submitHomework(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        req.setCharacterEncoding("utf-8");
        boolean j= allSService.deleteStudentHomework(req);
        boolean i = allSService.addHomework(req);

        if(i==true && j==true){
            //完成数据库操作，返回响应给jsp
            System.out.println("true");

        }else{
            System.out.println("false");
        }
        update1(req,resp);
     //   return "SubmitHomeworkServlet";
    }

    //老师

    public void update2(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        List<Homework> list3 = allSService.selectAll3();
        List<Student> list2=allTService.selectAll2();
        for (Student s:list2){
            System.out.println(s.getName());
            System.out.println(s.getCreateTime());
        }
        List<StudentHomework> list1=allTService.selectAll1();

        req.setAttribute("list3",list3);
        req.setAttribute("list2",list2);
        req.setAttribute("list1",list1);

    }

    @RequestMapping("/Search")
    public void search(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        update2(req,resp);
        req.getRequestDispatcher("/TSearch.jsp").forward(req,resp);
    }
    @RequestMapping("/Check")
    public void Check(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        String s=req.getParameter("hwId");
        List<Homework>list3 = allSService.selectAll3();
        for (Homework h:list3){
            long l =h.getId();
            List<StudentHomework> list1 = allTService.find12(l);
            Long n=(long)list1.size();
            boolean b=allSService.editHW(l,n);
            System.out.println(b);
        }

        update2(req,resp);
        req.getRequestDispatcher("/TCheck.jsp").forward(req,resp);
    }

    public void Check2(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        String s=req.getParameter("hwId");
        long l = Long.parseLong(s);
        List<StudentHomework> list1 = allTService.find12(l);
        if(null == list1 || list1.size() <= 0){
            req.setAttribute("flag",false);
        }else{
            req.setAttribute("flag",true);
            req.setAttribute("list1",list1);
        }

        req.getRequestDispatcher("/TCheck2.jsp").forward(req,resp);
    }


    @RequestMapping("/CheckHomework")
    public void checkHW (HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        String s=req.getParameter("hwId");
        long l = Long.parseLong(s);
        List<StudentHomework> list1 = allTService.find12(l);

        if(null == list1 || list1.size() <= 0){
            req.setAttribute("flag",false);
        }else{
            req.setAttribute("flag",true);
            req.setAttribute("list1",list1);
        }

        req.getRequestDispatcher("/TCheck2.jsp").forward(req,resp);
    }

    @RequestMapping("/CheckHomework2")
    public void checkHW2 (HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        req.getRequestDispatcher("/TCheck3.jsp").forward(req,resp);
    }

    //作业提交执行
    @RequestMapping("/CheckHomework3")
    public void checkHW3(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        req.setCharacterEncoding("utf-8");
        boolean i=allTService.editHomework(req);

        if(i=true){
            //完成数据库操作，返回响应给jsp
            System.out.println("true");

        }else{
            System.out.println("false");
        }
        Check2(req,resp);
        //req.setAttribute("hwId",hwId);
        //req.getRequestDispatcher("/TCheck2.jsp").forward(req,resp);
    }

    @RequestMapping("/DeleteStudentServlet")
    public void deleteStudent(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        req.setCharacterEncoding("utf-8");
        boolean j=allTService.deleteStudent(req);
        update2(req,resp);
        if(j=true){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        req.getRequestDispatcher("/TDeleteStudent.jsp").forward(req,resp);

    }

    @RequestMapping("/TDelete")
    public void TDelete (HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        update2(req,resp);
        req.getRequestDispatcher("/TDeleteStudent.jsp").forward(req,resp);
    }

    @RequestMapping("/TAdd")
    public void TAdd(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        update2(req,resp);
        req.getRequestDispatcher("/TAddStudent.jsp").forward(req,resp);
    }

    @RequestMapping("/TADDHomework")
    public void TADDHomework (HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        update2(req,resp);
        req.getRequestDispatcher("/TAddHomework.jsp").forward(req,resp);
    }

    @RequestMapping("/addStudent")
    public void addStudent(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        req.setCharacterEncoding("utf-8");

        boolean i= allTService.addStudent(req);
        update2(req,resp);
        if(i=true){
            System.out.println("true");
            //   out.print("<script>alert('Add Successfully')");
        }else{
            System.out.println("false");
            //   out.print("<script>alert('Failed')");
        }
        req.getRequestDispatcher("/TAddStudent.jsp").forward(req,resp);
    }

    @RequestMapping("/check")
    public void check (HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        System.out.println(req.getParameter("hwId"));
        req.getRequestDispatcher("/TCheckHomework2.jsp").forward(req,resp);
    }

    @RequestMapping("/HomeworkServlet")
    public void addHomework(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        req.setCharacterEncoding("utf-8");

        boolean i=allTService.addHomework(req);
        update2(req,resp);
        if(i=true){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        req.getRequestDispatcher("/TAddHomework.jsp").forward(req,resp);
    }

}

（三）Dao包

• 数据库操作mapper接口（mapper）
• @Repository表明此类为实体Bean类
• 接口只需要定义对应的方法即可。

（3.1）HomeworkDao.java

• Homework相关方法

package com.example.mybatis.dao;
import com.example.mybatis.model.Homework;
import org.springframework.stereotype.Repository;
import java.util.List;

@Repository
public interface HomeworkDao {
    boolean addHomework(Homework h);
    Homework find3(Long homeworkId);
    boolean editHW(Long homeworkId, Long num);
    List<Homework> selectAll3();
}

（3.2）StudentDao.java

• student相关方法

package com.example.mybatis.dao;
import com.example.mybatis.model.Student;
import org.springframework.stereotype.Repository;
import java.util.List;

@Repository
public interface StudentDao {
    boolean addStudent(Student s);
    boolean deleteStudent(Student s);
    List<Student> find2(Long studentId);
    List<Student> selectAll2();

}

（3.3）StudentHomeworkDao.java

• StudentHomework相关方法

package com.example.mybatis.dao;
import com.example.mybatis.model.StudentHomework;
import org.springframework.stereotype.Repository;
import java.util.List;

@Repository
public interface StudentHomeworkDao {

    boolean addHomework(StudentHomework sh);
    boolean editHomework(Long studentId,Long homeworkId,Long score);
    boolean deleteHomework(Long studentId);
    boolean deleteHomework2(Long studentId,Long homeworkId);
    StudentHomework find1(Long studentId, Long homeworkId);
    List<StudentHomework> find12(Long homeworkId);
    List<StudentHomework> selectAll1();
}

（3.4）TeacherDao.java

package com.example.mybatis.dao;


import com.example.mybatis.model.Teacher;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface TeacherDao {
    List<Teacher> find4(Long id, String pw);
    boolean addTeacher(Teacher t);
}

（四）Model包

本包内的类用于映射数据库中的数据，包括

（1）Homework.java

（2）Student.java

（3）StudentHomework.java

（4）Teacher.java

（4.1）Homework.java

package com.example.mybatis.model;
import lombok.Getter;
import lombok.Setter;

import java.util.Date;

/**

 * StudentHomework 数据层，与数据的映射关系
 * 老师布置添加的作业

 */
@Getter
@Setter
public class Homework {
    private Long id;
    private Long num;
    private String title;
    private String content;
    private Date createTime;
    private Date updateTime;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Long getNum() {
        return num;
    }

    public void setNum(Long num) {
        this.num = num;
    }

    public String getHomeworkTitle() {
        return title;
    }

    public void setHomeworkTitle(String title) { this.title = title; }

    public String getHomeworkContent() {
        return content;
    }

    public void setHomeworkContent(String content) {
        this.content = content;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }
}

（4.2）Student.java

package com.example.mybatis.model;

import java.util.Date;

public class Student {
    private Long id;
    private String name;
    private Date createTime;
    private Date updateTime;

    public Long getStudentId() { return id; }

    public void setStudentId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }
}

（4.3）StudentHomework.java

package com.example.mybatis.model;

import lombok.Getter;
import lombok.Setter;

import java.util.Date;

/**

 * StudentHomework 数据层，与数据的映射关系
 * 学生提交的作业

 */
@Getter
@Setter
public class StudentHomework {
    private Long id;
    private Long studentId;
    private Long homeworkId;
    private Long score;
    private String homeworkTitle;
    private String homeworkContent;
    private Date createTime;
    private Date updateTime;

    public Long getId() { return id; }

    public void setId(Long id) { this.id = id; }

    public Long getStudentId() { return studentId; }

    public void setStudentId(Long studentId) {
        this.studentId = studentId;
    }

    public Long getHomeworkId() {
        return homeworkId;
    }

    public void setHomeworkId(Long homeworkId) {
        this.homeworkId = homeworkId;
    }

    public String getHomeworkTitle() {
        return homeworkTitle;
    }

    public void setHomeworkTitle(String homeworkTitle) {
        this.homeworkTitle = homeworkTitle;
    }

    public String getHomeworkContent() {
        return homeworkContent;
    }

    public void setHomeworkContent(String homeworkContent) {
        this.homeworkContent = homeworkContent;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Long getScore() {
        return score;
    }

    public void setScore(Long score) {
        this.score = score;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

}

（4.4）Teacher.java

package com.example.mybatis.model;

public class Teacher {

    private Long id;
    private String pw;

    public Long getId() { return id; }

    public void setId(Long id) {
        this.id = id;
    }

    public String getPW() {
        return pw;
    }

    public void setPW(String pw) {
        this.pw = pw;
    }

}

（五）Service包

• 具体service接口（继承基础service）及实现service（继承抽象service以及实现具体service接口）
• 使用@Resource表明通过注入取得BookServices的对象。
• @Service表明此类为SpringMVC的服务层，并且通过注解注入了Dao包中的的对象。

（5.1）AllSService.java

• 包含学生界面所需方法的接口

package com.example.mybatis.service;

import com.example.mybatis.model.Homework;
import com.example.mybatis.model.Student;
import com.example.mybatis.model.StudentHomework;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.List;

public interface AllSService {

    List<Student> login (HttpServletRequest req);
    void submit1 (HttpServletRequest req, HttpServletResponse resp);
    void submit2 (HttpServletRequest req, HttpServletResponse resp);
    boolean addHomework(HttpServletRequest req);
    List<Homework> selectAll3();
    StudentHomework find1(Long studentId, Long homeworkId);
    boolean editHW(Long homeworkId, Long num);
    boolean deleteStudentHomework(HttpServletRequest req);

}

（5.2）AllSServiceImpl.java

• 包含学生界面所需方法的接口实现

package com.example.mybatis.service;


import com.example.mybatis.dao.HomeworkDao;
import com.example.mybatis.dao.StudentDao;
import com.example.mybatis.dao.StudentHomeworkDao;
import com.example.mybatis.model.Homework;
import com.example.mybatis.model.Student;
import com.example.mybatis.model.StudentHomework;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

@Service
public class AllSServiceImpl implements AllSService {

    @Resource
    private final HomeworkDao homeworkDao;
    private final StudentDao studentDao;
    private final StudentHomeworkDao studentHomeworkDao;

    @Autowired
    public AllSServiceImpl(HomeworkDao homeworkDao,StudentDao studentDao, StudentHomeworkDao studentHomeworkDao) {
        this.homeworkDao=homeworkDao;
        this.studentDao = studentDao;
        this.studentHomeworkDao = studentHomeworkDao;
    }
    

    public List<Homework> selectAll3() {
        return homeworkDao.selectAll3();
    }

    @Override
    public List<Student> login(HttpServletRequest req) {
        Student sId = new Student();
        sId.setStudentId(Long.parseLong(req.getParameter("sId")));
        return studentDao.find2(sId.getStudentId());

    }

    @Override
    public void submit1(HttpServletRequest req, HttpServletResponse resp) {

    }

    @Override
    public void submit2(HttpServletRequest req, HttpServletResponse resp) {

    }

    @Override
    public boolean addHomework(HttpServletRequest req) {
        StudentHomework sh = new StudentHomework();

        System.out.println("SubmitHomeworkServlet"+Long.parseLong(req.getParameter("sId")));

        sh.setStudentId(Long.parseLong(req.getParameter("sId")));
        sh.setHomeworkId(Long.parseLong(req.getParameter("hwId")));
        sh.setHomeworkTitle(req.getParameter("hwTitle"));
        sh.setHomeworkContent(req.getParameter("finish"));
        Calendar c = Calendar.getInstance();
        Date date = c.getTime();
        sh.setCreateTime(date);

        return studentHomeworkDao.addHomework(sh);

    }


    @Override
    public StudentHomework find1(Long studentId, Long homeworkId) {
        return studentHomeworkDao.find1(studentId,homeworkId);
    }

    @Override
    public boolean editHW(Long homeworkId, Long num) {

        return homeworkDao.editHW(homeworkId,num);
    }
    @Override
	public boolean deleteStudentHomework(HttpServletRequest req) {
	    StudentHomework sh = new StudentHomework();
	    sh.setStudentId(Long.parseLong(req.getParameter("sId")));
	    sh.setHomeworkId(Long.parseLong(req.getParameter("hwId")));
	
	    return studentHomeworkDao.deleteHomework2(sh.getStudentId(),sh.getHomeworkId());
	}
	
	}

（5.3）AllTService.java

• 包含老师界面所需方法的接口实现

package com.example.mybatis.service;

import com.example.mybatis.model.Student;
import com.example.mybatis.model.StudentHomework;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.List;

public interface AllTService {
    boolean login (HttpServletRequest req);
    void checkHW (HttpServletRequest req, HttpServletResponse resp);
    void checkHW2 (HttpServletRequest req, HttpServletResponse resp);
    void checkHW3(HttpServletRequest req, HttpServletResponse resp);
    boolean deleteStudent(HttpServletRequest req);
    boolean editHomework(HttpServletRequest req);
    boolean addStudent(HttpServletRequest req);
    boolean addTeacher(HttpServletRequest req);
    void check (HttpServletRequest req, HttpServletResponse resp);
    boolean addHomework(HttpServletRequest req);
    List<Student> selectAll2();
    List<StudentHomework> selectAll1();
    List<StudentHomework> find12(Long homeworkId);


}

（5.4）AllSServiceImpl.java

• 包含老师界面所需方法的接口实现

package com.example.mybatis.service;


import com.example.mybatis.dao.HomeworkDao;
import com.example.mybatis.dao.StudentDao;
import com.example.mybatis.dao.StudentHomeworkDao;
import com.example.mybatis.model.Homework;
import com.example.mybatis.model.Student;
import com.example.mybatis.model.StudentHomework;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

@Service
public class AllTServiceImpl implements AllTService {
    @Resource
    private final HomeworkDao homeworkDao;
    private final StudentDao studentDao;
    private final StudentHomeworkDao studentHomeworkDao;

    @Autowired
    public AllTServiceImpl(HomeworkDao homeworkDao, StudentDao studentDao, StudentHomeworkDao studentHomeworkDao) {
        this.homeworkDao = homeworkDao;
        this.studentDao = studentDao;
        this.studentHomeworkDao = studentHomeworkDao;
    }
    @Override
public boolean login(HttpServletRequest req) {
    Teacher t=new Teacher();
    t.setId(Long.parseLong(req.getParameter("id")));
    t.setPW(req.getParameter("pw"));
    System.out.println(t.getId()+"     "+t.getPW());
    List<Teacher> list=teacherDao.find4(t.getId(),t.getPW());

    if(null == list || list.size() <= 0){
        return false;
    }else{
        return true;
    }
}

    @Override
    public void checkHW(HttpServletRequest req, HttpServletResponse resp) {

    }

    @Override
    public void checkHW2(HttpServletRequest req, HttpServletResponse resp) {

    }

    @Override
    public void checkHW3(HttpServletRequest req, HttpServletResponse resp) {

    }
    @Override
	public boolean addTeacher(HttpServletRequest req) {
	    Teacher t=new Teacher();
	    t.setId(Long.parseLong(req.getParameter("id")));
	    t.setPW(req.getParameter("pw"));
	    return teacherDao.addTeacher(t);
	
	}
	
	    @Override
    public boolean deleteStudent(HttpServletRequest req) {
        StudentHomework sh = new StudentHomework();
        Student s = new Student();
        s.setStudentId(Long.parseLong(req.getParameter("id")));
        sh.setStudentId(Long.parseLong(req.getParameter("id")));

        boolean i=studentHomeworkDao.deleteHomework(sh.getStudentId());
        boolean j=studentDao.deleteStudent(s);

        if(j=true){
            return true;
        }else{
            return false;
        }
    }

    @Override
    public boolean editHomework(HttpServletRequest req) {
        Long studentId=Long.parseLong(req.getParameter("sId"));
        Long homeworkId=Long.parseLong(req.getParameter("hwId"));
        Long score=Long.parseLong(req.getParameter("score"));

        return studentHomeworkDao.editHomework(studentId,homeworkId,score);
    }

    @Override
    public boolean addStudent(HttpServletRequest req) {
        Student s = new Student();
        s.setStudentId(Long.parseLong(req.getParameter("id")));
        s.setName(req.getParameter("name"));
        //获取当前系统时间，存入数据库创建时间
        Calendar c = Calendar.getInstance();
        Date date = c.getTime();
        s.setCreateTime(date);

        return studentDao.addStudent(s);

    }

    @Override
    public void check(HttpServletRequest req, HttpServletResponse resp) {

    }

    @Override
    public boolean addHomework(HttpServletRequest req) {
        Homework h = new Homework();
        h.setHomeworkTitle(req.getParameter("title"));
        h.setHomeworkContent(req.getParameter("content"));
        Calendar c = Calendar.getInstance();
        Date date = c.getTime();
        h.setCreateTime(date);

        return homeworkDao.addHomework(h);
    }

    @Override
    public List<Student> selectAll2() {
        return studentDao.selectAll2();
    }

    @Override
    public List<StudentHomework> selectAll1() {
        return studentHomeworkDao.selectAll1();
    }

    @Override
    public List<StudentHomework> find12(Long homeworkId) {
        return studentHomeworkDao.find12(homeworkId);
    }
}

（六）Resources

（6.1）Mapper包

• 在mybatis中，映射文件中的namespace是用于绑定Dao接口的，即面向接口编程。namespace绑定接口后，可以不用写接口实现类，mybatis会通过该绑定自动找到对应要执行的SQL语句
• 具体接口参考第二部分Dao包里的内容
• 注意接口中的方法与映射文件中的SQL语句的ID一一对应

（6.1.1）homeworkDao.xml

• 对应HomeworkDao接口

<?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.example.mybatis.dao.HomeworkDao">

    <insert id="addHomework" parameterType="Homework">
        INSERT INTO `s_homework`(title,content,create_time) VALUE(#{title},#{content},#{createTime})
    </insert>

    <select id="find3" resultType="com.example.mybatis.model.Homework" parameterType="Long">
        SELECT * FROM s_homework WHERE id=#{homeworkId}
    </select>

    <update id="editHW">
        UPDATE s_homework SET num=#{num} WHERE id=#{homeworkId}
    </update>

    <select id="selectAll3" resultType="com.example.mybatis.model.Homework">
        SELECT * FROM s_homework
    </select>



</mapper>

（6.1.2）studentDao.xml

• 对应StudentDao接口

<?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.example.mybatis.dao.StudentDao">

<resultMap id="hw" type="com.example.mybatis.model.Homework">
    <id column="id" property="id" />
    <result column="num" property="num"/>
    <result column="title" property="title"/>
    <result column="content" property="content"/>
    <result column="create_time" property="createTime"/>
</resultMap>

    <insert id="addStudent" parameterType="Student">
        INSERT INTO `s_student`(id,name,create_time) VALUE(#{id}, #{name}, #{createTime})
    </insert>

    <delete id="deleteStudent" parameterType="Student">
        DELETE FROM `s_student` WHERE id=#{id}
    </delete>

    <select id="find2" resultType="com.example.mybatis.model.Student" parameterType="Long">
        SELECT * FROM s_student WHERE id=#{id}
    </select>

    <select id="selectAll2" resultType="com.example.mybatis.model.Student" >
        SELECT * FROM s_student
    </select>

</mapper>

（6.1.3）studentHomeworkDao.xml

• 对应StudentHomeworkDao接口

<?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.example.mybatis.dao.StudentHomeworkDao">

<resultMap id="stu" type="com.example.mybatis.model.Student">
    <id column="id" property="id" />
    <result column="name" property="name"/>
    <result column="create_time" property="createTime"/>
</resultMap>

    <insert id="addHomework" parameterType="StudentHomework">
        INSERT INTO `s_student_homework`(student_id,homework_id,homework_title,homework_content,create_time) VALUE(#{studentId},#{homeworkId},#{homeworkTitle},#{homeworkContent},#{createTime})
    </insert>

    <update id="editHomework" parameterType="Long">
        UPDATE s_student_homework SET score=#{score} WHERE student_id=#{studentId} AND homework_id=#{homeworkId}
    </update>

    <delete id="deleteHomework" parameterType="Long">
        DELETE FROM `s_student_homework`WHERE student_id=#{studentId}
    </delete>
<delete id="deleteHomework2" >
	    DELETE FROM `s_student_homework`WHERE student_id=#{studentId} AND homework_id=#{homeworkId}
	</delete>
	
    <select id="find1" resultType="com.example.mybatis.model.StudentHomework">
        SELECT * FROM s_student_homework WHERE student_id=#{studentId} AND homework_id=#{homeworkId}
    </select>

    <select id="find12" resultType="com.example.mybatis.model.StudentHomework" parameterType="Long">
        SELECT * FROM s_student_homework WHERE homework_id=#{homeworkId}
    </select>

    <select id="selectAll1" resultType="com.example.mybatis.model.StudentHomework">
        SELECT * FROM s_student_homework
    </select>


</mapper>

（6.2）application.properties

• 在学习的过程中，大多时候项目与数据库都在本机上，使用hibernate或者mybatits加上简单的配置就能够打通程序到数据库路径，让程序能够访问到数据库。
• 在这里配置少量的包括数据库信息的资源文件即可，提供连接mysql相关的信息：url，驱动，用户名，密码

server.port=7777
spring.jpa.database=mysql
spring.jpa.show-sql=true

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.password=123456
spring.datasource.username=root
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/j1?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai

spring.mvc.view.prefix=/jsp/

spring.mvc.view.suffix=.jsp
spring.thymeleaf.cache=false
spring.thymeleaf.enabled = false

mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package= com.example.mybatis.model

（6.3）mybatis-config.xml

• MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置（settings）和属性（properties）信息

<?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>
    <!--配置全局属性-->
    <settings>
        <!--使用jdbc的getGeneratedKeys获取数据库自增主键值-->
        <setting name="useGeneratedKeys" value="true"/>
        <!--使用列标签替换列别名 默认未true-->
        <setting name="useColumnLabel" value="true" />
        <!--开启驼峰式命名转换：Table{create_time} -> Entity{createTime}-->
        <setting name="mapUnderscoreToCamelCase" value="true" />
    </settings>
</configuration>

（七）webapp

（7.1）jsp文件

• 所有的jsp文件放在这里

• 项目完成~

源码地址：https://github.com/zhangzhangzhang0/JavaeeFinalProject