基于Spring+mybatis+amazeui+MySQL实现的毕业设计论文管理系统

1.项目介绍

毕业设计是本科教育的最后一个环节，整个过程包括课题拟定与审核、师生双选、开题报告、文档审核、中期检查、毕业答辩等多个环节，是一项系统而复杂的工作。开发一个适合本校的毕业设计管理系统，不仅能够极大地减少教务管理人员的工作量，还能较大地提高学生和教师的效率。

毕业设计管理系统可以分为五个模块：登录模块，选题模块，信息管理模块，流程管理模块，文件管理模块。

该系统在技术上使用 Spring + SpringMVC + MyBatis 整合框架作为后台开发框架，AmazeUI 作为前端开发框架。并使用 Ehcache 作为项目的缓存，druid 作为项目的数据库连接池，使用 FreeMarker 实现 word 的导出，使用 Shiro 完成项目的登录认证，数据库使用的则是 MySQL。

该系统可以分为三类角色：学生，教师，教务管理员。

该系统前端界面使用纯 HTML 实现，与后台的交互则都是通过 Ajax 完成。

1.1 软件架构

系统的组织架构如图所示，三种用户根据自己不同的权限对课题、文档、成绩、公告、任务五种数据信息进行处理，不同用户角色再根据这些数据信息进行交互通过课题进行交互，并且围绕着文档进行数据的传递和处理等。

系统的功能模块如图所示，每个模块各有几个子功能模块。

本系统包含三种用户：学生、教师和管理员。通过本系统，学生可以获取指导教师和管理员发布的相关教学信息和教学资源；教师可以进行毕设进度的日常管理，发布任务、上传资料、审核文档等；管理员可以进行系统的管理和维护，并对教师、学生、课题和文档进行管理，确保系统的正常运行。

系统总共分为3个模块：

1.学生模块 学生登录系统后进入该模块，在该模块中，学生能够修改个人资料和登录密码，选择感兴趣的课题及导师，下载导师上传的相关参考资料，上传自己已经完成的文档，查看发布的公告、任务和自己的阶段成绩等
2.教师模块 教师登录系统后进入该模块，在该模块中，教师能够修改个人资料和登录密码，选择学生，上传拟好的课题题目给管理员审核，发布阶段任务，上传相关资料给学生参考，下载学生上传的阶段文档并审核和打分，查看公告及发布新公告等
3.管理员模块 管理员登录系统后进入该模块，在该模块中，管理员可以增删查改导师和学生的信息，审核教师上传的课题，发布公告，查看各种信息，查看各种数据分析的结果和图表

2.数据库设计

2.1 数据分析

本系统的主要数据表为存储学生、教师、文档、课题数据集的四个表。其余表大多作为外键关联用于完善四张表的信息。

概念设计：

数据库主要围绕学生、教师、课题、文档4个实体进行数据处理。即系统只要处理好这4个实体的数据，就可以完成系统的绝大部分功能并让毕业设计管理的整个流程顺利进行下去。其余的数据表则是围绕这4个实体相应展开，进行一些扩展和补充，以完善整个数据库的结构并加快数据库对请求的响应速度。

数据库文档处理E-R图

数据库课题处理E-R图

2.2 表列表

数据库中一共设计了24张表，和学生相关的表有12张（包括学生信息、开题报告、文档成绩、毕设进度、学生疑问等），和教师相关的表有5张（包括教师信息、任务书、阶段任务、课题申报等），文档有2张表，课题涉及3张表，还有2张表属于公共信息表，用于进行一些补充以完善数据库。数据库的表清单如下。

管理员用户表

班级信息表

答辩信息表

部门科室表

字典表

下载信息表

年级表

公告表

综述表

论文表

盲审信息表

免答辩信息表

留言消息表

课题表

课题来源表

权限表

专业表

学生表

教师表

用户表

工作时间表

验收老师表

验收小组表

中期自查表

2.3 数据表关系图

2.4 功能模块的设计与实现

本系统依据学生、导师、管理员三种不同用户角色的需求，分为了三个大的功能模块，三种用户角色在各自的模块进行操作，可以通过课题进行与其他两种用户角色之间的交互，并且围绕着文档进行各种数据（用户信息、文档信息、课题信息）的传递和处理等，这就形成了系统的体系结构，管理员发布课题给学生，学生选择课题呈现给导师，导师自拟课题向管理员申报，如图所示。

同时三种用户可对五种数据信息进行不同的处理（增删查改的权限不同），表现在系统上就是拥有不同的功能模块，所以分为三个大的模块，每个模块有相应的小的功能模块，系统的功能结构如图。

3.项目实现

3.1 word文档工具类

