目录

一.前言介绍

二、主要技术

2.1  SSM框架介绍

2.2 MYSQL数据库

2.3 持久层框架MyBatis

2.4 前端框架BootStrap

三. 系统设计

3.1 系统架构设计

3.2 系统功能模块

3.2.1 学生模块

3.2.2 教师模块

3.2.3 管理员模块

四、数据库设计

4.1 数据分析

4.2 概念设计

4.3 重要E-R图

4.3.1 数据库文档处理的E-R图

 4.3.2 数据库文档处理的E-R图

 4.4 表设计

五、功能截图

5.1 学生模块部分页面

5.2 教师模块部分页面

5.3 管理员模块部分页面

 六、部分代码实现

6.1 用户模块controller代码实现

6.2 学生模块controller代码实现

七. 项目总结

八. 源码获取

---

一.前言介绍

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

二、主要技术

2.1  SSM框架介绍

本课题程序开发使用到的框架技术，名称缩写是SSM，在JavaWeb开发中使用的流行框架有SSH、SSM、SpringMVC等，作为一个课题程序采用SSH框架也可以，SSM框架也可以，SpringMVC也可以。SSH框架是属于重量级别的框架，配置繁琐，不够灵活，修改程序需要修改好多个文件，并且运行起来也占用内存较高，CPU使用率相对也高，SpringMVC是Spring开发的一套MVC架构，更灵活更好用，SSM框架取中间值，既没有SSH臃肿，也没有SpringMVC简化，属于中间级别的，在配置过程和使用过程中更能编写和理解。MyBatis框架取代Hibernate框架是因为它更灵活，不需要完全在框架里操作，它在数据操作上可以写出更灵活的代码，它的性能也比Hibernate框架更稳定。总的来说，使用SSM框架是通过综合考虑而使用的，网上有很多的使用教程和心得体会，而且SSM又是这么的流行，用SSM框架开发是顺其自然的。

2.2 MYSQL数据库

Mysql的语言是非结构化的，用户可以在数据上进行工作。MySQL因为其速度、可靠性和适应性而备受关注。大多数人都认为在不需要事务化处理的情况下，MySQL是管理内容最好的选择。并且因为Mysql的语言和结构比较简单，但是功能和存储信息量很强大，所以得到了普遍的应用。Mysql数据库在编程过程中的作用是很广泛的，为用户进行数据查询带来了方便。Mysql数据库的应用因其灵活性强，功能强大，所以在实现某功能时只需要一小段代码，而不像其他程序需要编写大段代码。总体来说，Mysql数据库的语言相对要简洁很多。

2.3 持久层框架MyBatis

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

2.4 前端框架BootStrap

Bootstrap是美国Twitter公司的设计师Mark Otto和Jacob Thornton合作基于HTML、CSS、JavaScript 开发的简洁、直观、强悍的前端开发框架，使得 Web 开发更加快捷。

Bootstrap中包含了丰富的Web组件，根据这些组件，可以快速的搭建一个漂亮、功能完备的网站，其中包括以下组件：下拉菜单、按钮组、按钮下拉菜单、导航、导航条、路径导航、分页、排版、缩略图、警告对话框、进度条、媒体对象等。

三. 系统设计

3.1 系统架构设计

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

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

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

3.2 系统功能模块

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

3.2.1 学生模块

学生登录系统后进入该模块，在该模块中，学生能够修改个人资料和登录密码，选择感兴趣的课题及导师，下载导师上传的相关参考资料，上传自己已经完成的文档，查看发布的公告、任务和自己的阶段成绩等。

3.2.2 教师模块

教师登录系统后进入该模块，在该模块中，教师能够修改个人资料和登录密码，选择学生，上传拟好的课题题目给管理员审核，发布阶段任务，上传相关资料给学生参考，下载学生上传的阶段文档并审核和打分，查看公告及发布新公告等。

3.2.3 管理员模块

管理员登录系统后进入该模块，在该模块中，管理员可以增删查改导师和学生的信息，审核教师上传的课题，发布公告，查看各种信息，查看各种数据分析的结果和图表。

四、数据库设计

4.1 数据分析

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

4.2 概念设计

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

4.3 重要E-R图

4.3.1 数据库文档处理的E-R图

 4.3.2 数据库文档处理的E-R图

 4.4 表设计

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

序号	物理表名	中文名称
1	t_announcement	公告表
2	t_department	学院表
3	t_doubt	疑问表
4	t_major	专业表
5	t_student	学生表
6	t_student_opening_report_task_book	学生开题报告表
7	t_student_progress	学生进度通知填写表
8	t_student_score	学生成绩表
9	t_teacher	教师表
10	t_teacher_opening_report_task_book	教师开题报告表
11	t_teacher_progress_notification	教师阶段任务表
12	t_thesis_information	文档提交表
13	t_thesis_title	教师提交课题表
14	t_topic	选题信息表
15	t_user	用户表

五、功能截图

5.1 学生模块部分页面

5.2 教师模块部分页面

5.3 管理员模块部分页面

 六、部分代码实现

6.1 用户模块controller代码实现

package com.zc.web;


import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.zc.entity.Student;
import com.zc.entity.Teacher;
import com.zc.entity.User;
import com.zc.service.IDepartmentService;
import com.zc.service.IMajorService;
import com.zc.service.IStudentService;
import com.zc.service.ITeacherService;
import com.zc.service.IUserService;

/**
 * @date 2018-4-6
 * @author zhangC
 * adminLogin() 管理员登陆
 * teacherLogin() 教师登陆
 * studentLogin() 学生登陆
 * quitSystem() 退出系统
 * modifyPassword() 修改密码，由于管理员，教师，学生的修改密码相同，所以只用一个controller作为修改。
 *
 * @date 2018-4-11
 * @author zhangC
 * 修改了teacherLogin() 方法，新增了查询教师信息的功能。并且写入session中。
 *
 */

@Controller
public class UserController {
	
	@Autowired
	private IUserService userService;
	
	@Autowired
	private ITeacherService teacherService;
	
	@Autowired
	private IDepartmentService departmentService;
	
	@Autowired
	private IStudentService studentService;
	
