源码获取：博客首页 "资源" 里下载！
基于B/S架构的课程在线学习与测试系统
启动说明
项目为maven管理，最近集成了redis，所以在运行项目是先要下载redis并启动客户端，方可正常运行项目，由于只需要下载redis，无需其他配置，这里就不做过多说明。
最近更新
集成redis来保存用户登录信息，添加过滤器重置用户登录有效期。拦截器实现统一登录和权限校验（相关重构还未完成）。
修改配置文件：com.bs.commonn.RedisPool 地址、端口号
pool = new JedisPool(config,"127.0.0.1",6379,1000*2);
修改数据库配置文件，导入项目bs.sql文件
学生账号测试：lwj 123456
教师测试账号：lwj 123456
管理员测试账号：admin admin
项目采用前后端分离技术实现
***
- 框架：SSM（Spring，SpringMVC，Mybatis）
- 缓存：redis
- 数据库：MySQL
- IDE：Intellij IDEA/Eclipse
- 其他：Maven，Git
项目亮点
***
1. 前后端分离。
1. 用户登录权限区分和控制。
1. 防止横向越权和纵向越权。
1. 密码MD5明文加密。
1. 设计高复用的服务器响应对象。
1. guava缓存。
1. pojo，vo抽象模型。
1. 数据绑定对象。
1. Mybatis分页
1. Bootstrap。
1. artTemplate，artDialog，iframe前端模板使用。
1. select2、toastr、sweetalert等等前端插件的使用。
1. redis缓存。
1. 全局异常处理，拦截器权限统一检验。
班级管理控制层：
@Controller
@SuppressWarnings("all")
public class ClassInfoHandler {
@Autowired
private ClassInfoService classInfoService;
@Autowired
private GradeInfoService gradeInfoService;
@Autowired
private TeacherInfoService teacherInfoService;
@Autowired
private TeacherInfo teacher;
@Autowired
private ClassInfo classInfo;
@Autowired
private Gson gson;
private Logger logger = Logger.getLogger(ClassInfoHandler.class);
/**
* 获取所有班级
*
* @param gradeId
* 系部编号
* @param className
* 班级名称 可用于模糊查询
* @param classId
* 班级编号
* @return
*/
@RequestMapping(value = "/classes", method = RequestMethod.GET)
public ModelAndView getClasses(@RequestParam(value = "gradeId", required = false) Integer gradeId,
@RequestParam(value = "className", required = false) String className,
@RequestParam(value = "classId", required = false) Integer classId) {
ModelAndView model = new ModelAndView();
ClassInfo classInfo = new ClassInfo();
/* 处理查询条件 */
if (gradeId != null) {
GradeInfo gradeInfo = new GradeInfo();
gradeInfo.setGradeId(gradeId);
classInfo.setGrade(gradeInfo);
}
if (classId != null)
classInfo.setClassId(classId);
if (className != null) {
if (className.trim() != "")
classInfo.setClassName(className);
}
List<ClassInfo> classes = classInfoService.getClasses(classInfo);
model.setViewName("admin/clazz/classes");
model.addObject("classes", classes);
return model;
}
/**
* 预添加班级处理
*
* @return
*/
@RequestMapping("/preAddClass")
public ModelAndView preAddClass(@RequestParam(name = "gid",required = false,defaultValue = "")Integer gid) {
ModelAndView model = new ModelAndView();
// 获取系部信息
List<GradeInfo> grades = gradeInfoService.getGrades();
model.setViewName("admin/clazz/classedit");
model.addObject("grades", grades);
// 获取不是班主任的教师
teacher.setIsWork(0);
Map<String, Object> map = new HashMap<String, Object>();
map.put("startIndex", null);
map.put("pageShow", null);
map.put("teacher", teacher);
List<TeacherInfo> teachers = teacherInfoService.getTeachers(map);
model.addObject("teachers", teachers);
model.addObject("editClass", new ClassInfo());
model.addObject("gid",gid);
return model;
}
/**
* 添加班级
*
* @param classInfo
* 班级信息
* @param request
* @return
*/
@RequestMapping(value = "/class", method = RequestMethod.POST)
public String isAddClass(ClassInfo classInfo, HttpServletRequest request) {
//判断班级名是否存在
ClassInfo byClassName = classInfoService.findByClassName(classInfo.getClassName());
if(byClassName!=null){
request.setAttribute("error", "该班级名称已存在！");
return "error";
}
// 修改教师班主任状态
String returnMsg = isChangeTeacherWork(1, classInfo.getTeacher().getTeacherId());
if (returnMsg != null) {
request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
return "error";
}
// 添加
int row = classInfoService.isAddClass(classInfo);
if (row < 1) {
request.setAttribute("error", "班级 " + classInfo.getClassName() + " 添加失败，请稍后再试！");
return "error";
}
return "redirect:/classes";
}
/**
* 删除班级
*
* @param classId
* 班级编号
* @param request
* @return
*/
@RequestMapping(value = "/del/class/{classId}", method = RequestMethod.DELETE)
public String isDelClass(@PathVariable("classId") Integer classId, HttpServletRequest request) {
logger.info("删除班级 " + classId);
// 将删除班级对于之前班主任改为 非班主任状态
// 需要在删除班级之前修改，如果先删除了班级，再根据班级获取教师编号，就不能获取
ClassInfo delClass = classInfoService.getClassById(classId);
String returnMsg = isChangeTeacherWork(0, delClass.getTeacher().getTeacherId());
if (returnMsg != null) {
request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
return "error";
}
// 删除
int row = classInfoService.isDelClass(classId);
if (row < 1) {
logger.error("班级 " + classId + " 删除失败");
request.setAttribute("error", "班级删除失败，请稍后再试！");
return "../error";
}
return "redirect:/classes";
}
/**
* 预修改班级处理
*
* @param classId
* 班级编号
* @return
*/
@RequestMapping(value = "edit/class/{classId}", method = RequestMethod.GET)
public ModelAndView preUpdateClass(@PathVariable("classId") Integer classId) {
logger.info("预修改班级处理");
ModelAndView model = new ModelAndView();
// 获取要修改班级
ClassInfo classInfo = classInfoService.getClassById(classId);
model.setViewName("/admin/clazz/classedit");
model.addObject("editClass", classInfo);
List<GradeInfo> grades = gradeInfoService.getGrades();
// 获取不是班主任的教师
teacher.setIsWork(0);
Map<String, Object> map = new HashMap<String, Object>();
map.put("startIndex", null);
map.put("pageShow", null);
map.put("teacher", teacher);
List<TeacherInfo> teachers = teacherInfoService.getTeachers(map);
// 如果没有可用班主任
if (teachers.size() == 0 || teachers == null) {
teacher.setTeacherId(classInfo.getTeacher().getTeacherId());
teacher.setTeacherName("暂无剩余教师");
teachers.add(teacher);
}
model.addObject("teachers", teachers);
model.addObject("grades", grades);
return model;
}
/**
* 修改班级信息
*
* @param classInfo
* 班级信息
* @param request
* @param lastTeacherId
* 上一个班主任编号，修改其 班主任状态
* @return
*/
@RequestMapping(value = "edit/class/class", method = RequestMethod.POST)
public String isUpdateClass(ClassInfo classInfo, HttpServletRequest request,
@RequestParam(value = "lastTeacher", required = false) Integer lastTeacherId) {
ClassInfo byClassName = classInfoService.findByClassName(classInfo.getClassName());
if(byClassName!=null){
if(!byClassName.getClassId().equals(classInfo.getClassId())){
request.setAttribute("error", "该班级名称已存在！");
return "../../error";
}
}
// 修改上一教师不为班主任状态
if (lastTeacherId != null) {
String returnMsg = isChangeTeacherWork(0, lastTeacherId);
if (returnMsg != null) {
request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
return "../error";
}
}
// 修改当前教师为班主任状态
String returnMsg = isChangeTeacherWork(1, classInfo.getTeacher().getTeacherId());
if (returnMsg != null) {
request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
return "../error";
}
int row = classInfoService.isUpdateClass(classInfo);
if (row < 1) {
logger.error("班级 " + classInfo + " 修改失败");
request.setAttribute("error", "班级修改失败，请稍后再试！");
return "../error";
}
return "redirect:/classes";
}
/**
* 获取指定系部下的班级
*
* @param gradeId
* 系部编号
* @param response
* @throws IOException
*/
@RequestMapping(value = "/gradeclass/{gradeId}", method = RequestMethod.GET)
public void getClassesByGradeId(@PathVariable("gradeId") Integer gradeId, HttpServletResponse response)
throws IOException {
List<ClassInfo> classes = classInfoService.getClassByGradeId(gradeId);
String json = gson.toJson(classes);
response.getWriter().print(json);
}
/**
* 修改教师(班主任)工作状态
*
* @param status
* 是否为班主任标识
* @param teacherId
* 教师编号
*/
private String isChangeTeacherWork(int status, Integer teacherId) {
teacher.setIsWork(status);
if (teacherId == null) {
logger.error("修改教师班主任状态 对应教师编号有误");
return "修改教师班主任状态 对应教师编号有误";
}
teacher.setTeacherId(teacherId);
int row = teacherInfoService.updateTeacherIsWork(teacher);
return null;
}
@RequestMapping("/stuCount")
public void getStudentCountForClass(@RequestParam(value = "gradeId", required = false) Integer gradeId,
HttpServletResponse response) throws IOException {
Map<String, Object> map = classInfoService.getStudentCountForClass(gradeId);
String json = StudentCount.createBarJson(map);
response.getWriter().print(json);
}
/**
* 预添加班级处理
*
* @return
*/
@RequestMapping("/preStudentCount")
public ModelAndView preStudentCount() {
ModelAndView model = new ModelAndView();
// 获取系部信息
List<GradeInfo> grades = gradeInfoService.getGrades();
model.setViewName("admin/charts/studentCount");
model.addObject("grades", grades);
return model;
}
}
教师管理控制层：
@Controller
@SuppressWarnings("all")
public class TeacherInfoHandler {
@Autowired
private TeacherInfoService teacherInfoService;
private Logger logger = Logger.getLogger(TeacherInfoHandler.class);
/**
* 获取 验证教师信息
*
* @param teacherAccount
* @param response
* @throws Exception
*/
@RequestMapping(value = "/validateTeacher", method = RequestMethod.POST)
public void queryTeacherExists(@RequestParam(value = "account") String teacherAccount, HttpServletResponse response)
throws Exception {
logger.info("获取教师 " + teacherAccount + " 的信息");
TeacherInfo teacherInfo = null;
teacherInfo = teacherInfoService.getTeacherByAccount(teacherAccount);
// 教师账户不存在
if (teacherInfo == null) {
response.getWriter().print("1");
} else {
response.getWriter().print(teacherInfo.getTeacherPwd());
}
}
/**
* 教师登录
*
* @param teacherAccount
* @param request
* @return
*/
@RequestMapping(value = "/teacherlogin", method = RequestMethod.POST)
public String teacherLogin(@RequestParam("teacherAccount") String teacherAccount, HttpServletRequest request) {
if (teacherAccount == null || "".equals(teacherAccount)) {
logger.error("教师账号为空");
request.setAttribute("error", "登录信息有误");
return "/error";
}
logger.info("教师 " + teacherAccount + " 登录");
// 获取当前登录教师
TeacherInfo teacherInfo = teacherInfoService.getTeacherByAccount(teacherAccount);
if (teacherInfo == null) {
logger.error("教师账号为空");
request.setAttribute("error", "账号不存在！");
return "/error";
}
String teacherPwd = request.getParameter("teacherPwd");
if (!teacherInfo.getTeacherPwd().equals(teacherPwd)) {
logger.error("密码错误");
request.setAttribute("error", "密码错误！");
return "/error";
}
// 将当前登录教师 后台权限存入 Session
request.getSession().setAttribute("adminPower", teacherInfo.getAdminPower());
request.getSession().setAttribute("loginTeacher", teacherInfo);
return "redirect:admin/index.jsp";
}
/**
* 教师查看自己的信息
*
* @param teacherId
* @return
*/
@RequestMapping("/selfinfo/{teacherId}")
public ModelAndView loginTeacherSelf(@PathVariable("teacherId") Integer teacherId) {
ModelAndView model = new ModelAndView();
logger.error("教师 " + teacherId + " 查看自己的信息");
if (teacherId == null) {
model.setViewName("../error");
return model;
} else {
List<TeacherInfo> teachers = new ArrayList<TeacherInfo>();
TeacherInfo teacher = teacherInfoService.getTeacherById(teacherId);
teachers.add(teacher);
model.addObject("teachers", teachers);
model.setViewName("/admin/teacher/teachers");
return model;
}
}
/**
* 教师退出登录
*
* @throws IOException
*/
@RequestMapping("/exitTeacher")
public void exitTeacher(HttpSession session, HttpServletResponse response) throws IOException {
session.removeAttribute("loginTeacher");
session.removeAttribute("adminPower");
response.sendRedirect("admin/login.jsp");
}
/**
* 查询教师集合
*
* @param startPage
* @param pageShow
* @return
*/
@RequestMapping(value = "/teachers", method = RequestMethod.GET)
public ModelAndView getTeachers(
@RequestParam(value = "startPage", required = false, defaultValue = "1") Integer startPage, // 当前页码,默认第一页
@RequestParam(value = "pageShow", required = false, defaultValue = "10") Integer pageShow /*
* 每页显示数据量
* ，
* 默认10条
*/) {
logger.info("查询教师集合");
ModelAndView model = new ModelAndView();
model.setViewName("admin/teacher/teachers");
List<TeacherInfo> teachers;
Map<String, Object> map = new HashMap<String, Object>();
// 计算当前查询起始数据索引
int startIndex = (startPage - 1) * pageShow;
map.put("startIndex", startIndex);
map.put("pageShow", pageShow);
map.put("teacher", null);
teachers = teacherInfoService.getTeachers(map);
model.addObject("teachers", teachers);
// 获取教师总量
int teacherTotal = teacherInfoService.getTeacherTotal();
// 计算总页数
int pageTotal = 1;
if (teacherTotal % pageShow == 0)
pageTotal = teacherTotal / pageShow;
else
pageTotal = teacherTotal / pageShow + 1;
model.addObject("pageTotal", pageTotal);
model.addObject("pageNow", startPage);
return model;
}
/**
* 预修改教师
*
* @param teacherId
* @return
*/
@RequestMapping(value = "/teacher/{teacherId}", method = RequestMethod.GET)
public ModelAndView preUpdateTeacher(@PathVariable("teacherId") Integer teacherId) {
logger.info("预修改教师处理");
ModelAndView model = new ModelAndView();
// 获取要修改教师
TeacherInfo teacher = teacherInfoService.getTeacherById(teacherId);
model.setViewName("/admin/teacher/teacheredit");
model.addObject("teacher", teacher);
return model;
}
/**
* 修改/添加 教师
*
* @param teacherId
* @param isUpdate
* 操作标识
* @param teacherName
* @param teacherAccount
* @param teacherPwd
* @param adminPower
* @return
*/
@RequestMapping(value = "/teacher/teacher", method = RequestMethod.POST)
public String isUpdateOrAddTeacher(@RequestParam(value = "teacherId", required = false) Integer teacherId,
@RequestParam(value = "isupdate", required = false) Integer isUpdate,
@RequestParam("teacherName") String teacherName, @RequestParam("teacherAccount") String teacherAccount,
@RequestParam("teacherPwd") String teacherPwd, @RequestParam("adminPower") Integer adminPower) {
TeacherInfo teacher = new TeacherInfo();
teacher.setTeacherId(teacherId);
teacher.setTeacherName(teacherName);
teacher.setTeacherAccount(teacherAccount);
teacher.setTeacherPwd(teacherPwd);
teacher.setAdminPower(adminPower);
if (isUpdate != null) { // 修改
logger.info("修改教师 " + teacher + " 的信息");
int row = teacherInfoService.isUpdateTeacherInfo(teacher);
} else { // 添加
logger.info("添加教师 " + teacher + " 的信息");
int row = teacherInfoService.isAddTeacherInfo(teacher);
}
return "redirect:/teachers";
}
/**
* 删除教师
*
* @param teacherId
* @return
*/
@RequestMapping(value = "/teacher/{teacherId}", method = RequestMethod.DELETE)
public String isDelTeacher(@PathVariable("teacherId") Integer teacherId) {
logger.info("删除教师 " + teacherId);
int row = teacherInfoService.isDelTeacherInfo(teacherId);
return "redirect:/teachers";
}
}
学生管理控制层：
@Controller
@SuppressWarnings("all")
public class StudentInfoHandler {
@Autowired
private StudentInfoService studentInfoService;
@Autowired
private ClassInfoService classInfoService;
@Autowired
private ExamSubjectMiddleInfoService examSubjectMiddleInfoService;
@Autowired
private ExamHistoryPaperService examHistoryPaperService;
@Autowired
private ExamChooseInfoService examChooseInfoService;
@Autowired
private ExamSubjectMiddleInfo esm;
@Autowired
private ClassInfo classInfo;
@Autowired
private ExamPaperInfo examPaper;
@Autowired
private GradeInfo grade;
@Autowired
private StudentInfo student;
@Autowired
private ExamPaperInfoService examPaperInfoService;
private Logger logger = Logger.getLogger(StudentInfoHandler.class);
/**
* 获取学生集合
* @param studentId 学生编号
* @param classId 班级编号
* @param gradeId 系部编号
* @param startPage 起始页 default=1
* @param pageShow 页容量 default=10
* @return
*/
@RequestMapping("/students")
public ModelAndView getCourses(@RequestParam(value = "studentId", required = false) Integer studentId,
@RequestParam(value = "classId", required = false) Integer classId,
@RequestParam(value = "gradeId", required = false) Integer gradeId,
@RequestParam(value="startPage", required=false, defaultValue="1") Integer startPage,
@RequestParam(value="pageShow", required=false, defaultValue="10") Integer pageShow ) {
logger.info("获取学生集合 classId="+classId+", gradeId="+gradeId+", startPage="+startPage+", pageShow="+pageShow);
ModelAndView model = new ModelAndView();
model.setViewName("/admin/student/students");
//查询条件处理
StudentInfo student = new StudentInfo();
if (studentId != null)
student.setStudentId(studentId);
if (classId != null) {
classInfo.setClassId(classId);
student.setClassInfo(classInfo);
}
if (gradeId != null) {
grade.setGradeId(gradeId);
student.setGrade(grade);
}
Map<String, Object> map = new HashMap<String, Object>();
//计算当前查询起始数据索引
int startIndex = (startPage-1) * pageShow;
map.put("student", student);
map.put("startIndex", startIndex);
map.put("pageShow", pageShow);
List<StudentInfo> students = studentInfoService.getStudents(map);
model.addObject("students", students);
//获取学生总量
int studentTotal = studentInfoService.getStudentTotal();
//计算总页数
int pageTotal = 1;
if (studentTotal % pageShow == 0)
pageTotal = studentTotal / pageShow;
else
pageTotal = studentTotal / pageShow + 1;
model.addObject("pageTotal", pageTotal);
model.addObject("pageNow", startPage);
return model;
}
/**
* 根据编号获取学生信息
* @param studentId
* @return
*/
@RequestMapping("/student/{studentId}")
public ModelAndView getCourseById(@PathVariable("studentId") Integer studentId) {
logger.info("获取学生 " + studentId);
ModelAndView model = new ModelAndView();
model.setViewName("/admin/student/studentedit");
StudentInfo student = studentInfoService.getStudentById(studentId);
model.addObject("student", student);
List<ClassInfo> classes = classInfoService.getClasses(null);
model.addObject("classes", classes);
return model;
}
/**
* 添加/修改学生信息
* @param studentId
* @param isUpdate 操作标识
* @param studentName
* @param studentAccount
* @param studentPwd
* @param classId
* @return
*/
@RequestMapping(value = "/student/student", method = RequestMethod.POST)
public String isUpdateOrAddCourse(
@RequestParam(value = "studentId", required = false) Integer studentId,
@RequestParam(value = "isupdate", required = false) Integer isUpdate,
@RequestParam(value = "studentName", required = false) String studentName,
@RequestParam("studentAccount") String studentAccount,
@RequestParam("studentPwd") String studentPwd,
@RequestParam("classId") Integer classId) {
StudentInfo student = new StudentInfo();
student.setStudentId(studentId);
student.setStudentName(studentName);
student.setStudentAccount(studentAccount);
student.setStudentPwd(studentPwd);
classInfo.setClassId(classId);
student.setClassInfo(classInfo);
if (isUpdate != null) {
logger.info("修改学生 " + student + " 的信息");
int row = studentInfoService.isUpdateStudent(student);
} else {
logger.info("添加学生 " + student + " 的信息");
int row = studentInfoService.isAddStudent(student);
}
return "redirect:/students";
}
/**
* 删除学生
* @param studentId
* @return
*/
@RequestMapping(value = "/student/{studentId}", method = RequestMethod.DELETE)
public String isDelTeacher(@PathVariable("studentId") Integer studentId) {
logger.info("删除学生 " + studentId);
int row = studentInfoService.isDelStudent(studentId);
return "redirect:/students";
}
/**
* 预添加学生
* @return
*/
@RequestMapping("/preAddStudent")
public ModelAndView preAddStudent() {
logger.info("预添加学生信息");
ModelAndView model = new ModelAndView();
model.setViewName("/admin/student/studentedit");
List<ClassInfo> classes = classInfoService.getClasses(null);
model.addObject("classes", classes);
return model;
}
/**
* 学生考试登录验证
*
* 此处验证并不合理 登录验证实现如下：
* 前台学生登录传入账户，后台根据账户获取学生密码
* 返回学生密码，前台登录焦点离开密码框使用 JavaScript 判断
*
* @param studentAccount 学生登录账户
* @param response
* @throws IOException
*/
@RequestMapping("/validateLoginStudent")
public void validateLoginStudent(@RequestParam("studentAccount") String studentAccount,
HttpServletResponse response) throws IOException {
logger.info("学生账户 "+studentAccount+"，尝试登录考试");
//获取需要登录的学生对象
StudentInfo student = studentInfoService.getStudentByAccountAndPwd(studentAccount);
if (student == null) {
logger.error("登录学生账户 "+studentAccount+" 不存在");
response.getWriter().print("n");
} else {
logger.error("登录学生账户 "+studentAccount+" 存在");
response.getWriter().print(student.getStudentPwd());
}
}
/**
* 学生登录考试
* @param student 登录学生
* @param request
* @return
*/
@RequestMapping(value="/studentLogin", method=RequestMethod.POST)
public ModelAndView studentLogin(StudentInfo student, HttpServletRequest request) {
ModelAndView model = new ModelAndView();
StudentInfo loginStudent = studentInfoService.getStudentByAccountAndPwd(student.getStudentAccount());
logger.info("学生 "+loginStudent+" 有效登录");
if(loginStudent == null || !student.getStudentPwd().equals(loginStudent.getStudentPwd())){
model.setViewName("reception/suc");
model.addObject("success", "密码错误");
return model;
}
request.getSession().setAttribute("loginStudent", loginStudent);
model.setViewName("reception/suc");
model.addObject("success", "登录成功");
return model;
}
/**
* 退出登录
* @param session
* @return
*/
@RequestMapping("/exit")
public String studentClearLogin(HttpSession session) {
StudentInfo studnet = (StudentInfo) session.getAttribute("loginStudent");
logger.info("学生 "+studnet.getStudentName()+", 编号 "+studnet.getStudentId()+" 退出登录");
session.removeAttribute("loginStudent");
return "redirect:index.jsp";
}
/**
* 学生注册 验证当前账户是否被占用
* @param studentAccount 注册账户
* @param response
* @throws IOException
*/
@RequestMapping("/validateAccount")
public void validateRegisterAccount(@RequestParam("studentAccount") String studentAccount,
HttpServletResponse response) throws IOException {
logger.info("验证学生账户 "+studentAccount+"，是否已被注册");
StudentInfo student = studentInfoService.getStudentByAccountAndPwd(studentAccount);
if (student == null) {
logger.error("注册学生账户 "+studentAccount+" 可以注册");
response.getWriter().print("t");
} else {
logger.error("注册学生账户 "+studentAccount+" 已被注册");
response.getWriter().print("f");
}
}
/**
* 学生注册
* @param studentName
* @param studentAccount
* @param studentPwd
* @param classId
* @param response
* @throws IOException
*/
@RequestMapping(value="/studentReg", method=RequestMethod.POST)
public void studentRegister(
@RequestParam("name") String studentName,
@RequestParam("account") String studentAccount,
@RequestParam("pwd") String studentPwd,
@RequestParam("classId") Integer classId,
HttpServletResponse response) throws IOException {
ModelAndView model = new ModelAndView();
student.setStudentName(studentName);
student.setStudentAccount(studentAccount);
student.setStudentPwd(studentPwd);
classInfo.setClassId(classId);
student.setClassInfo(classInfo);
logger.info("学生注册 "+student);
int row = studentInfoService.isAddStudent(student);
response.getWriter().print("t");
}
/**
* 预注册
* @return
*/
@RequestMapping("/preStudentReg")
public ModelAndView preStudentReg() {
ModelAndView model = new ModelAndView();
model.setViewName("reception/register");
model.addObject("classs", classInfoService.getClasses(null));
return model;
}
/**
* 学生进入考试
* @param classId 班级编号
* @param examPaperId 试卷编号
* @param studentId 考生编号
* @param examTime 考试时间
* @param beginTime 考试开始时间
* @param gradeId 系部编号
* @param session
* @return
*/
@RequestMapping("/begin")
public ModelAndView beginExam(
@RequestParam("classId") Integer classId,
@RequestParam("examPaperId") Integer examPaperId,
@RequestParam(value="studentId", required=false) Integer studentId,
@RequestParam("examTime") Integer examTime,
@RequestParam("beginTime") String beginTime,
@RequestParam("gradeId") Integer gradeId,
HttpSession session) {
ModelAndView model = new ModelAndView();
/*
* 查询该考试当前进入的试卷是否已经在历史记录中存在
* 如果存在，则不能再次进入考试； 反之进入考试
*/
Map<String, Object> map = new HashMap<String, Object>();
map.put("studentId", studentId);
map.put("examPaperId", examPaperId);
int count = examHistoryPaperService.getHistoryInfoWithIds(map);
if(session.getAttribute("loginStudent") == null) {
model.addObject("error", "请先登录后再操作");
model.setViewName("error");
return model;
} else if (count >= 1) {
model.addObject("error", "不能重复考试");
model.setViewName("error");
return model;
} else {
logger.info("学生 "+studentId+" 进入考试 班级 "+classId+" 试卷 "+examPaperId);
model.setViewName("/reception/exam");
ExamPaperInfo examPaper = new ExamPaperInfo();
examPaper.setExamPaperId(examPaperId);
esm.setExamPaper(examPaper);
//获取试卷 试题集合
List<ExamSubjectMiddleInfo> esms = examSubjectMiddleInfoService.getExamPaperWithSubject(esm);
logger.info("考试试题总量 "+esms.size());
//获取当前考生在当前试卷中已选答案记录
Map<String, Object> choosedMap = new HashMap<String, Object>();
choosedMap.put("studentId", studentId);
choosedMap.put("examPaperId", examPaperId);
List<ExamChooseInfo> chooses = examChooseInfoService.getChooseInfoWithSumScore(choosedMap);
if (chooses == null || chooses.size() == 0) {
model.addObject("chooses", null);
} else {
model.addObject("chooses", chooses);
}
model.addObject("esms", esms);
model.addObject("sumSubject", esms.size());
model.addObject("examPaperId", examPaperId);
model.addObject("examTime", examTime);
model.addObject("beginTime", beginTime);
model.addObject("classId", classId);
model.addObject("gradeId", gradeId);
return model;
}
}
/**
* 获取学生历史考试记录
* @param studentId 学生编号
* @return
*/
@RequestMapping("/history/{studentId}")
public ModelAndView getExamHistoryInfo(@PathVariable("studentId") Integer studentId) {
ModelAndView model = new ModelAndView();
if (studentId == null) {
logger.error("学生编号 为空");
model.setViewName("error");
return model;
}
logger.info("学生 "+studentId+" 获取考试历史记录");
//获取历史考试信息记录集合
List<ExamHistoryPaper> ehps = examHistoryPaperService.getExamHistoryToStudent(studentId);
model.addObject("ehps", ehps);
model.setViewName("/reception/examHistory");
return model;
}
/**
* 考生提交考试
* @param studentId
* @param examPaperId
* @param classId
* @param gradeId
* @return
*/
@RequestMapping(value="/submit", method={RequestMethod.POST, RequestMethod.GET})
public String examSubmit(
@RequestParam("studentId") Integer studentId,
@RequestParam("examPaperId") Integer examPaperId,
@RequestParam("classId") Integer classId,
@RequestParam("gradeId") Integer gradeId) {
logger.info("学生 "+studentId+" 提交了试卷 "+examPaperId);
//获取当前学生当前试卷所选择的全部答案
Map<String, Object> map = new HashMap<String, Object>();
map.put("studentId", studentId);
map.put("examPaperId", examPaperId);
List<ExamChooseInfo> chooses = examChooseInfoService.getChooseInfoWithSumScore(map);
logger.info("学生 "+studentId+" 共选择了 "+chooses.size()+" 道题");
//总分记录
int sumScore = 0;
for (ExamChooseInfo choose : chooses) {
SubjectInfo subject = choose.getSubject();
String chooseResult = choose.getChooseResult();
String rightResult = subject.getRightResult();
if (chooseResult.equals(rightResult)) { //答案正确
sumScore += subject.getSubjectScore();
logger.info("学生 "+studentId+" 第 "+subject.getSubjectId()+" 选择正确答案 "+chooseResult+" 当前总分 "+sumScore);
} else {
logger.info("学生 "+studentId+" 第 "+subject.getSubjectId()+" 答案选择错误 "+chooseResult+" 正确答案为 "+rightResult+" 当前总分 "+sumScore);
}
}
/*
* 首先判断当前记录是否已经添加过
* 防止当前学生点击提交后，系统倒计时再次进行提交
*/
int count = examHistoryPaperService.getHistoryInfoWithIds(map);
if (count == 0) {
//添加到历史记录
map.put("examScore", sumScore);
int row = examHistoryPaperService.isAddExamHistory(map);
logger.info("学生 "+studentId+" 提交的试卷 "+examPaperId+" 已成功处理，并添加到历史记录中");
}
return "redirect:willexams?gradeId="+gradeId+"&classId="+classId+"&studentId="+studentId;
}
/**
* 学生回顾试卷 -- 后台教师查看也调用此方法
* @param studentId
* @param examPaperId
* @param score
* @param examPaperName
* @param studentName 后台教师查看需传入学生姓名
* @return
* @throws UnsupportedEncodingException
*/
@RequestMapping("/review")
public ModelAndView reViewExam(
@RequestParam("studentId") Integer studentId,
@RequestParam("examPaperId") Integer examPaperId,
@RequestParam("score") Integer score,
@RequestParam("examPaperName") String examPaperName,
@RequestParam(value="studentName", required=false) String studentName) throws UnsupportedEncodingException {
ModelAndView model = new ModelAndView();
if (studentId == null) {
model.addObject("error", "请先登录后再操作");
model.setViewName("error");
return model;
} else {
//获取当前试卷的试题集合 -- 前台判断需要
examPaper.setExamPaperId(examPaperId);
esm.setExamPaper(examPaper);
List<ExamSubjectMiddleInfo> esms = examSubjectMiddleInfoService.getExamPaperWithSubject(esm);
Map<String, Object> map = new HashMap<String, Object>();
map.put("studentId", studentId);
map.put("examPaperId", examPaperId);
//获取当前回顾试卷 试题、选择答案 信息
List<ExamChooseInfo> reviews = examChooseInfoService.getChooseInfoWithExamSubject(map);
logger.info("学生 "+studentId+" 回顾试卷 "+examPaperId+" 试题数量 "+reviews.size());
//设置试卷名称、试卷总分
model.addObject("examPaperName", examPaperName);
model.addObject("score", score);
model.setViewName("reception/review");
model.addObject("views", reviews);
model.addObject("esms", esms);
if (studentName != null) model.addObject("studentName", studentName);
model.addObject("ExamedPaper", examPaperInfoService.getExamPaper(examPaperId));
return model;
}
}
/**
* 学生查看自己信息
* @param studentId
* @return
*/
@RequestMapping("/self/{studentId}")
public ModelAndView selfInfo(@PathVariable("studentId") Integer studentId) {
StudentInfo stu = studentInfoService.getStudentById(studentId);
ModelAndView model = new ModelAndView();
model.setViewName("/reception/self");
model.addObject("self", stu);
return model;
}
/**
* 学生修改密码
* @param pwd
* @param studentId
* @param response
* @throws IOException
*/
@RequestMapping("/reset/{pwd}/{studentId}")
public void isResetPwd(
@PathVariable("pwd") String pwd,
@PathVariable("studentId") Integer studentId,
HttpServletResponse response) throws IOException {
logger.info("学生 "+studentId+" 修改密码");
student.setStudentId(studentId);
student.setStudentPwd(pwd);
int row = studentInfoService.isResetPwdWithStu(student);
if (row > 0) {
response.getWriter().print("t");
} else {
response.getWriter().print("f");
}
}
}源码获取：博客首页 "资源" 里下载！
284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