```java public class WordUtils { //配置信息,代码本身写的还是很可读的,就不过多注解了 private static Configuration configuration = null; //这里注意的是利用WordUtils的类加载器动态获得模板文件的位置 private static final String templateFolder = WordUtils.class.getClassLoader().getResource("../").getPath()+"/templete/"; static { configuration = new Configuration(); configuration.setDefaultEncoding("utf-8"); try { configuration.setDirectoryForTemplateLoading(new File(templateFolder)); } catch (IOException e) { e.printStackTrace(); } }

private WordUtils() {
    throw new AssertionError();
}

public static void exportMillCertificateWord(HttpServletRequest request, HttpServletResponse response,
        Map map, String templeteName, String fileName) throws IOException {
    //Template freemarkerTemplate = configuration.getTemplate("开题报告.ftl");
    Template freemarkerTemplate = configuration.getTemplate(templeteName);
    File file = null;
    InputStream fin = null;
    ServletOutputStream out = null;
    try {
        // 调用工具类的createDoc方法生成Word文档
        file = createDoc(map,freemarkerTemplate);
        fin = new FileInputStream(file);
       // response.setCharacterEncoding("utf-8");
        response.setContentType("application/msword;charset=utf-8");
        // 设置浏览器以下载的方式处理该文件名
       // String fileName = "开题报告.doc";
        response.setHeader("Content-Disposition", "attachment;filename=".concat(String.valueOf(Utils.filenameEncoding(fileName, request))));
        out = response.getOutputStream();
        byte[] buffer = new byte[512];  // 缓冲区
        int bytesToRead = -1;
        // 通过循环将读入的Word文件的内容输出到浏览器中
        while((bytesToRead = fin.read(buffer)) != -1) {
            out.write(buffer, 0, bytesToRead);
        }
    } finally {
        if(fin != null) fin.close();
        if(out != null) out.close();
        if(file != null) file.delete(); // 删除临时文件
    }
}

private static File createDoc(Map<?, ?> dataMap, Template template) {
    String name =  "test.doc";
    File f = new File(name);
    Template t = template;
    try {
        // 这个地方不能使用FileWriter因为需要指定编码类型否则生成的Word文档会因为有无法识别的编码而无法打开
        Writer w = new OutputStreamWriter(new FileOutputStream(f), "utf-8");
        t.process(dataMap, w);
        w.close();
    } catch (Exception ex) {
        ex.printStackTrace();
        throw new RuntimeException(ex);
    }
    return f;
}

} ```

3.2 登录拦截类

```java public class LoginRealm extends AuthenticatingRealm{

@Autowired
private UserService userService;

@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
    System.out.println("doGetAuthenticationInfo1:"+token.hashCode());
    //1.将AuthenticationToken强转为UsernamePasswordToken
    UsernamePasswordToken uspaToken=(UsernamePasswordToken)token;
    //2.获得用户名,密码
    String userName=uspaToken.getUsername();
    String password=new String(uspaToken.getPassword());
    //3.查询数据库获得真实的用户名或密码(这里模拟)
    //若用户不存在,抛出UnknownAccountException
    User user = userService.login(userName, password);
    if(user==null) {
        throw new UnknownAccountException("用户不存在");
    }
    if(user.getUserRoles()==null||user.getUserRoles()==3){
        throw new LockedAccountException("用户被锁定");
    }
    //4.根据用户信息构建AuthenticationInfo，我们常用其子类：
    //1).principal 用户实体信息  可以是userName，也可以是数据表对应的实体类信息
    Object principal=userName;
    //2).credentials 密码
    Object credentials=password;
    //3).realmName  使用当前realName即可
    String realmName=this.getName();
    SimpleAuthenticationInfo info=new SimpleAuthenticationInfo(principal, credentials, realmName);
    return info;
}

} ```

3.3 主要代码编写

UserController.java