	@Autowired
	private IMajorService majorService;
	
	@RequestMapping(value="/admin/login")
	public String adminLogin(String userNo,String password,Model model,HttpServletRequest request) {
		User currentUser = userService.login(userNo, password);
		if("".equals(currentUser)||currentUser==null) {
			model.addAttribute("message", "用户名或密码错误");
			return "../../admin/adminLogin.jsp";
		}
		if(currentUser.getPermission()==3) {
			// request.getSession().setAttribute("userNo", userNo);
			HttpSession session = request.getSession();
			session.setMaxInactiveInterval(3600);
			
			session.setAttribute("currentUser", currentUser);
			//model.addAttribute("userNo", userNo);
			return "admin/main.jsp";
		}else {
			model.addAttribute("message", "当前用户不是管理员");
			return "../../admin/adminLogin.jsp";
		}
	}
	
	@RequestMapping(value="/teacher/login")
	public String teacherLogin(String userNo,String password,Model model,HttpServletRequest request) {
		
		User currentUser = userService.login(userNo, password);
		if("".equals(currentUser)||currentUser==null) {
			model.addAttribute("message", "用户名或密码错误");
			return "../../teacher/teacherLogin.jsp";
		}
		if(currentUser.getPermission()==2) {
			HttpSession session = request.getSession();
			session.setMaxInactiveInterval(3600);
			// 在t_user表的信息
			session.setAttribute("currentUser", currentUser);
			
			// 完整的teacher信息
			Teacher teacher = teacherService.showInfoByNo(userNo);
			int depId = teacher.getDepartmentId();
			String depName = departmentService.getNameById(depId);
			teacher.setDepartmentName(depName);
			
			session.setAttribute("teacher", teacher);
			//model.addAttribute("userNo", userNo);
			return "teacher/main.jsp";
		}else {
			model.addAttribute("message", "当前用户不是教师");
			return "../../teacher/teacherLogin.jsp";
		}
	}
	@RequestMapping(value="/student/login")
	public String studentLogin(String userNo,String password,Model model,HttpServletRequest request) {
		
		User currentUser = userService.login(userNo, password);
		System.out.println(currentUser);
		if("".equals(currentUser)||currentUser==null) {
			model.addAttribute("message", "用户名或密码错误");
			//model.addAttribute("url", "../student/studentLogin.jsp");
			//return "error.jsp";
			return "../../student/studentLogin.jsp";
		}
		if(currentUser.getPermission()==1) {
			HttpSession session = request.getSession();
			session.setMaxInactiveInterval(3600);
			// t_user 表中的关于学生的信息
			session.setAttribute("currentUser", currentUser);
			
			// t_student 表中的信息
			Student student = studentService.getStudentByNO(userNo);
			int majorId = student.getMajorId();
			String majorName = majorService.getNameById(majorId);
			student.setMajorName(majorName);
			
			session.setAttribute("student", student);
			// model.addAttribute("userNo", userNo);
			return "student/main.jsp";
		}else {
			model.addAttribute("message", "当前用户不是学生");
			//return "error.jsp";
			return "../../student/studentLogin.jsp";
		}
	}
	
	@RequestMapping(value="/quit")
	public String quitSystem(Model model,HttpServletRequest request) { 
		
		request.getSession().invalidate();
		
		return "../../index.jsp";
	}
	
	@RequestMapping(value="/modifyPassword")
	public String modifyPassword(Model model,String newPassword1,String currentUserNo) {
		
		/*System.out.println("新的密码："+newPassword1);
		System.out.println("账户："+currentUserNo);*/
		int num = userService.modifyPassword(currentUserNo, newPassword1);
		System.out.println("修改了"+num+"条数据");
		model.addAttribute("num", num);
		return "modifySuccess.jsp";
	}
	
}

6.2 学生模块controller代码实现

package com.zc.web;

import java.io.File;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.commons.io.FileUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.zc.entity.Announcement;
import com.zc.entity.Doubt;
import com.zc.entity.Student;
import com.zc.entity.StudentScore;
import com.zc.entity.StudentTaskBookOpening;
import com.zc.entity.TeacherProgress;
import com.zc.entity.TeacherTaskBookOpening;
import com.zc.entity.ThesisInformation;
import com.zc.entity.ThesisTitle;
import com.zc.entity.Topic;
import com.zc.entity.User;
import com.zc.entity.Zhiyuan;
import com.zc.service.IMajorService;
import com.zc.service.IStudentService;
import com.zc.service.ITeacherService;

/**
 * 
 * @author zhangC
 * addStudentForm() 主页跳转到添加界面
 * addStudent() 添加学生   以废除
 * studentInfo() 学生修改个人信息跳转
 * 
 * @date 2018-4-6
 * @author zhangC 
 * @desc 都是跳转页面
 * studentMainForm() 跳转学生管理主页
 * studentMofidyInfoForm() 跳转学生 修改个人信息页
 * studentMofidyPasswordForm() 跳转学生 修改密码页
 * studentThesis() 学生选题页
 * studentThesisResult() 学生选题结果页
 * studentViewTaskOpening() 查看任务书及开题报告
 * studentSectionTask() 填写阶段任务
 * studentUploadFile() 文件上传
 * studentResourcesDownload() 文件下载
 * studentAnnouncement() 查看公共
 * studentScore() 查询成绩
 * 
 * @date 2018-4-12
 * @author zhangC
 * 修改了studentThesis() 页面可以显示当前学生的选题状况，若是选择了课题则直接跳转到主页。
 * 修改了studentThesisResult() 显示学生的选题情况，若是为选择课题则不能查询选题结果，会直接跳转到主页
 * studentModifyInfoToDb() 修改学生信息
 * studentGetAllAvailableTopicForm() 获得可选择的课题，用于学生选题页
 * studentSelectTopic() 提交当前学生的选题情况
 * studentDeleteChosenTopic() 学生退选当前课题
 * 
 * @date 2018-4-15
 * @author zhangC
 * 修改了studentViewTaskOpening() 页面，用于查看学生所选课题的开题报告和任务书，并下载
 * 修改了 studentResourcesDownload() 也main，显示学生上传的内容
 * fileDownload() 文件下载
 * studentUploadTaskBook() 上传自己写的任务书 ---以废除不用
 * studentUploadOpening() 上传自己写的开题报告
 * fileDelete() 文件删除
 * studentOpeningResult() 学生查看自己开题报告的审核结果 (未提交--- 通过---- 不通过  )
 * 
 * @date 2018-4-16
 * @author zhangC
 * 修改了 studentSelectTopic() 方法 添加了 把选题信息保存到application 中，以便jsp页面的显示
 * getRealTimeTopic() 获得当前选题信息，并保存到application中
 * 
 * @date 2018-4-17
 * @author zhangC
 * 修改了studentResourcesDownload方法，可以显示上传为论文信息
 * 修改了fileDelete方法，可以删除上传的论文信息
 * studentUploadThesisInformation() 学生提交 学生论文信息
 * 
 * @date 2018-4-18
 * @author zhangC
 * studentQualification()  学生答辩资格的查看
 * 
 * @date 2018-5-9
 * @author zhangC
 * studentDoubtForm() 跳转到学生提出疑惑页面
 * studentDoubtListForm() 显示学生的疑惑，并查看是否有解决方案
 * studentDoubtToDb() 添加学生的疑惑道数据库
 * 
 */

