• Java项目：ssm在线考试系统

    作者主页：夜未央5788

     简介：Java领域优质创作者、Java项目、学习资料、技术互助

    文末获取源码

    项目介绍

    在线考试系统分为前后台，分为学生、老师、管理员三种角色；前台学生登录，后台老师、管理员登录；
    前台学生登录主要功能包括：
    登录、注册、考试中心参加教师分配的考试内容、查看考试历史，回顾考试试卷；

    管理员主要功能包括：
    首页试卷统计；
    基本信息：年级管理、科目管理；
    班级管理：班级管理、各班人数折线图统计；
    教师管理：教师信息增删改查；
    学生管理：学生信息增删改查、学生考试平均成绩柱状图统计；
    试卷管理：包括查看试题、添加试题、生成试题；
    试题管理：试题列表，导入试题；
    考试安排管理：待考信息；
    以往考试信息：考试记录；

    教师登录后功能菜单与管理员相同，但会限制当前教师的权限；
     

    环境需要

    1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。
    2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA;
    3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可
    4.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS；
    5.是否Maven项目: 否；查看源码目录中是否包含pom.xml；若包含，则为maven项目，否则为非maven项目 

    6.数据库：MySql 5.7版本；

    技术栈

    1. 后端：Spring SpringMVC MyBatis

    2. 前端：JSP+bootstrap+jQuery+Echarts

    使用说明

    1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件；
    2. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;若为maven项目，导入成功后请执行maven clean;maven install命令，配置tomcat，然后运行；
    3. 将项目中db.properties配置文件中的数据库配置改为自己的配置;
    4. 运行项目，输入localhost:8080/ 登录
    学生用户名：xiepengfei 密码：123
    管理员用户名：ylrc 密码：123456

    教师用户名：liyinping 密码：123456

    运行截图

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    相关代码 

    管理员首页

    1. package com.taohan.online.exam.handler;
    2.  
    3. import java.io.IOException;
    4.  
    5. import javax.servlet.http.HttpServletResponse;
    6.  
    7. import org.apache.log4j.Logger;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.stereotype.Controller;
    10. import org.springframework.web.bind.annotation.RequestMapping;
    11.  
    12. import com.google.gson.Gson;
    13. import com.taohan.online.exam.service.ExamPaperInfoService;
    14. import com.taohan.online.exam.service.StudentInfoService;
    15. import com.taohan.online.exam.service.SubjectInfoService;
    16. import com.taohan.online.exam.service.TeacherInfoService;
    17.  
    18. /**
    19.   *
    20.   * 
      Title: AdminHomeHandler
    21.   * 
      Description: 后台首页相关
    22.   * @author: taohan
    23.   * @date: 2018-9-18
    24.   * @time: 下午1:59:22
    25.   * @version: 1.0
    26.   */
    27.  
    28. @Controller
    29. public class AdminHomeHandler {
    30.  
    31. 	@Autowired
    32. 	ExamPaperInfoService examPaperInfoService;
    33. 	@Autowired
    34. 	SubjectInfoService subjectInfoService;
    35. 	@Autowired
    36. 	TeacherInfoService teacherInfoService;
    37. 	@Autowired
    38. 	StudentInfoService studentInfoService;
    39. 	@Autowired
    40. 	Gson gson;
    41. 	
    42. 	private Logger logger = Logger.getLogger(AdminHomeHandler.class);
    43. 	
    44. 	
    45. 	@RequestMapping("/homeInfo")
    46. 	public void homeInfo(HttpServletResponse response) throws IOException {
    47. 		logger.info("加载后台首页相关数据");
    48. 		
    49. 		int examPaperTotal = examPaperInfoService.getExamPpaerTotal();
    50. 		int subjectTotal = subjectInfoService.getSubjectTotal();
    51. 		int teacherTotal = teacherInfoService.getTeacherTotal();
    52. 		int studentTotal = studentInfoService.getStudentTotal();
    53. 		
    54. 		String json = "{\"examPaperTotal\":"+examPaperTotal+", " +
    55. 				"\"subjectTotal\":"+subjectTotal+", " +
    56. 				"\"teacherTotal\":"+teacherTotal+", " +
    57. 				"\"studentTotal\":"+studentTotal+"}";
    58. 		
    59. 		response.getWriter().print(json);
    60. 	}
    61. }

    科目信息

    1. package com.taohan.online.exam.handler;
    2.  
    3. import java.util.List;
    4.  
    5. import org.apache.log4j.Logger;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Controller;
    8. import org.springframework.web.bind.annotation.*;
    9. import org.springframework.web.servlet.ModelAndView;
    10.  
    11. import com.taohan.online.exam.po.CourseInfo;
    12. import com.taohan.online.exam.po.GradeInfo;
    13. import com.taohan.online.exam.service.CourseInfoService;
    14. import com.taohan.online.exam.service.GradeInfoService;
    15.  
    16. /**
    17.   *
    18.   * 
      Title: CourseInfoHandler
    19.   * 
      Description: 科目
    20.   * @author: taohan
    21.   * @date: 2018-8-15
    22.   * @time: 下午5:32:03
    23.   * @version: 1.0
    24.   */
    25.  
    26. @Controller
    27. @SuppressWarnings("all")
    28. public class CourseInfoHandler {
    29. 	@Autowired
    30. 	private CourseInfoService courseInfoService;
    31. 	@Autowired
    32. 	private GradeInfoService gradeInfoService;
    33. 	
    34. 	private Logger logger = Logger.getLogger(CourseInfoHandler.class);
    35. 	
    36. 	/**
    37. 	 * 获取科目信息
    38. 	 * @param gradeId 年级编号
    39. 	 * @param division 分科情况
    40. 	 * @return
    41. 	 */
    42. 	@RequestMapping("/courses")
    43. 	public ModelAndView getCourses(@RequestParam(value="gradeId", required=false) Integer gradeId,
    44. 			@RequestParam(value="division", required=false) Integer division) {
    45. 		logger.info("获取科目集合 年级条件 "+gradeId+" 分科条件 "+division);
    46. 		ModelAndView model = new ModelAndView();
    47. 		model.setViewName("/admin/courses");
    48. 		
    49. 		CourseInfo course = new CourseInfo();
    50. 		if (gradeId != null)
    51. 			course.getGrade().setGradeId(gradeId);
    52. 		if (division != null)
    53. 			course.setDivision(division);
    54. 		List courses = courseInfoService.getCourses(course);
    55. 		model.addObject("courses", courses);
    56. 		
    57. 		return model;
    58. 	}
    59. 	
    60. 	/**
    61. 	 * 根据科目编号获取学科信息
    62. 	 * @param courseId 科目编号
    63. 	 * @return
    64. 	 */
    65. 	@RequestMapping("/course/{courseId}")
    66. 	public ModelAndView getCourseById(@PathVariable("courseId") Integer courseId) {
    67. 		logger.info("获取科目信息 科目编号 "+courseId);
    68. 		ModelAndView model = new ModelAndView();
    69. 		model.setViewName("/admin/courseedit");
    70. 		
    71. 		CourseInfo course = courseInfoService.getCourseById(courseId);
    72. 		model.addObject("course", course);
    73. 		/** 获取所有年级列表 */
    74. 		List grades = gradeInfoService.getGrades();
    75. 		model.addObject("grades", grades);
    76. 		
    77. 		return model;
    78. 	}
    79. 	
    80. 	/**
    81. 	 * 添加/修改科目信息
    82. 	 * @param courseId 科目编号
    83. 	 * @param isUpdate 标识是否为修改操作
    84. 	 * @param courseName 科目名称
    85. 	 * @param division 分科情况
    86. 	 * @param gradeId 年级编号
    87. 	 * @return
    88. 	 */
    89. 	@RequestMapping(value="/course/course", method=RequestMethod.POST)
    90. 	public String isUpdateOrAddCourse(@RequestParam(value="courseId", required=false) Integer courseId,
    91. 			@RequestParam(value="isupdate", required=false) Integer isUpdate,
    92. 			@RequestParam("courseName") String courseName,
    93. 			@RequestParam("division") Integer division,
    94. 			@RequestParam("gradeId") Integer gradeId) {
    95. 		
    96. 		CourseInfo course = new CourseInfo();
    97. 			course.setCourseId(courseId);
    98. 			course.setCourseName(courseName);
    99. 			course.setDivision(division);
    100. 			GradeInfo grade = new GradeInfo();
    101. 			grade.setGradeId(gradeId);
    102. 			course.setGrade(grade);
    103. 		
    104. 		//修改
    105. 		if (isUpdate != null) {
    106. 			logger.info("修改科目 "+course+" 的信息");
    107. 			int row = courseInfoService.isUpdateCourse(course);			
    108. 		}
    109. 		//添加
    110. 		else {
    111. 			logger.info("添加科目 "+course+" 的信息");
    112. 			int row = courseInfoService.isAddCourse(course);
    113. 		}
    114. 		
    115. 		return "redirect:/courses";
    116. 	}
    117. 	
    118. 	/**
    119. 	 * 删除科目
    120. 	 * @param courseId 待删除科目编号
    121. 	 * @return
    122. 	 */
    123. 	@RequestMapping(value="/course/{courseId}", method=RequestMethod.DELETE)
    124. 	public String isDelTeacher(@PathVariable("courseId") Integer courseId) {
    125. 		logger.info("删除科目 "+courseId);
    126. 		
    127. 		int row = courseInfoService.isDelCourse(courseId);
    128. 		
    129. 		return "redirect:/courses";
    130. 	}
    131. 	
    132. 	/**
    133. 	 * 预添加科目信息
    134. 	 * @return
    135. 	 */
    136. 	@RequestMapping("/preAddCourse")
    137. 	public ModelAndView preAddCourse() {
    138. 		logger.info("预添加科目信息");
    139. 		ModelAndView model = new ModelAndView();
    140. 		model.setViewName("/admin/courseedit");
    141. 		/** 获取年级集合 */
    142. 		List grades = gradeInfoService.getGrades();
    143. 		model.addObject("grades", grades);
    144. 		
    145. 		return model;
    146. 	}
    147. }

    班级信息

    1. package com.taohan.online.exam.handler;
    2.  
    3. import java.io.IOException;
    4. import java.util.HashMap;
    5. import java.util.List;
    6. import java.util.Map;
    7.  
    8. import javax.servlet.http.HttpServletRequest;
    9. import javax.servlet.http.HttpServletResponse;
    10.  
    11. import org.apache.log4j.Logger;
    12. import org.springframework.beans.factory.annotation.Autowired;
    13. import org.springframework.stereotype.Controller;
    14. import org.springframework.web.bind.annotation.*;
    15. import org.springframework.web.servlet.ModelAndView;
    16.  
    17. import com.google.gson.Gson;
    18. import com.taohan.online.exam.charts.StudentCount;
    19. import com.taohan.online.exam.po.ClassInfo;
    20. import com.taohan.online.exam.po.GradeInfo;
    21. import com.taohan.online.exam.po.TeacherInfo;
    22. import com.taohan.online.exam.service.ClassInfoService;
    23. import com.taohan.online.exam.service.GradeInfoService;
    24. import com.taohan.online.exam.service.TeacherInfoService;
    25.  
    26. /**
    27.   *
    28.   * 
      Title: ClassInfoHandler
    29.   * 
      Description: 班级
    30.   * @author: taohan
    31.   * @date: 2018-8-13
    32.   * @time: 下午2:18:14
    33.   * @version: 1.0
    34.   */
    35.  
    36. @Controller
    37. @SuppressWarnings("all")
    38. public class ClassInfoHandler {
    39.  
    40. 	@Autowired
    41. 	private ClassInfoService classInfoService;
    42. 	@Autowired
    43. 	private GradeInfoService gradeInfoService;
    44. 	@Autowired
    45. 	private TeacherInfoService teacherInfoService;
    46. 	@Autowired
    47. 	private TeacherInfo teacher;
    48. 	@Autowired
    49. 	private ClassInfo classInfo;
    50. 	@Autowired
    51. 	private Gson gson;
    52. 	
    53. 	private Logger logger = Logger.getLogger(ClassInfoHandler.class);
    54. 	
    55. 	/**
    56. 	 * 获取所有班级
    57. 	 * @param gradeId 年级编号
    58. 	 * @param className 班级名称  可用于模糊查询
    59. 	 * @param classId  班级编号
    60. 	 * @return
    61. 	 */
    62. 	@RequestMapping(value="/classes", method=RequestMethod.GET)
    63. 	public ModelAndView getClasses(@RequestParam(value="gradeId", required=false) Integer gradeId,
    64. 			@RequestParam(value="className", required=false) String className,
    65. 			@RequestParam(value="classId", required=false) Integer classId) {
    66. 		logger.info("获取班级集合 条件：gradeId： "+gradeId+", 班级编号："+classId+", 班级："+className);
    67. 		ModelAndView model = new ModelAndView();
    68. 		ClassInfo classInfo = new ClassInfo();
    69. 		
    70. 		/*处理查询条件*/
    71. 		if (gradeId != null) {
    72. 			GradeInfo gradeInfo = new GradeInfo();
    73. 			gradeInfo.setGradeId(gradeId);
    74. 			classInfo.setGrade(gradeInfo);
    75. 		}
    76. 		if (classId != null)
    77. 			classInfo.setClassId(classId);
    78. 		if (className != null) {
    79. 			if (className.trim() != "")
    80. 				classInfo.setClassName(className);
    81. 		}
    82. 		
    83. 		List classes = classInfoService.getClasses(classInfo);
    84. 		model.setViewName("admin/classes");
    85. 		model.addObject("classes", classes);
    86. 		
    87. 		return model;
    88. 	}
    89. 	
    90. 	
    91. 	/**
    92. 	 * 预添加班级处理
    93. 	 * @return
    94. 	 */
    95. 	@RequestMapping("/preAddClass")
    96. 	public ModelAndView preAddClass() {
    97. 		logger.info("预添加班级信息");
    98. 		
    99. 		ModelAndView model = new ModelAndView();
    100. 		//获取年级信息
    101. 		List grades = gradeInfoService.getGrades();
    102. 		model.setViewName("admin/classedit");
    103. 		model.addObject("grades", grades);
    104. 		//获取不是班主任的教师
    105. 		teacher.setIsWork(0);
    106. 		Map map = new HashMap();
    107. 		map.put("startIndex", null);
    108. 		map.put("pageShow", null);
    109. 		map.put("teacher", teacher);
    110. 		List teachers = teacherInfoService.getTeachers(map);
    111. 		model.addObject("teachers", teachers);
    112. 		model.addObject("editClass", new ClassInfo());
    113. 		
    114. 		return model;
    115. 	}
    116. 	
    117. 	/**
    118. 	 * 添加班级
    119. 	 * @param classInfo 班级信息
    120. 	 * @param request
    121. 	 * @return
    122. 	 */
    123. 	@RequestMapping(value="/class", method=RequestMethod.POST)
    124. 	public String isAddClass(ClassInfo classInfo, HttpServletRequest request) {
    125. 		logger.info("添加班级信息 "+classInfo);
    126. 		
    127. 		//修改教师班主任状态
    128. 		String returnMsg = isChangeTeacherWork(1, classInfo.getTeacher().getTeacherId());
    129. 		if (returnMsg != null) {
    130. 			request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
    131. 			return "error";
    132. 		}
    133.  
    134. 		//添加
    135. 		int row = classInfoService.isAddClass(classInfo);
    136. 		if (row < 1) {
    137. 			logger.error("班级 "+classInfo+" 删除失败");
    138. 			
    139. 			request.setAttribute("error", "班级 "+classInfo.getClassName()+" 添加失败，请稍后再试！");
    140. 			return "../error";
    141. 		}
    142. 		
    143. 		return "redirect:/classes";
    144. 	}
    145. 	
    146. 	
    147. 	/**
    148. 	 * 删除班级
    149. 	 * @param classId 班级编号
    150. 	 * @param request
    151. 	 * @return
    152. 	 */
    153. 	@RequestMapping(value="/del/class/{classId}", method=RequestMethod.DELETE)
    154. 	public String isDelClass(@PathVariable("classId") Integer classId, HttpServletRequest request) {
    155. 		logger.info("删除班级 "+classId);
    156. 		
    157. 		//将删除班级对于之前班主任改为 非班主任状态
    158. 		//需要在删除班级之前修改，如果先删除了班级，再根据班级获取教师编号，就不能获取
    159. 		ClassInfo delClass = classInfoService.getClassById(classId);
    160. 		String returnMsg = isChangeTeacherWork(0, delClass.getTeacher().getTeacherId());
    161. 		if (returnMsg != null) {
    162. 			request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
    163. 			return "error";
    164. 		}
    165.  
    166. 		//删除
    167. 		int row = classInfoService.isDelClass(classId);
    168. 		if (row < 1) {
    169. 			logger.error("班级 "+classId+" 删除失败");
    170. 			
    171. 			request.setAttribute("error", "班级删除失败，请稍后再试！");
    172. 			return "../error";
    173. 		}
    174. 		
    175. 		return "redirect:/classes";
    176. 	}
    177. 	
    178. 	
    179. 	/**
    180. 	 * 预修改班级处理
    181. 	 * @param classId 班级编号
    182. 	 * @return
    183. 	 */
    184. 	@RequestMapping(value="edit/class/{classId}", method=RequestMethod.GET)
    185. 	public ModelAndView preUpdateClass(@PathVariable("classId") Integer classId) {
    186. 		logger.info("预修改班级处理");
    187. 		
    188. 		ModelAndView model = new ModelAndView();
    189. 		//获取要修改班级
    190. 		ClassInfo classInfo = classInfoService.getClassById(classId);
    191. 		model.setViewName("/admin/classedit");
    192. 		model.addObject("editClass", classInfo);
    193. 		List grades = gradeInfoService.getGrades();
    194. 		//获取不是班主任的教师
    195. 		teacher.setIsWork(0);
    196. 		Map map = new HashMap();
    197. 		map.put("startIndex", null);
    198. 		map.put("pageShow", null);
    199. 		map.put("teacher", teacher);
    200. 		List teachers = teacherInfoService.getTeachers(map);
    201. 		//如果没有可用班主任
    202. 		if (teachers.size() == 0 || teachers == null) {
    203. 			teacher.setTeacherId(classInfo.getTeacher().getTeacherId());
    204. 			teacher.setTeacherName("暂无剩余教师");
    205. 			teachers.add(teacher);
    206. 		}
    207. 		model.addObject("teachers", teachers);
    208. 		model.addObject("grades", grades);
    209. 		
    210. 		return model;
    211. 	}
    212. 	
    213. 	
    214. 	/**
    215. 	 * 修改班级信息
    216. 	 * @param classInfo 班级信息
    217. 	 * @param request
    218. 	 * @param lastTeacherId  上一个班主任编号，修改其 班主任状态
    219. 	 * @return
    220. 	 */
    221. 	@RequestMapping(value="edit/class/class", method=RequestMethod.PUT)
    222. 	public String isUpdateClass(ClassInfo classInfo, HttpServletRequest request, 
    223. 			@RequestParam(value="lastTeacher", required=false) Integer lastTeacherId) {
    224. 		//修改上一教师不为班主任状态
    225. 		if (lastTeacherId != null) {
    226. 			String returnMsg = isChangeTeacherWork(0, lastTeacherId);
    227. 			if (returnMsg != null) {
    228. 				request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
    229. 				return "/error";
    230. 			}
    231. 		}
    232. 		//修改当前教师为班主任状态
    233. 		String returnMsg = isChangeTeacherWork(1, classInfo.getTeacher().getTeacherId());
    234. 		if (returnMsg != null) {
    235. 			request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
    236. 			return "/error";
    237. 		}
    238. 		
    239. 		logger.info("修改班级 "+classInfo);
    240. 		
    241. 		int row = classInfoService.isUpdateClass(classInfo);
    242. 		if (row < 1) {
    243. 			logger.error("班级 "+classInfo+" 修改失败");
    244. 			
    245. 			request.setAttribute("error", "班级修改失败，请稍后再试！");
    246. 			return "../error";
    247. 		}
    248. 		
    249. 		return "redirect:/classes";
    250. 	}
    251. 	
    252. 	
    253. 	/**
    254. 	 * 获取指定年级下的班级
    255. 	 * @param gradeId 年级编号
    256. 	 * @param response
    257. 	 * @throws IOException
    258. 	 */
    259. 	@RequestMapping(value="/gradeclass/{gradeId}", method=RequestMethod.GET)
    260. 	public void getClassesByGradeId(@PathVariable("gradeId") Integer gradeId,
    261. 			HttpServletResponse response) throws IOException {
    262. 		logger.info("获取年级 "+gradeId+" 下的班级集合");
    263. 		
    264. 		List classes = classInfoService.getClassByGradeId(gradeId);
    265. 		
    266. 		String json = gson.toJson(classes);
    267. 		response.getWriter().print(json);
    268. 	}
    269. 	
    270. 	
    271. 	/**
    272. 	 * 修改教师(班主任)工作状态
    273. 	 * @param status 是否为班主任标识
    274. 	 * @param teacherId 教师编号
    275. 	 */
    276. 	private String isChangeTeacherWork(int status, Integer teacherId) {
    277. 		logger.info("修改教师 "+teacherId+" 的状态为 "+status);
    278. 		teacher.setIsWork(status);
    279. 		if (teacherId == null) {
    280. 			logger.error("修改教师班主任状态 对应教师编号有误");
    281. 			return "修改教师班主任状态 对应教师编号有误";
    282. 		}
    283. 		teacher.setTeacherId(teacherId);
    284. 		int row = teacherInfoService.updateTeacherIsWork(teacher);
    285. 		return null;
    286. 	}
    287. 	
    288. 	@RequestMapping("/stuCount")
    289. 	public void getStudentCountForClass(
    290. 			@RequestParam(value="gradeId", required=false) Integer gradeId,
    291. 			HttpServletResponse response) throws IOException {
    292. 		Map map = classInfoService.getStudentCountForClass(gradeId);
    293. 		String json = StudentCount.createBarJson(map);
    294. 		
    295. 		response.getWriter().print(json);
    296. 	}
    297. 	
    298. 	/**
    299. 	 * 预添加班级处理
    300. 	 * @return
    301. 	 */
    302. 	@RequestMapping("/preStudentCount")
    303. 	public ModelAndView preStudentCount() {
    304. 		
    305. 		ModelAndView model = new ModelAndView();
    306. 		//获取年级信息
    307. 		List grades = gradeInfoService.getGrades();
    308. 		model.setViewName("admin/charts/studentCount");
    309. 		model.addObject("grades", grades);
    310. 		
    311. 		return model;
    312. 	}
    313. 	
    314. }

    年级信息

    1. package com.taohan.online.exam.handler;
    2.  
    3. import java.util.List;
    4. import java.util.Map;
    5.  
    6. import javax.servlet.http.HttpServletRequest;
    7.  
    8. import org.apache.log4j.Logger;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.beans.factory.annotation.Qualifier;
    11. import org.springframework.stereotype.Controller;
    12. import org.springframework.web.bind.annotation.*;
    13. import org.springframework.web.servlet.ModelAndView;
    14.  
    15. import com.google.gson.Gson;
    16. import com.taohan.online.exam.po.GradeInfo;
    17. import com.taohan.online.exam.service.GradeInfoService;
    18.  
    19. /**
    20.   *
    21.   * 
      Title: GradeInfoHandler
    22.   * 
      Description: 年级
    23.   * @author: taohan
    24.   * @date: 2018-8-14
    25.   * @time: 上午10:03:33
    26.   * @version: 1.0
    27.   */
    28.  
    29. @Controller
    30. public class GradeInfoHandler {
    31.  
    32. 	@Autowired
    33. 	@Qualifier("gson")
    34. 	private Gson gson;
    35. 	@Autowired
    36. 	private GradeInfoService gradeInfoService;
    37. 	
    38. 	private Logger logger = Logger.getLogger(GradeInfoHandler.class);
    39. 	
    40. 	/**
    41. 	 * 获取所有年级集合
    42. 	 * @return
    43. 	 */
    44. 	@RequestMapping(value="/grades")
    45. 	public ModelAndView getGrades() {
    46. 		logger.info("获取所有年级");
    47. 		
    48. 		ModelAndView model = new ModelAndView();
    49. 		model.setViewName("admin/grades");
    50. 		//获取所有年级
    51. 		List grades = gradeInfoService.getGrades();
    52. 		model.addObject("grades", grades);
    53. 		
    54. 		return model;
    55. 	}
    56. 	
    57. 	
    58. 	/**
    59. 	 * 预添加年级处理
    60. 	 * @param map
    61. 	 * @return
    62. 	 */
    63. 	@RequestMapping("/preAddGrade")
    64. 	public String preAddGrade(Map map) {
    65. 		logger.info("年级添加预处理");
    66. 		
    67. 		map.put("grade", new GradeInfo());
    68. 		
    69. 		return "admin/gradeedit";
    70. 	}
    71. 	
    72. 	/**
    73. 	 * 添加年级
    74. 	 * @param grade
    75. 	 * @param request
    76. 	 * @return
    77. 	 */
    78. 	@RequestMapping(value="/grade", method=RequestMethod.POST)
    79. 	public String isAddGrade(GradeInfo grade, HttpServletRequest request) {
    80. 		logger.info("添加年级 "+grade);
    81.  
    82. 		if (grade == null) {
    83. 			logger.error("年级 "+grade+" 为空");
    84. 			
    85. 			request.setAttribute("error", "年级添加失败，请稍后再试！");
    86. 			return "error";
    87. 		}
    88. 		int row = gradeInfoService.isAddGrade(grade);
    89. 		if (row < 1) {
    90. 			logger.error("年级添加失败");
    91. 			
    92. 			request.setAttribute("error", "年级添加失败，请稍后再试！");
    93. 			return "error";
    94. 		}
    95. 		
    96. 		return "redirect:grades";
    97. 	}
    98. 	
    99. 	/**
    100. 	 * 预修改年级处理
    101. 	 * @param gradeId 待修改年级编号
    102. 	 * @param map
    103. 	 * @return
    104. 	 */
    105. 	@RequestMapping(value="/grade/update/{gradeId}", method=RequestMethod.GET)
    106. 	public String preUpdateGrade(@PathVariable("gradeId") Integer gradeId,
    107. 			Map map) {
    108. 		logger.info("年级修改预处理");
    109. 		
    110. 		map.put("grade", gradeInfoService.getGradeById(gradeId));
    111. 		
    112. 		return "/admin/gradeedit";
    113. 	}
    114. 	
    115. 	/**
    116. 	 * 修改年级信息
    117. 	 * @param grade
    118. 	 * @param request
    119. 	 * @return
    120. 	 */
    121. 	@RequestMapping(value="/grade/update/grade", method=RequestMethod.PUT)
    122. 	public String isUpdateGrade(GradeInfo grade, HttpServletRequest request) {
    123. 		logger.info("修改年级 "+grade+" 的信息");
    124. 		
    125. 		int row = gradeInfoService.isUpdateGrade(grade);
    126. 		if (row < 1) {
    127. 			logger.error("年级修改失败");
    128. 			
    129. 			request.setAttribute("error", "年级修改失败，请稍后再试！");
    130. 			return "/error";
    131. 		}
    132. 		
    133. 		return "redirect:/grades";
    134. 	}
    135. 	
    136. 	/**
    137. 	 * 删除年级
    138. 	 * @param gradeId
    139. 	 * @param request
    140. 	 * @return
    141. 	 */
    142. 	@RequestMapping(value="grade/del/{gradeId}", method=RequestMethod.DELETE)
    143. 	public String isDelGrade(@PathVariable("gradeId") Integer gradeId, HttpServletRequest request) {
    144. 		logger.info("删除年级 "+gradeId);
    145. 		
    146. 		int row = gradeInfoService.isDelGrade(gradeId);
    147. 		if (row < 1) {
    148. 			logger.error("年级删除失败");
    149. 			
    150. 			request.setAttribute("error", "年级删除失败，请稍后再试！");
    151. 			return "/error";
    152. 		}
    153. 		
    154. 		return "redirect:/grades";
    155. 	}
    156. }

    如果也想学习本系统，下面领取。回复：198ssm

     

  • 相关阅读:
    重塑 Google 搜索、Android 13 新版发布，这届 I/O 大会为开发者带来了什么？
    如何管理oralce口令文件和参数文件
    java 查看内存方式
    List的使用
    牛客网---活动运营刷题笔记
    【Javascript】在对象的方法里访问自己的属性
    App分发的原理ipa分发系统需求
    【操作系统实验】线程的创建+信号量通信
    Android13版本新特性介绍
    计算机网络第三章——数据链路层（二）
  • 原文地址：https://blog.csdn.net/hanyunlong1989/article/details/126339492