```java @Controller @RequestMapping("/userController") public class UserController {

@Autowired
private UserService userService;

@ResponseBody
@RequestMapping(value="/isuser",method=RequestMethod.POST)
public boolean isUser(String account) {
    return userService.isUser(account);
}

@ResponseBody
@RequestMapping(value="/ispassword",method=RequestMethod.POST)
public boolean ispassword(@RequestParam("password")String password,HttpSession session) {
    User user = (User) session.getAttribute("user");
    if(user!=null) {
        return userService.ispassword(Utils.md5(password),user.getUserId());
    }
    return false;
}

@ResponseBody
@RequestMapping(value="/login",method=RequestMethod.POST)
public String login(HttpSession session,String randStr,String account,String password) {
    String randStr2=(String) session.getAttribute("randStr");
        if(randStr2!=null&&randStr2.equals(randStr)) {
            password=Utils.md5(password);
            Subject currentUser = SecurityUtils.getSubject();
            if (!currentUser.isAuthenticated()) {
                //把用户名和密码封装为UsernamePasswordToken
                UsernamePasswordToken token = new UsernamePasswordToken(account, password);
                try {
                    //执行登录
                    currentUser.login(token);
                    return toUI(session,account,password);
                }
                //用户不存在
                catch (UnknownAccountException ae) {
                    return "passwordError";
                }
                //用户被锁定
                catch (LockedAccountException e) {
                    return "passwordError";
                }
            }else {
                return toUI(session,account,password);
            }
        }else {
            return "randStrError";
        }
}
private String toUI(HttpSession session,String account,String password) {
    User user = userService.login(account, password);
    if(user!=null) {
        if(2==user.getUserRoles()) {
            session.setAttribute("user", user);
            return "student/sindex.html";
        }
        if(1==user.getUserRoles()) {
            session.setAttribute("user", user);
            return "teacher/tindex.html";
        }
    }
    return "passwordError";
@RequestMapping("/logout")
public String logout(HttpSession session) {
    session.removeAttribute("user");
    return "redirect:http://localhost:8080/graduation/login.html";
}

@ResponseBody
@RequestMapping(value="/updateInfo",method=RequestMethod.POST)
public boolean updateStudentInfo(User user,
        @RequestParam(value="portrait",required=false)MultipartFile portrait,HttpServletRequest request) {
    if(portrait!=null&&portrait.getSize()>0) {
        if(portrait.getSize()>(10*1024*1024)) {
            return false;
        }
        String filename=portrait.getOriginalFilename();
        String dbPath=request.getServletContext().getContextPath()+"/portrait/"+user.getUserId();
        String basePath=request.getServletContext().getRealPath("/portrait/"+user.getUserId());
        new File(basePath).mkdir();
        File portraitFile=new File(basePath,filename);
        try {
            portrait.transferTo(portraitFile);
            user.setUserPortrait(dbPath+"/"+filename);
            return userService.updateUserInfo(user);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    return userService.updateUserInfo(user);
}

@ResponseBody
@RequestMapping(value="/updatePwd",method=RequestMethod.PUT)
public boolean updateStudentPwd(User user,HttpSession session) {
    String password=user.getUserPassword();
    if(password!=null&&!password.isEmpty()) {
        user.setUserPassword(Utils.md5(password));
        boolean bool = userService.updateUserInfo(user);
        if(bool==true) {
            session.removeAttribute("user");
            return true;
        }
    }
    return false;
}

} ```

ProjectController.java

```java @Controller @RequestMapping("/projectController") public class ProjectController {

@Autowired
private ProjectService projectService;
@Autowired
private TeacherService teacherService;
@Autowired
private StudentService studentService;

@ResponseBody
@RequestMapping(value="/getProjectListByTeacherId",method=RequestMethod.GET)
public PageInfo<Project> getProjectListByTeacherId(@RequestParam(required=true)String teacherId,
          @RequestParam(defaultValue="1")int pageNum,@RequestParam(defaultValue="8")int pageSize) {
    PageHelper.startPage(pageNum, pageSize);
    List<Project> list = projectService.getProjectListByTeacherId(teacherId);
    return new PageInfo<>(list);
}

@ResponseBody
@RequestMapping(value="/getCountProjectNum",method=RequestMethod.GET)
public int getCountProjectNum() {
    return projectService.getCountProjectNum();
}

@ResponseBody
@RequestMapping(value="/thisTeacherYesProjectNum",method=RequestMethod.GET)
public int thisTeacherYesProjectNum(HttpSession session) {
    User user=(User) session.getAttribute("user");
    if(user!=null) {
        Teacher teacher = teacherService.findTeacherByUserId(user.getUserId());
        if(teacher!=null) {
            String teacherId = teacher.getTeacherId();
            return projectService.thisTeacherYesProjectNum(teacherId);
        }
    }
    return 0;
}

@ResponseBody
@RequestMapping(value="/thisTeacherUndefinedStudentNum",method=RequestMethod.GET)
public int thisTeacherUndefinedStudentNum(HttpSession session) {
    User user=(User) session.getAttribute("user");
    if(user!=null) {
        Teacher teacher = teacherService.findTeacherByUserId(user.getUserId());
        if(teacher!=null) {
            String teacherId = teacher.getTeacherId();
            return studentService.thisTeacherUndefinedStudentNum(teacherId);
        }
    }
    return 0;
}

/**
 * 添加与更新方法
 * @param project
 * @param session
 * @return
 */
@ResponseBody
@RequestMapping(value="/insertSelective",method=RequestMethod.POST)
public boolean insertSelective(Project project,HttpSession session) {
    User user=(User) session.getAttribute("user");
    if(user!=null) {
        Teacher teacher = teacherService.findTeacherByUserId(user.getUserId());
        if(teacher!=null) {
            project.setTeacherId(teacher.getTeacherId());
            if(project.getProjectId()!=null) {
                return projectService.updateByPrimaryKeySelective(project);
            }else {
                return projectService.insertSelective(project,teacher.getTeacherId());
            }
        }
    }
    return false;
}

@ResponseBody
@RequestMapping(value="/getProjectByTeacherId")
public List<Project> getProjectByTeacherId(HttpSession session){
    User user=(User) session.getAttribute("user");
    if(user!=null) {
        Teacher teacher = teacherService.findTeacherByUserId(user.getUserId());
        if(teacher!=null) {
            return projectService.getProjectByTeacherId(teacher.getTeacherId());
        }
    }
    return null;
}

} ```