@Controller
@RequestMapping(value="/student")
public class StudentController {

	@Autowired
	private IStudentService studentService;
	
	@Autowired
	private IMajorService majorService;
	
	@Autowired
	private ITeacherService teacherService;
	
	@RequestMapping(value="/add",method=RequestMethod.GET)
	public String addStudentForm() {
		return "student/addStudent.jsp";
	}
	
	private String realTimeTopicMessageOn = "";
	
	// 已废除
	@RequestMapping(value="/add",method=RequestMethod.POST)
	public String addStudent(HttpServletRequest request,String studentNo, String studentName,String sex,String grade ,String inputMan,String phone,String major,Model model) throws Exception {
		studentNo = new String(studentNo.getBytes("iso-8859-1"),"utf-8");
		studentName = new String(studentName.getBytes("iso-8859-1"),"utf-8");
		sex = new String(sex.getBytes("iso-8859-1"),"utf-8");
		grade = new String(grade.getBytes("iso-8859-1"),"utf-8");
		inputMan = new String(inputMan.getBytes("iso-8859-1"),"utf-8");
		phone = new String(phone.getBytes("iso-8859-1"),"utf-8");
		major = new String(major.getBytes("iso-8859-1"),"utf-8");
		Date currentTime = new Date();
		
		Student student = new Student();
		student.setStudentNo(studentNo);
		student.setStudentName(studentName);
		student.setSex(sex);
		student.setGrade(grade);
		student.setInputMan(inputMan);
		student.setPhone(phone);
		student.setMajorId(Integer.parseInt(major));
		student.setLastModifyTime(currentTime);
		
		int addNum = studentService.addStudent(student);
		System.out.println("添加数目："+addNum);
		
		return "student/addSuccess.jsp";
	}
	
	@RequestMapping(value="/info",method=RequestMethod.GET)
	public String studentInfo() {
		return "student/studentPersionalInformation.jsp";
	}
	
	@RequestMapping(value="/main",method=RequestMethod.GET)
	public String studentMainForm() {
		return "student/main.jsp";
	}
	
	@RequestMapping(value="/modifyInfo",method=RequestMethod.GET)
	public String studentMofidyInfoForm() {
		return "student/studentModifyInfo.jsp";
	}
	
	@RequestMapping(value="/modifyPassword",method=RequestMethod.GET)
	public String studentMofidyPasswordForm() {
		return "student/studentModifyPassword.jsp";
	}
	
	@RequestMapping(value="/thesis",method=RequestMethod.GET)
	public String studentThesis(HttpServletResponse response,HttpServletRequest request,Model model) {
		User currentUser = (User)request.getSession().getAttribute("currentUser");
		String userNo = currentUser.getUserNo();
		//获取所有课题
		List<ThesisTitle> thesisList = teacherService.showAllThesisTitle();
		
		Student student = studentService.getStudentByNO(userNo);
		int studentId = student.getId();
		Topic topic = studentService.chosenThesisTitle(studentId);
		//ThesisTitle title = teacherService.getThesisInfoByThesisId(topic.getThesisId());
		
		//ThesisInformation topic2 = studentService.getInfoByStudentId(studentId);
		if(topic == null || "".equals(topic)) {
			model.addAttribute("thesisTitleList", thesisList);
			System.out.println("查询到的课题有："+thesisList);
			return "student/studentThesis.jsp";
		}else {
			System.out.println(topic);
			model.addAttribute("topicMessage", "你已选择课题，不可多选");
			//model.addAttribute("Message", title.getThesisName());
			
			return "student/main.jsp";
		}
		
		
		
	}
	
	@RequestMapping(value="/thesisResult",method=RequestMethod.GET)
	public String studentThesisResult(HttpServletResponse response,HttpServletRequest request,Model model) {
		User currnetUser = (User)request.getSession().getAttribute("currentUser");
		String studentNo = currnetUser.getUserNo();
		Student student = studentService.getStudentByNO(studentNo);
		int studentId = student.getId();
		Topic topic = studentService.chosenThesisTitle(studentId);
		Zhiyuan zhiyuan = studentService.chosenZhiyuan(studentId);
		if(topic == null || "".equals(topic)) {
			if(zhiyuan == null || "".equals(zhiyuan)) {
				model.addAttribute("topicMessage", "还未选择课题");
				model.addAttribute("realTimeTopicMessage", realTimeTopicMessageOn);
			} else {
				model.addAttribute("topicMessage", "已选择课题，请等待导师选择");
				model.addAttribute("realTimeTopicMessage", realTimeTopicMessageOn);
			}
			
			return "student/main.jsp";
		}else {
			int thesisId = topic.getThesisId();
			
			ThesisTitle theisTitle = teacherService.getThesisById(thesisId);
			String topicName = theisTitle.getThesisName();
			String inputMan = theisTitle.getInputMan();
			String nandu = theisTitle.getNandu();
			String liang = theisTitle.getLiang();
			String from = theisTitle.getFrom();
			String leixing = theisTitle.getLeixing();
			String description = theisTitle.getDescription();
			
			model.addAttribute("topicName", topicName);
			model.addAttribute("inputMan", inputMan);
			model.addAttribute("nandu", nandu);
			model.addAttribute("liang", liang);
			model.addAttribute("from", from);
			model.addAttribute("leixing", leixing);
			model.addAttribute("description", description);
			
			model.addAttribute("realTimeTopicMessage", realTimeTopicMessageOn);
			
			return "student/studentThesisResult.jsp";
		}
		
	}
	
	@RequestMapping(value="/viewTaskOpening")
	public String studentViewTaskOpening(HttpServletRequest request,Model model) {
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		Topic topic = studentService.chosenThesisTitle(studentId);
		if(topic == null || "".equals(topic)) {
			model.addAttribute("message", "尚未选择课题");
			return "student/studentViewTaskBookAndOpening.jsp";
		}else {
			int thesisId = topic.getThesisId();
			TeacherTaskBookOpening ttbo = studentService.getFilePathByThesisId(thesisId);
			if(ttbo==null || "".equals(ttbo)) {
				return "student/studentViewTaskBookAndOpening.jsp";
			}else {
				// 获得数据库中的文件目录；
				String taskBookPath = ttbo.getTaskBook();
				String openingPath = ttbo.getOpeningReport();
				String keXingXingPath = ttbo.getKeXingXing();
				String xuQiuPath = ttbo.getXuQiu();
				String gaiYaoPath = ttbo.getGaiYao();
				String shuJuKuPath = ttbo.getShuJuKu();
				
				Map<String, String> fileList = new HashMap<String, String>();

				if(taskBookPath == null || "".equals(taskBookPath)) {
					
				}else {
					String[] str1 = taskBookPath.split("\\\\");
					String taskBookName = str1[str1.length-1].toString();
					fileList.put(taskBookName, taskBookPath);
				}
				
				if(openingPath == null || "".equals(openingPath)) {
					
				}else {
					String[] str2 = openingPath.split("\\\\");
					String openingName = str2[str2.length-1].toString();
					fileList.put(openingName, openingPath);
				}
				
				if(keXingXingPath == null || "".equals(keXingXingPath)) {
					
				}else {
					String[] str2 = keXingXingPath.split("\\\\");
					String keXingXingName = str2[str2.length-1].toString();
					fileList.put(keXingXingName, keXingXingPath);
				}
				
				if(xuQiuPath == null || "".equals(xuQiuPath)) {
					
				}else {
					String[] str2 = xuQiuPath.split("\\\\");
					String xuQiuName = str2[str2.length-1].toString();
					fileList.put(xuQiuName, xuQiuPath);
				}
				
				if(gaiYaoPath == null || "".equals(gaiYaoPath)) {
					
				}else {
					String[] str2 = gaiYaoPath.split("\\\\");
					String gaiYaoName = str2[str2.length-1].toString();
					fileList.put(gaiYaoName, gaiYaoPath);
				}
				
				if(shuJuKuPath == null || "".equals(shuJuKuPath)) {
					
				}else {
					String[] str2 = shuJuKuPath.split("\\\\");
					String shuJuKuName = str2[str2.length-1].toString();
					fileList.put(shuJuKuName, shuJuKuPath);
				}
				
				model.addAttribute("fileList", fileList);
				
				return "student/studentViewTaskBookAndOpening.jsp";
			}
			
		}
		
		
	}
	
	@RequestMapping(value="/sectionTask")
	public String studentSectionTask(HttpServletRequest request,Model model) {
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		
		List<TeacherProgress> progresses = studentService.getTeacherProgressByStudentId(studentId);
		
		for(int i=0;i<progresses.size();i++) {
			int state = progresses.get(i).getState();
			if(state ==0) {
				progresses.get(i).setStateName("教师还未查看");
			}else if(state ==1) {
				progresses.get(i).setStateName("未通过");
			}else {
				progresses.get(i).setStateName("已通过");
			}
			
		}
		
		
		model.addAttribute("progressList", progresses);
		
		return "student/studentSectionTask.jsp";
	}
	
	@RequestMapping(value="/uploadFile",method=RequestMethod.GET)
	public String studentUploadFile() {
		return "student/studentUploadFile.jsp";
	}
	
	@RequestMapping(value="/resourcesDownload")
	public String studentResourcesDownload(HttpServletRequest request,Model model) {
		
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		
		
		Map<String, String> fileList = studentService.getTaskBookOpeningToMap(studentId);
		if(fileList.isEmpty()) {
			return "student/studentResourcesDownload.jsp";
		}else {
			ThesisInformation thesisInformation4Db = studentService.getInfoByStudentId(studentId);
			if(thesisInformation4Db ==null) {
				
			}else {
				String filePath = thesisInformation4Db.getThesisText();
				String[] str = filePath.split("\\\\");
				String fileName = str[str.length-1].toString();
				fileList.put(fileName, filePath);
			}
			
			model.addAttribute("fileList", fileList);
			return "student/studentResourcesDownload.jsp";
		}
	}
	
	@RequestMapping(value="/announcement")
	public String studentAnnouncement(Model model) {
		List<Announcement> list = studentService.showAllAnnouncement();
		SimpleDateFormat time=new SimpleDateFormat("yyyy-MM-dd"); 
		for(int i=0;i<list.size();i++) {
			Date time4db = list.get(i).getLastModifyTime();
			String formatTime = time.format(time4db);
			list.get(i).setTimeFormat(formatTime);
		}
		
		model.addAttribute("announcementList", list);
		
		return "student/studentAnnouncement.jsp";
	}
	
	@RequestMapping(value="/score")
	public String studentScore(HttpServletRequest request,Model model) {
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		StudentScore dbScore = teacherService.showInfoByStudentId(studentId);
		if(dbScore == null || "".equals(dbScore)) {
			model.addAttribute("message", "暂无成绩");
			return "student/main.jsp";
			
		}else {
			String studentName = teacherService.getStudentInfoByStudentId(studentId).getStudentName();
			int thesisId = teacherService.getTopicInfoByStudentId(studentId).getThesisId();
			String thesisName = teacherService.getThesisById(thesisId).getThesisName();
			int score = teacherService.showInfoByStudentId(studentId).getThesisResult();
			Student student = new Student();
			student.setStudentName(studentName);
			student.setThesisName(thesisName);
			student.setThesisScore(score);
			
			model.addAttribute("studentList", student);
			
			return "student/studentScore.jsp";
		}
		
	}
	
	@RequestMapping(value="/modifyInfoToDb",method=RequestMethod.POST)
	public String studentModifyInfoToDb(Model model,HttpServletRequest request,int id,String studentNo, String studentName,String sex,String majorOld,String major,String grade, String phone, String email) throws Exception {
		
		// 以下代码是学生修改学生信息
		int majorId = 0;
		majorOld = new String(majorOld.getBytes("iso-8859-1"),"utf-8");
		//departmentId =  departmentService.getIdByName(departmentOld);
		majorId = majorService.getIdByName(majorOld);
		studentNo = new String(studentNo.getBytes("iso-8859-1"),"utf-8");
		studentName = new String(studentName.getBytes("iso-8859-1"),"utf-8");
		grade = new String(grade.getBytes("iso-8859-1"),"utf-8");
		sex = new String(sex.getBytes("iso-8859-1"),"utf-8");
		User user = (User)request.getSession().getAttribute("currentUser");
		String inputMan = user.getUserNo();
		phone = new String(phone.getBytes("iso-8859-1"),"utf-8");
		email = new String(email.getBytes("iso-8859-1"),"utf-8");
		major = new String(major.getBytes("iso-8859-1"),"utf-8");
		Date currentTime = new Date();
		
		
		Student student = new Student();
		student.setId(id);
		student.setStudentNo(studentNo);
		student.setStudentName(studentName);
		
		if (major == null || "".equals(major)) {
			student.setMajorId(majorId);
		}else {
			student.setMajorId(Integer.parseInt(major));
		}
		student.setGrade(grade);
		student.setSex(sex);
		student.setInputMan(inputMan);
		student.setLastModifyTime(currentTime);
		student.setPhone(phone);
		student.setEmail(email);
		
		int num = studentService.updateStudent(student);
		System.out.println("修改学生数目："+num);
		
		// 根据 院系id 获得专业name
		int majId = student.getMajorId();
		String majorNameNew = majorService.getNameById(majId);
		student.setMajorName(majorNameNew);
		
		HttpSession session = request.getSession();
		session.setAttribute("student", student);
		
		return "student/main.jsp";
	}
	
	@RequestMapping(value="/getAllAvailableTopic")
	public void studentGetAllAvailableTopicForm(HttpServletResponse response,HttpServletRequest request) throws Exception {
		
		List<ThesisTitle> thesisList = studentService.availableTopic();
		response.setContentType("text/html;charset=UTF-8");
		PrintWriter write = response.getWriter();
		write.write(JSONArray.toJSONString(thesisList));
		write.close();
	}
	
	@RequestMapping(value="/selectTopic")
	public String studentSelectTopic(HttpServletResponse response,HttpServletRequest request,Model model,int id,int topic) throws Exception {
		
		/*System.out.println("id:"+id);
		System.out.println("topic:"+topic);*/
		Topic top = new Topic();
		top.setStudentId(id);
		top.setThesisId(topic);
		Date time = new Date();
		top.setSelectTime(time);
		
		int num = studentService.addTopicToDb(top);
		System.out.println("添加了"+num+"个选题");
		
		Student student = studentService.getStudentNameById(id);
		String studentNo = student.getStudentNo();
		
		ThesisTitle thesis = studentService.getThesisInfoByid(topic);
		String thesisName = thesis.getThesisName();
		
		
		StringBuffer sb = new StringBuffer();
		sb.append("学号为");
		sb.append(studentNo);
		sb.append("的学生，选择了");
		sb.append(thesisName);
		
		
		String infoMessage = sb.toString();
		
		this.realTimeTopicMessageOn = infoMessage;
		model.addAttribute("realTimeTopicMessage", realTimeTopicMessageOn);
		
		studentThesisResult(response, request, model);
		return "student/studentThesisResult.jsp";
	}
	
	@RequestMapping(value="/selectThesis")
	public String studentSelectThesis(HttpServletResponse response,HttpServletRequest request,Model model,int id,int thesis) throws Exception {
		
		/*System.out.println("id:"+id);
		System.out.println("topic:"+topic);*/
		Zhiyuan zhi = studentService.chosenZhiyuan(id);
		if(zhi == null || "".equals(zhi)) {
			Zhiyuan zhiyuan = new Zhiyuan();
			zhiyuan.setStudentId(id);
			zhiyuan.setThesisId(thesis);
			Date time = new Date();
			zhiyuan.setSelectTime(time);
			
			int num = studentService.addZhiyuanToDb(zhiyuan);
			System.out.println("添加了"+num+"个志愿");
			
			Student student = studentService.getStudentNameById(id);
			String studentNo = student.getStudentNo();
			
			ThesisTitle thesis1 = studentService.getThesisInfoByid(thesis);
			String thesisName = thesis1.getThesisName();
			
			
			StringBuffer sb = new StringBuffer();
			sb.append("学号为");
			sb.append(studentNo);
			sb.append("的学生，选择了");
			sb.append(thesisName);
			
			
			String infoMessage = sb.toString();
			
			this.realTimeTopicMessageOn = infoMessage;
			model.addAttribute("message", realTimeTopicMessageOn);
			
			studentThesisResult(response, request, model);
			return "student/main.jsp";
		}else {
			model.addAttribute("message", "已选择课题，不可再次选择");
			return "student/main.jsp";
		}
		
	}
	
	@RequestMapping(value="/deleteChosenTopic")
	public String studentDeleteChosenTopic(Model model,int studentId) throws Exception {
		
		// System.out.println(studentId);
		StudentTaskBookOpening stbo = studentService.getSTBOInfoById(studentId);
		if(stbo==null||"".equals(stbo)) {
			int num = studentService.deleteTopic(studentId); 
			System.out.println("成功退选 :"+num+"条数据");
			model.addAttribute("message", "成功退选");
			
			return "student/main.jsp";
		}else {
			model.addAttribute("message", "已上传开题报告，不可退选");
			return "student/main.jsp";
		}
	}
	
	@RequestMapping(value="/fileDownload")
	public ResponseEntity<byte[]> fileDownload(HttpServletRequest request, @RequestParam("filePath") String filePath,@RequestParam("fileName") String fileName, Model model) throws Exception {
		System.out.println(fileName);
		System.out.println(filePath);
		//fileName = new String(fileName.getBytes("iso-8859-1"),"utf-8");
		//filePath = new String(filePath.getBytes("iso-8859-1"),"utf-8");
		File file = new File(filePath);
		HttpHeaders headers = new HttpHeaders();
		String downloadFile = new String(fileName.getBytes("utf-8"), "iso-8859-1");
		headers.setContentDispositionFormData("attachment", downloadFile);
		headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
		return new ResponseEntity<byte[]>(FileUtils.readFileToByteArray(file),headers,HttpStatus.CREATED); 
	}
	
	@RequestMapping(value="/uploadTaskBook")
	public String studentUploadTaskBook(HttpServletRequest request, Model model,@RequestParam("file") MultipartFile file) throws Exception {
		
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		
		String studentIdToString = String.valueOf(studentId);
		
		if(!file.isEmpty()) {
			
			File fileRoot = new File("E:\\BSM\\student");
			File fileDb = new File(fileRoot, studentIdToString);
			String fileName = file.getOriginalFilename();
			
			File filePath = new File(fileDb, fileName);
			
			if(!filePath.getParentFile().exists()) {
				filePath.getParentFile().mkdirs();
			}
			
			file.transferTo(new File(fileDb+File.separator+fileName));
			
			int num = studentService.uploadTaskBook(studentId, filePath.toString());
			System.out.println("添加了"+num+"条信息");
			model.addAttribute("message", "上传任务书成功");
			return "student/main.jsp";
		}else {
			model.addAttribute("message", "上传任务书出错");
			return "error.jsp";
		}
	}
	
	@RequestMapping(value="/uploadOpening")
	public String studentUploadOpening(HttpServletRequest request, Model model,@RequestParam("file") MultipartFile file) throws Exception {
		
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		
		String studentIdToString = String.valueOf(studentId);
		
		Topic topic = studentService.chosenThesisTitle(studentId);
		if(topic == null || "".equals(topic)) {
			model.addAttribute("message", "无法上传开题报告");
			return "student/main.jsp";
		}else {
			if(!file.isEmpty()) {
				
				File fileRoot = new File("E:\\BSM\\student");
				File fileDb = new File(fileRoot, studentIdToString);
				String fileName = file.getOriginalFilename();
				
				File filePath = new File(fileDb, fileName);
				
				if(!filePath.getParentFile().exists()) {
					filePath.getParentFile().mkdirs();
				}
				
				file.transferTo(new File(fileDb+File.separator+fileName));
				
				int num = studentService.uploadOpening(studentId, filePath.toString());
				System.out.println("添加了"+num+"条信息");
				
				model.addAttribute("message", "上传开题报告成功");
				return "student/main.jsp";
			}else {
				model.addAttribute("message", "上传开题报告出错");
				return "student/main.jsp";
			}
		}
	}
	
	@RequestMapping(value="/uploadKexing")
	public String studentUploadKexing(HttpServletRequest request, Model model,@RequestParam("file") MultipartFile file) throws Exception {
		
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		
		String studentIdToString = String.valueOf(studentId);
		
		Topic topic = studentService.chosenThesisTitle(studentId);
		if(topic == null || "".equals(topic)) {
			model.addAttribute("message", "无法上传可行性分析报告");
			return "student/main.jsp";
		}else {
			if(!file.isEmpty()) {
				
				File fileRoot = new File("E:\\BSM\\student");
				File fileDb = new File(fileRoot, studentIdToString);
				String fileName = file.getOriginalFilename();
				
				File filePath = new File(fileDb, fileName);
				
				if(!filePath.getParentFile().exists()) {
					filePath.getParentFile().mkdirs();
				}
				
				file.transferTo(new File(fileDb+File.separator+fileName));
				
				int num = studentService.uploadKexing(studentId, filePath.toString());
				System.out.println("添加了"+num+"条信息");
				
				model.addAttribute("message", "上传可行性分析报告成功");
				return "student/main.jsp";
			}else {
				model.addAttribute("message", "上传可行性分析报告出错");
				return "student/main.jsp";
			}
		}
	}
	
	@RequestMapping(value="/uploadXuqiu")
	public String studentUploadXuqiu(HttpServletRequest request, Model model,@RequestParam("file") MultipartFile file) throws Exception {
		
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		
		String studentIdToString = String.valueOf(studentId);
		
		Topic topic = studentService.chosenThesisTitle(studentId);
		if(topic == null || "".equals(topic)) {
			model.addAttribute("message", "无法上传需求分析报告");
			return "student/main.jsp";
		}else {
			if(!file.isEmpty()) {
				
				File fileRoot = new File("E:\\BSM\\student");
				File fileDb = new File(fileRoot, studentIdToString);
				String fileName = file.getOriginalFilename();
				
				File filePath = new File(fileDb, fileName);
				
				if(!filePath.getParentFile().exists()) {
					filePath.getParentFile().mkdirs();
				}
				
				file.transferTo(new File(fileDb+File.separator+fileName));
				
				int num = studentService.uploadXuqiu(studentId, filePath.toString());
				System.out.println("添加了"+num+"条信息");
				
				model.addAttribute("message", "上传需求分析报告成功");
				return "student/main.jsp";
			}else {
				model.addAttribute("message", "上传需求分析报告出错");
				return "student/main.jsp";
			}
		}
	}
	
	@RequestMapping(value="/uploadGaiyao")
	public String studentUploadGaiyao(HttpServletRequest request, Model model,@RequestParam("file") MultipartFile file) throws Exception {
		
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		
		String studentIdToString = String.valueOf(studentId);
		
		Topic topic = studentService.chosenThesisTitle(studentId);
		if(topic == null || "".equals(topic)) {
			model.addAttribute("message", "无法上传概要设计报告");
			return "student/main.jsp";
		}else {
			if(!file.isEmpty()) {
				
				File fileRoot = new File("E:\\BSM\\student");
				File fileDb = new File(fileRoot, studentIdToString);
				String fileName = file.getOriginalFilename();
				
				File filePath = new File(fileDb, fileName);
				
				if(!filePath.getParentFile().exists()) {
					filePath.getParentFile().mkdirs();
				}
				
				file.transferTo(new File(fileDb+File.separator+fileName));
				
				int num = studentService.uploadGaiyao(studentId, filePath.toString());
				System.out.println("添加了"+num+"条信息");
				
				model.addAttribute("message", "上传概要设计报告成功");
				return "student/main.jsp";
			}else {
				model.addAttribute("message", "上传概要设计报告出错");
				return "student/main.jsp";
			}
		}
	}
	
	@RequestMapping(value="/uploadShujuku")
	public String studentUploadShujuku(HttpServletRequest request, Model model,@RequestParam("file") MultipartFile file) throws Exception {
		
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		
		String studentIdToString = String.valueOf(studentId);
		
		Topic topic = studentService.chosenThesisTitle(studentId);
		if(topic == null || "".equals(topic)) {
			model.addAttribute("message", "无法上传数据库设计报告");
			return "student/main.jsp";
		}else {
			if(!file.isEmpty()) {
				
				File fileRoot = new File("E:\\BSM\\student");
				File fileDb = new File(fileRoot, studentIdToString);
				String fileName = file.getOriginalFilename();
				
				File filePath = new File(fileDb, fileName);
				
				if(!filePath.getParentFile().exists()) {
					filePath.getParentFile().mkdirs();
				}
				
				file.transferTo(new File(fileDb+File.separator+fileName));
				
				int num = studentService.uploadShujuku(studentId, filePath.toString());
				System.out.println("添加了"+num+"条信息");
				
				model.addAttribute("message", "上传数据库设计报告成功");
				return "student/main.jsp";
			}else {
				model.addAttribute("message", "上传数据库设计报告出错");
				return "student/main.jsp";
			}
		}
	}
	
	@RequestMapping(value="/fileDelete")
	public String fileDelete(HttpServletRequest request,HttpServletResponse response, @RequestParam("filePath") String filePath,@RequestParam("fileName") String fileName, Model model) throws Exception {
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		
		request.setCharacterEncoding("utf-8");
		response.setCharacterEncoding("utf-8");
		fileName = new String(fileName.getBytes("iso-8859-1"),"utf-8");
		filePath = new String(filePath.getBytes("iso-8859-1"),"utf-8");
		File deleteFile = new File(filePath);
		String message = "";
		boolean flag = false;
		if(deleteFile.exists()) {
			flag = deleteFile.delete();
			if(flag ) {
				message = "删除成功";
			}else {
				message = "删除失败";
			}
			
		}else {
			message = "文件不存在";
		}
		
		ThesisInformation thesis = studentService.getInfoByFilePath(filePath);
		if(thesis== null || "".equals(thesis)) {
			
		}else {
			int num1 = studentService.deleteThesisInformation(studentId);
			System.out.println("成功删除论文文件");
		}
		
		StudentTaskBookOpening STBO = studentService.getInfoByTaskBookPath(filePath);
		if(STBO == null || "".equals(STBO)) {
			
		}else {
			int num = studentService.resetTaskBook(studentId);
			System.out.println("成功删除任务书");
		}
		
		StudentTaskBookOpening STBO2 = studentService.getInfoByOpeningPath(filePath);
		if(STBO2==null || "".equals(STBO2) ) {
			
		}else {
			int num = studentService.resetOpening(studentId);
			System.out.println("成功删除开题报告");
		}
		
		model.addAttribute("message", "成功删除一个文档");
	
		return "student/main.jsp";
	}
	
	@RequestMapping(value="/openingResult")
	public String studentOpeningResult(HttpServletRequest request,Model model) {
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		StudentTaskBookOpening STBO = studentService.getSTBOInfoById(studentId);
		if(STBO == null || "".equals(STBO)) {
			model.addAttribute("message", "尚未提交开题报告");
			return "student/studentOpeningResult.jsp";
		}else {
			int completion = STBO.getCompletion();
			if(completion == 0) {
				model.addAttribute("message", "你的开题报告还未审核，请耐心等待");
			}else if(completion == 1) {
				model.addAttribute("message", "你的开题报告未通过，请修改后重新提交");
			}else {
				model.addAttribute("message", "开题报告已通过");
			}
		}
		return "student/studentOpeningResult.jsp";
	}
	
	@RequestMapping(value="/wendangResult")
	public String studentwendangResult(HttpServletRequest request,Model model) {
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		StudentTaskBookOpening STBO = studentService.getSTBOInfoById(studentId);
		Map<String, String> wendangList = new HashMap<String, String>();
		wendangList.put("open", STBO.getOpenscore());
		wendangList.put("kexing", STBO.getKexingscore());
		wendangList.put("xuqiu", STBO.getXuqiuscore());
		wendangList.put("gaiyao", STBO.getGaiyaoscore());
		wendangList.put("shujuku", STBO.getShujukuscore());
/*		if(STBO == null || "".equals(STBO)) {
			model.addAttribute("message", "尚未提交开题报告");
			return "student/studentOpeningResult.jsp";
		}else {
			int completion = STBO.getCompletion();
			if(completion == 0) {
				model.addAttribute("message", "你的开题报告还未审核，请耐心等待");
			}else if(completion == 1) {
				model.addAttribute("message", "你的开题报告未通过，请修改后重新提交");
			}else {
				model.addAttribute("message", "开题报告已通过");
			}
		}*/
		System.out.println(wendangList);
		if(wendangList==null) {
			model.addAttribute("message", "还未提交任何文档");
		}
		model.addAttribute("wendangList", wendangList);
		return "student/studentWendangResult.jsp";
	}
	
	@RequestMapping(value="/getRealTimeTopic")
	public void getRealTimeTopic(HttpServletResponse response,HttpServletRequest request) throws Exception {
		String message = (String)request.getSession().getServletContext().getAttribute("realTimeTopicMessage");
		response.setContentType("text/html;charset=UTF-8");
		PrintWriter write = response.getWriter();
		write.write(JSONObject.toJSONString(message));
		write.close();
	}
	
	@RequestMapping(value="/uploadThesisInformation")
	public String studentUploadThesisInformation(HttpServletRequest request, Model model,@RequestParam("file") MultipartFile file) throws Exception {
		
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		
		String studentIdToString = String.valueOf(studentId);
		
		Topic topic = studentService.chosenThesisTitle(studentId);
		if(topic == null || "".equals(topic)) {
			model.addAttribute("message", "无法上传毕业论文");
			return "student/main.jsp";
		}else {
			
			StudentTaskBookOpening stbo  = studentService.getSTBOInfoById(studentId);
			if(stbo == null || "".equals(stbo)) {
				model.addAttribute("message", "开题报告还未上传或还未审核，无法上传");
				return "student/main.jsp";
			}else {
				int completion = stbo.getCompletion();
				if(completion == 2) {
					if(!file.isEmpty()) {
						
						File fileRoot = new File("E:\\BSM\\student");
						File fileDb = new File(fileRoot, studentIdToString);
						String fileName = file.getOriginalFilename();
						
						File filePath = new File(fileDb, fileName);
						
						if(!filePath.getParentFile().exists()) {
							filePath.getParentFile().mkdirs();
						}
						
						file.transferTo(new File(fileDb+File.separator+fileName));
						
						int num = studentService.uploadThesisInformation(studentId, filePath.toString());
						System.out.println("添加了"+num+"条信息");
						
						model.addAttribute("message", "上传论文成功");
						return "student/main.jsp";
					}else {
						model.addAttribute("message", "上传论文出错");
						return "student/main.jsp";
					}
					
				}else {
					
					model.addAttribute("message", "开题报告还未上传或还未审核，无法上传");
					return "student/main.jsp";
					
				}
				
				
				
			}
			}
			
			
	}
	
	
	@RequestMapping(value="/qualification")
	public String studentQualification(HttpServletRequest request,Model model) {
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		
		ThesisInformation thesis = studentService.getThesisInforInfoByStudentId(studentId);
		
		if(thesis == null || "".equals(thesis)) {
			model.addAttribute("message", "不具备答辩资格");
		}else {
			int status = thesis.getStatus();
			if(status == 0) {
				model.addAttribute("message", "不具备答辩资格");
			}else if(status == 1) {
				model.addAttribute("message", "不具备答辩资格");
			}else {
				model.addAttribute("message", "你已具备答辩资格");
			}
			
		}
		return "student/studentQualifications.jsp";
	}
	
	
	@RequestMapping(value="/studentDoubt")
	public String studentDoubtForm() {
		return "student/studentDoubt.jsp";
	}
	
	@RequestMapping(value="/studentDoubtList")
	public String studentDoubtListForm(Model model,HttpServletRequest request) {
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		List<Doubt> doubtList = studentService.getAllDoubtByStudent(studentId);
		for(int i= 0;i<doubtList.size();i++) {
			String answer = doubtList.get(i).getAnswer();
			if(answer == null || "".equals(answer)) {
				doubtList.get(i).setAnswer("教师还未做出解答");
			}
		}
		model.addAttribute("doubtList", doubtList);
		return "student/studentDoubtList.jsp";
	}
	
	@RequestMapping(value="/studentDoubtToDb")
	public String studentDoubtToDb(Model model,String doubt,HttpServletRequest request) throws Exception {
		Student currentUser = (Student)request.getSession().getAttribute("student");
		int studentId = currentUser.getId();
		doubt = new String(doubt.getBytes("iso-8859-1"),"utf-8");
		Doubt d = new Doubt();
		d.setStudentId(studentId);
		d.setStudentDoubt(doubt);
		studentService.addDoubt(d);
		model.addAttribute("message", "添加疑问成功");
		return "student/main.jsp";
	}
	
	@RequestMapping(value="/getThesisDescById")
	public void getThesisDescById(Model model,int topicId,HttpServletResponse response) throws Exception {
		String description = studentService.getThesisDesc(topicId);
		Map<String, String> map = new HashMap<String, String>();
		map.put("desc", description);
		response.setContentType("text/html;charset=UTF-8");
		PrintWriter write = response.getWriter();
		write.write(JSONObject.toJSONString(map));
		write.close();
	}
}

七. 项目总结

通过对毕业设计管理系统的开发，让我深刻明白开发一个程序软件需要经历的流程，当确定要开发一个系统的时候，对其功能进行合理的需求分析，然后才是程序软件的功能的框架设计，数据库的实体与数据表设计，程序软件的功能详细界面实现，以及程序的功能测试等进行全方位的细致考虑，虽然在此过程中，各个环节都遇到了大大小小的困难，但是通过对这些问题进行反复的分析，深入的思考，借助各种相关文献资料提供的方法与解决思路成功解决面临的各个问题，最后成功的让系统得以正常运行。商毕业设计管理系统在功能上面是基本可以满足用户对系统的操作，但是这个程序软件也有许多方面是不足的，因此，在下一个时间阶段，有几点需要改进的地方需要提出来，它们分别是：

（1）操作页面可以满足用户简易操作的要求，但是在页面多样化设计层面上需要把一些比较丰富的设计结构考虑进来。

（2）程序软件的总体安全性能需要优化，例如程序的退出安全性，以及程序的并发性等问题都需要进行安全性升级。

（3）需要对程序的数据结构方面，程序的代码方面等进行优化，让运行起来的程序可以保持稳定运行，也让程序能够保证短时间内处理相关事务，节省处理事务的时间，提高事务处理的效率，同时对服务器上资源占用的比例进行降低。

   

八. 源码获取

想要源码的小伙伴，大家点赞、收藏、关注、评论啦。谢谢各位大大。

源码下载