devbox
小舞很执着
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java项目:校园宿舍管理系统(java+Springboot+Vue+maven+redis+Mysql)_java高校宿舍安全检查管理系统前后端分离

作者：小舞很执着 | 2024-07-20 19:32:22

赞

踩

java高校宿舍安全检查管理系统前后端分离

源码获取：俺的博客首页 "资源" 里下载！

项目介绍

这个项目是一个基于SpringBoot+Vue的校园宿舍管理系统，前后端分离。
主要有超级管理员和宿舍管理员两种角色；

超级管理员权限包括：
首页；
学生宿舍管理：宿舍管理、学生管理、班级管理、宿舍楼管理；
记录：维修记录、晚归记录、请假记录；
系统管理：用户管理、角色管理、菜单管理、日志管理等。

宿舍管理员权限包括：
首页；
学生宿舍管理：宿舍管理、学生管理、班级管理；
记录：维修记录、晚归记录、请假记录；


环境需要

1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。
2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA;
3.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS；
4.数据库：MySql 5.7/8.0版本均可；
5.是否Maven项目：是；


技术栈

1.后端：SpringBoot+Mysql+redis
2.前端：Vue


使用说明

后端项目运行：
1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件；
2. 使用IDEA/Eclipse/MyEclipse导入项目，导入成功后请执行maven clean;maven install命令，然后运行；
3. 将项目中application-dev.yaml配置文件中的数据库配置改为自己的配置;
4. 运行项目，控制台提示运行成功后再去运行前端项目；

前端项目运行:


1. 安装好node环境
2. 在dms目录下运行 npm install 安装所需要的包
3. 在dms目录下运行 npm run dev
4. 运行成功后，在浏览器中访问http://localhost:8087，登录账号即可

 

 

 

 

 

 

 

后台用户管理控制器:

  1. /**
  2.  * 后台用户管理控制器
  3.  * @author yy
  4.  *
  5.  */
  6. @RequestMapping("/user")
  7. @Controller
  8. public class UserController {
  9.  
  10. 	@Autowired
  11. 	private UserService userService;
  12. 	@Autowired
  13. 	private RoleService roleService;
  14. 	@Autowired
  15. 	private OperaterLogService operaterLogService;
  16. 	/**
  17. 	 * 用户列表页面
  18. 	 * @param model
  19. 	 * @param user
  20. 	 * @param pageBean
  21. 	 * @return
  22. 	 */
  23. 	@RequestMapping(value="/list")
  24. 	public String list(Model model,User user,PageBean<User> pageBean){
  25. 		model.addAttribute("title", "用户列表");
  26. 		model.addAttribute("username", user.getUsername());
  27. 		model.addAttribute("pageBean", userService.findList(user, pageBean));
  28. 		return "admin/user/list";
  29. 	}
  30. 	
  31. 	/**
  32. 	 * 新增用户页面
  33. 	 * @param model
  34. 	 * @return
  35. 	 */
  36. 	@RequestMapping(value="/add",method=RequestMethod.GET)
  37. 	public String add(Model model){
  38. 		model.addAttribute("roles", roleService.findAll());
  39. 		return "admin/user/add";
  40. 	}
  41. 	
  42. 	/**
  43. 	 * 用户添加表单提交处理
  44. 	 * @param user
  45. 	 * @return
  46. 	 */
  47. 	@RequestMapping(value="/add",method=RequestMethod.POST)
  48. 	@ResponseBody
  49. 	public Result<Boolean> add(User user){
  50. 		//用统一验证实体方法验证是否合法
  51. 		CodeMsg validate = ValidateEntityUtil.validate(user);
  52. 		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
  53. 			return Result.error(validate);
  54. 		}
  55. 		if(user.getRole() == null || user.getRole().getId() == null){
  56. 			return Result.error(CodeMsg.ADMIN_USER_ROLE_EMPTY);
  57. 		}
  58. 		//判断用户名是否存在
  59. 		if(userService.isExistUsername(user.getUsername(), 0l)){
  60. 			return Result.error(CodeMsg.ADMIN_USERNAME_EXIST);
  61. 		}
  62. 		//到这说明一切符合条件，进行数据库新增
  63. 		if(userService.save(user) == null){
  64. 			return Result.error(CodeMsg.ADMIN_USE_ADD_ERROR);
  65. 		}
  66. 		operaterLogService.add("添加用户，用户名：" + user.getUsername());
  67. 		return Result.success(true);
  68. 	}
  69. 	
  70. 	/**
  71. 	 * 用户编辑页面
  72. 	 * @param model
  73. 	 * @return
  74. 	 */
  75. 	@RequestMapping(value="/edit",method=RequestMethod.GET)
  76. 	public String edit(Model model,@RequestParam(name="id",required=true)Long id){
  77. 		model.addAttribute("roles", roleService.findAll());
  78. 		model.addAttribute("user", userService.find(id));
  79. 		return "admin/user/edit";
  80. 	}
  81.  
  82. 	
  83. 	/**
  84. 	 * 编辑用户信息表单提交处理
  85. 	 * @param user
  86. 	 * @return
  87. 	 */
  88. 	@RequestMapping(value="/edit",method=RequestMethod.POST)
  89. 	@ResponseBody
  90. 	public Result<Boolean> edit(User user){
  91. 		//用统一验证实体方法验证是否合法
  92. 		CodeMsg validate = ValidateEntityUtil.validate(user);
  93. 		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
  94. 			return Result.error(validate);
  95. 		}
  96. 		if(user.getRole() == null || user.getRole().getId() == null){
  97. 			return Result.error(CodeMsg.ADMIN_USER_ROLE_EMPTY);
  98. 		}
  99. 		if(user.getId() == null || user.getId().longValue() <= 0){
  100. 			return Result.error(CodeMsg.ADMIN_USE_NO_EXIST);
  101. 		}
  102. 		if(userService.isExistUsername(user.getUsername(), user.getId())){
  103. 			return Result.error(CodeMsg.ADMIN_USERNAME_EXIST);
  104. 		}
  105. 		//到这说明一切符合条件，进行数据库保存
  106. 		User findById = userService.find(user.getId());
  107. 		//讲提交的用户信息指定字段复制到已存在的user对象中,该方法会覆盖新字段内容
  108. 		BeanUtils.copyProperties(user, findById, "id","createTime","updateTime");
  109. 		if(userService.save(findById) == null){
  110. 			return Result.error(CodeMsg.ADMIN_USE_EDIT_ERROR);
  111. 		}
  112. 		operaterLogService.add("编辑用户，用户名：" + user.getUsername());
  113. 		return Result.success(true);
  114. 	}
  115. 	
  116. 	/**
  117. 	 * 删除用户
  118. 	 * @param id
  119. 	 * @return
  120. 	 */
  121. 	@RequestMapping(value="/delete",method=RequestMethod.POST)
  122. 	@ResponseBody
  123. 	public Result<Boolean> delete(@RequestParam(name="id",required=true)Long id){
  124. 		try {
  125. 			userService.delete(id);
  126. 		} catch (Exception e) {
  127. 			return Result.error(CodeMsg.ADMIN_USE_DELETE_ERROR);
  128. 		}
  129. 		operaterLogService.add("添加用户，用户ID：" + id);
  130. 		return Result.success(true);
  131. 	}
  132. }

系统控制器:

  1. /**
  2.  * 系统控制器
  3.  *
  4.  * @author yy
  5.  */
  6. @RequestMapping("/system")
  7. @Controller
  8. public class SystemController {
  9.  
  10. 	@Autowired
  11. 	private OrderAuthService orderAuthService;
  12.  
  13. 	@Autowired
  14. 	private OperaterLogService operaterLogService;
  15.  
  16. 	@Autowired
  17. 	private StudentService studentService;
  18.  
  19. 	@Autowired
  20. 	private UserService userService;
  21. 	@Autowired
  22. 	private EmpService empService;
  23.  
  24. 	@Autowired
  25. 	private DatabaseBakService databaseBakService;
  26.  
  27. 	@Value("${show.tips.text}")
  28. 	private String showTipsText;
  29. 	@Value("${show.tips.url.text}")
  30. 	private String showTipsUrlText;
  31. 	@Value("${show.tips.btn.text}")
  32. 	private String showTipsBtnText;
  33. 	@Value("${show.tips.url}")
  34. 	private String showTipsUtl;
  35.  
  36. 	private Logger log = LoggerFactory.getLogger(SystemController.class);
  37.  
  38. 	/**
  39. 	 * 登录页面
  40. 	 *
  41. 	 * @param
  42. 	 * @param model
  43. 	 * @return
  44. 	 */
  45. 	@RequestMapping(value = "/login", method = RequestMethod.GET)
  46. 	public String login(Model model) {
  47. 		return "admin/system/login";
  48. 	}
  49.  
  50. 	/**
  51. 	 * 用户登录提交表单处理方法
  52. 	 *
  53. 	 * @param request
  54. 	 * @param user
  55. 	 * @param cpacha
  56. 	 * @return
  57. 	 */
  58. 	@RequestMapping(value = "/login", method = RequestMethod.POST)
  59. 	@ResponseBody
  60. 	public Result<Boolean> login(HttpServletRequest request, User user, String cpacha, String type) {
  61. 		if (user == null) {
  62. 			return Result.error(CodeMsg.DATA_ERROR);
  63. 		}
  64. 		//用统一验证实体方法验证是否合法
  65. 		CodeMsg validate = ValidateEntityUtil.validate(user);
  66. 		if (validate.getCode() != CodeMsg.SUCCESS.getCode()) {
  67. 			return Result.error(validate);
  68. 		}
  69. 		//表示实体信息合法，开始验证验证码是否为空
  70. 		if (StringUtils.isEmpty(cpacha)) {
  71. 			return Result.error(CodeMsg.CPACHA_EMPTY);
  72. 		}
  73. 		//说明验证码不为空，从session里获取验证码
  74. 		Object attribute = request.getSession().getAttribute("admin_login");
  75. 		if (attribute == null) {
  76. 			return Result.error(CodeMsg.SESSION_EXPIRED);
  77. 		}
  78. 		//表示session未失效，进一步判断用户填写的验证码是否正确
  79. 		if (!cpacha.equalsIgnoreCase(attribute.toString())) {
  80. 			return Result.error(CodeMsg.CPACHA_ERROR);
  81. 		}
  82.  
  83. 		if ("2".equals(type)) {
  84. 			//表示验证码正确，开始查询数据库，检验密码是否正确
  85. 			User findByUsername = userService.findByUsername(user.getUsername());
  86. 			//判断是否为空
  87. 			if (findByUsername == null) {
  88. 				return Result.error(CodeMsg.ADMIN_USERNAME_NO_EXIST);
  89. 			}
  90. 			//表示用户存在，进一步对比密码是否正确
  91. 			if (!findByUsername.getPassword().equals(user.getPassword())) {
  92. 				return Result.error(CodeMsg.ADMIN_PASSWORD_ERROR);
  93. 			}
  94. 			//表示密码正确，接下来判断用户状态是否可用
  95. 			if (findByUsername.getStatus() == User.ADMIN_USER_STATUS_UNABLE) {
  96. 				return Result.error(CodeMsg.ADMIN_USER_UNABLE);
  97. 			}
  98. 			//检查用户所属角色状态是否可用
  99. 			if (findByUsername.getRole() == null || findByUsername.getRole().getStatus() == Role.ADMIN_ROLE_STATUS_UNABLE) {
  100. 				return Result.error(CodeMsg.ADMIN_USER_ROLE_UNABLE);
  101. 			}
  102. 			//检查用户所属角色的权限是否存在
  103. 			if (findByUsername.getRole().getAuthorities() == null || findByUsername.getRole().getAuthorities().size() == 0) {
  104. 				return Result.error(CodeMsg.ADMIN_USER_ROLE_AUTHORITES_EMPTY);
  105. 			}
  106. 			//检查一切符合，可以登录，将用户信息存放至session
  107. 			request.getSession().setAttribute(SessionConstant.SESSION_USER_LOGIN_KEY, findByUsername);
  108. 			//销毁session中的验证码
  109. 			request.getSession().setAttribute("admin_login", null);
  110. 			//将登陆记录写入日志库
  111. 			operaterLogService.add("用户【" + user.getUsername() + "】于【" + StringUtil.getFormatterDate(new Date(), "yyyy-MM-dd HH:mm:ss") + "】登录系统！");
  112. 			log.info("用户成功登录，user = " + findByUsername);
  113. 		} else if ("0".equals(type)) {
  114. 			//表示验证码正确，开始查询数据库，检验密码是否正确
  115. 			Student findByStudentNo = studentService.findByStudentNo(user.getUsername());
  116. 			//判断是否为空
  117. 			if (findByStudentNo == null) {
  118. 				return Result.error(CodeMsg.ADMIN_USERNAME_NO_EXIST);
  119. 			}
  120. 			//表示用户存在，进一步对比密码是否正确
  121. 			if (!findByStudentNo.getPassword().equals(user.getPassword())) {
  122. 				return Result.error(CodeMsg.ADMIN_PASSWORD_ERROR);
  123. 			}
  124. 			user.setEmail(findByStudentNo.getEmail());
  125. 			user.setUsername(findByStudentNo.getStudentName());
  126. 			user.setRole(findByStudentNo.getRole());
  127. 			user.setMobile(findByStudentNo.getMobile());
  128. 			user.setSex(findByStudentNo.getStudentSex());
  129. 			user.setId(findByStudentNo.getId());
  130. 			user.setHeadPic(findByStudentNo.getHeadPic());
  131. 			//检查一切符合，可以登录，将用户信息存放至session
  132. 			request.getSession().setAttribute(SessionConstant.SESSION_USER_LOGIN_KEY, user);
  133. 			request.getSession().setAttribute("admin_login", null);
  134. 			request.getSession().setAttribute("admin_stu", findByStudentNo);
  135. 			//将登陆记录写入日志库
  136. 			operaterLogService.add("用户【" + user.getUsername() + "】于【" + StringUtil.getFormatterDate(new Date(), "yyyy-MM-dd HH:mm:ss") + "】登录系统！");
  137. 			log.info("用户成功登录，user = " + user);
  138. 		} else if ("1".equals(type)) {
  139. 			//表示验证码正确，开始查询数据库，检验密码是否正确
  140. 			Emp byNumber = empService.findByNumber(user.getUsername());
  141. 			//判断是否为空
  142. 			if (byNumber == null) {
  143. 				return Result.error(CodeMsg.ADMIN_USERNAME_NO_EXIST);
  144. 			}
  145. 			//表示用户存在，进一步对比密码是否正确
  146. 			if (!byNumber.getPassword().equals(user.getPassword())) {
  147. 				return Result.error(CodeMsg.ADMIN_PASSWORD_ERROR);
  148. 			}
  149. 			user.setEmail(byNumber.getEmail());
  150. 			user.setUsername(byNumber.getName());
  151. 			user.setPassword(byNumber.getPassword());
  152. 			user.setRole(byNumber.getRole());
  153. 			user.setMobile(byNumber.getMobile());
  154. 			user.setSex(byNumber.getSex());
  155. 			user.setHeadPic(byNumber.getHeadPic());
  156. 			user.setRole(byNumber.getRole());
  157. 			user.setId(byNumber.getId());
  158. 			//检查一切符合，可以登录，将用户信息存放至session
  159. 			request.getSession().setAttribute(SessionConstant.SESSION_USER_LOGIN_KEY, user);
  160. 			request.getSession().setAttribute("admin_login", null);
  161. 			//将登陆记录写入日志库
  162. 			operaterLogService.add("用户【" + user.getUsername() + "】于【" + StringUtil.getFormatterDate(new Date(), "yyyy-MM-dd HH:mm:ss") + "】登录系统！");
  163. 			log.info("用户成功登录，user = " + user);
  164. 		}
  165. 		return Result.success(true);
  166. 	}
  167.  
  168. 	/**
  169. 	 * 登录成功后的系统主页
  170. 	 *
  171. 	 * @param model
  172. 	 * @return
  173. 	 */
  174. 	@RequestMapping(value = "/index")
  175. 	public String index(Model model) {
  176. 		model.addAttribute("operatorLogs", operaterLogService.findLastestLog(10));
  177. 		model.addAttribute("userTotal", userService.total());
  178. 		model.addAttribute("operatorLogTotal", operaterLogService.total());
  179. 		model.addAttribute("databaseBackupTotal", databaseBakService.total());
  180. 		model.addAttribute("onlineUserTotal", SessionListener.onlineUserCount);
  181. 		model.addAttribute("showTipsText", showTipsText);
  182. 		model.addAttribute("showTipsUrlText", showTipsUrlText);
  183. 		model.addAttribute("showTipsUtl", showTipsUtl);
  184. 		model.addAttribute("showTipsBtnText", showTipsBtnText);
  185. 		return "admin/system/index";
  186. 	}
  187.  
  188. 	/**
  189. 	 * 注销登录
  190. 	 *
  191. 	 * @return
  192. 	 */
  193. 	@RequestMapping(value = "/logout")
  194. 	public String logout() {
  195. 		User loginedUser = SessionUtil.getLoginedUser();
  196. 		if (loginedUser != null) {
  197. 			SessionUtil.set(SessionConstant.SESSION_USER_LOGIN_KEY, null);
  198. 		}
  199. 		return "redirect:login";
  200. 	}
  201.  
  202. 	/**
  203. 	 * 无权限提示页面
  204. 	 *
  205. 	 * @return
  206. 	 */
  207. 	@RequestMapping(value = "/no_right")
  208. 	public String noRight() {
  209. 		return "admin/system/no_right";
  210. 	}
  211.  
  212. 	/**
  213. 	 * 修改用户个人信息
  214. 	 *
  215. 	 * @return
  216. 	 */
  217. 	@RequestMapping(value = "/update_userinfo", method = RequestMethod.GET)
  218. 	public String updateUserInfo() {
  219. 		return "admin/system/update_userinfo";
  220. 	}
  221.  
  222. 	/**
  223. 	 * 修改个人信息保存
  224. 	 *
  225. 	 * @param user
  226. 	 * @return
  227. 	 */
  228. 	@RequestMapping(value = "/update_userinfo", method = RequestMethod.POST)
  229. 	public String updateUserInfo(User user) {
  230. 		User loginedUser = SessionUtil.getLoginedUser();
  231. 		Role role = loginedUser.getRole();
  232.  
  233. 		if (role.getRoleType() == RoleType.ELECTRICIAN) {
  234. 			Emp emp = empService.find(loginedUser.getId());
  235. 			emp.setEmail(user.getEmail());
  236. 			emp.setMobile(user.getMobile());
  237. 			emp.setHeadPic(user.getHeadPic());
  238. 			empService.save(emp);
  239. 			loginedUser.setEmail(user.getEmail());
  240. 			loginedUser.setMobile(user.getMobile());
  241. 			loginedUser.setHeadPic(user.getHeadPic());
  242. 		} else if (role.getRoleType() == RoleType.STUDENT) {
  243. 			Student student = studentService.findByID(loginedUser.getId());
  244. 			student.setEmail(user.getEmail());
  245. 			student.setMobile(user.getMobile());
  246. 			student.setHeadPic(user.getHeadPic());
  247. 			studentService.save(student);
  248. 			loginedUser.setEmail(user.getEmail());
  249. 			loginedUser.setMobile(user.getMobile());
  250. 			loginedUser.setHeadPic(user.getHeadPic());
  251. 		} else {
  252. 			loginedUser.setEmail(user.getEmail());
  253. 			loginedUser.setMobile(user.getMobile());
  254. 			loginedUser.setHeadPic(user.getHeadPic());
  255. 			userService.save(loginedUser);
  256. 		}
  257.  
  258.  
  259. 		//更新session里的值
  260. 		SessionUtil.set(SessionConstant.SESSION_USER_LOGIN_KEY, loginedUser);
  261. 		return "redirect:update_userinfo";
  262. 	}
  263.  
  264. 	/**
  265. 	 * 修改密码页面
  266. 	 *
  267. 	 * @return
  268. 	 */
  269. 	@RequestMapping(value = "/update_pwd", method = RequestMethod.GET)
  270. 	public String updatePwd() {
  271. 		return "admin/system/update_pwd";
  272. 	}
  273.  
  274. 	/**
  275. 	 * 修改密码表单提交
  276. 	 *
  277. 	 * @param oldPwd
  278. 	 * @param newPwd
  279. 	 * @return
  280. 	 */
  281. 	@RequestMapping(value = "/update_pwd", method = RequestMethod.POST)
  282. 	@ResponseBody
  283. 	public Result<Boolean> updatePwd(@RequestParam(name = "oldPwd", required = true) String oldPwd,
  284. 	                                 @RequestParam(name = "newPwd", required = true) String newPwd
  285. 	) {
  286.  
  287. 		if (newPwd.length() < 4 || newPwd == null) {
  288. 			return Result.error(CodeMsg.ADMIN_UPDATE_PWD_ERROR);
  289. 		}
  290.  
  291. 		User loginedUser = SessionUtil.getLoginedUser();
  292. 		Role role = loginedUser.getRole();
  293. 		if (!loginedUser.getPassword().equals(oldPwd)) {
  294. 			return Result.error(CodeMsg.ADMIN_USER_UPDATE_PWD_ERROR);
  295. 		}
  296. 		if (StringUtils.isEmpty(newPwd)) {
  297. 			return Result.error(CodeMsg.ADMIN_USER_UPDATE_PWD_EMPTY);
  298. 		}
  299. 		loginedUser.setPassword(newPwd);
  300. 		if (role.getRoleType() == RoleType.ELECTRICIAN) {
  301. 			Emp emp = empService.find(loginedUser.getId());
  302. 			emp.setPassword(newPwd);
  303. 			empService.save(emp);
  304. 		} else if (role.getRoleType() == RoleType.STUDENT) {
  305. 			Student student = studentService.findByID(loginedUser.getId());
  306. 			student.setPassword(newPwd);
  307. 			studentService.save(student);
  308. 		} else {
  309. 			userService.save(loginedUser);
  310. 		}
  311.  
  312.  
  313. 		//保存数据库
  314.  
  315.  
  316. 		//更新session
  317. 		SessionUtil.set(SessionConstant.SESSION_USER_LOGIN_KEY, loginedUser);
  318. 		return Result.success(true);
  319. 	}
  320.  
  321. 	/**
  322. 	 * 日志管理列表
  323. 	 *
  324. 	 * @param model
  325. 	 * @param operaterLog
  326. 	 * @param pageBean
  327. 	 * @return
  328. 	 */
  329. 	@RequestMapping(value = "/operator_log_list")
  330. 	public String operatorLogList(Model model, OperaterLog operaterLog, PageBean<OperaterLog> pageBean) {
  331. 		model.addAttribute("pageBean", operaterLogService.findList(operaterLog, pageBean));
  332. 		model.addAttribute("operator", operaterLog.getOperator());
  333. 		model.addAttribute("title", "日志列表");
  334. 		return "admin/system/operator_log_list";
  335. 	}
  336.  
  337. 	/**
  338. 	 * 删除操作日志，可删除多个
  339. 	 *
  340. 	 * @param ids
  341. 	 * @return
  342. 	 */
  343. 	@RequestMapping(value = "/delete_operator_log", method = RequestMethod.POST)
  344. 	@ResponseBody
  345. 	public Result<Boolean> delete(String ids) {
  346. 		if (!StringUtils.isEmpty(ids)) {
  347. 			String[] splitIds = ids.split(",");
  348. 			for (String id : splitIds) {
  349. 				operaterLogService.delete(Long.valueOf(id));
  350. 			}
  351. 		}
  352. 		return Result.success(true);
  353. 	}
  354.  
  355. 	/**
  356. 	 * 清空整个日志
  357. 	 *
  358. 	 * @return
  359. 	 */
  360. 	@RequestMapping(value = "/delete_all_operator_log", method = RequestMethod.POST)
  361. 	@ResponseBody
  362. 	public Result<Boolean> deleteAll() {
  363. 		operaterLogService.deleteAll();
  364. 		return Result.success(true);
  365. 	}
  366. }

后台角色管理控制器:

  1. /**
  2.  * 后台角色管理控制器
  3.  * @author yy
  4.  *
  5.  */
  6. @RequestMapping("/role")
  7. @Controller
  8. public class RoleController {
  9.  
  10. 	
  11. 	private Logger log = LoggerFactory.getLogger(RoleController.class);
  12. 	
  13. 	@Autowired
  14. 	private MenuService menuService;
  15. 	
  16. 	@Autowired
  17. 	private OperaterLogService operaterLogService;
  18. 	
  19. 	@Autowired
  20. 	private RoleService roleService;
  21. 	
  22. 	/**
  23. 	 * 分页搜索角色列表
  24. 	 * @param model
  25. 	 * @param role
  26. 	 * @param pageBean
  27. 	 * @return
  28. 	 */
  29. 	@RequestMapping(value="/list")
  30. 	public String list(Model model,Role role,PageBean<Role> pageBean){
  31. 		model.addAttribute("title", "角色列表");
  32. 		model.addAttribute("name", role.getName());
  33. 		model.addAttribute("pageBean", roleService.findByName(role, pageBean));
  34. 		return "admin/role/list";
  35. 	}
  36. 	
  37. 	/**
  38. 	 * 角色添加页面
  39. 	 * @param model
  40. 	 * @return
  41. 	 */
  42. 	@RequestMapping(value="/add",method=RequestMethod.GET)
  43. 	public String add(Model model){
  44. 		List<Menu> findAll = menuService.findAll();
  45. 		model.addAttribute("roleTypes", RoleType.values());
  46. 		model.addAttribute("topMenus",MenuUtil.getTopMenus(findAll));
  47. 		model.addAttribute("secondMenus",MenuUtil.getSecondMenus(findAll));
  48. 		model.addAttribute("thirdMenus",MenuUtil.getThirdMenus(findAll));
  49. 		return "admin/role/add";
  50. 	}
  51. 	
  52. 	/**
  53. 	 * 角色添加表单提交处理
  54. 	 * @param role
  55. 	 * @return
  56. 	 */
  57. 	@RequestMapping(value="/add",method=RequestMethod.POST)
  58. 	@ResponseBody
  59. 	public Result<Boolean> add(Role role){
  60. 		//用统一验证实体方法验证是否合法
  61. 		CodeMsg validate = ValidateEntityUtil.validate(role);
  62. 		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
  63. 			return Result.error(validate);
  64. 		}
  65. 		if(roleService.save(role) == null){
  66. 			return Result.error(CodeMsg.ADMIN_ROLE_ADD_ERROR);
  67. 		}
  68. 		log.info("添加角色【"+role+"】");
  69. 		operaterLogService.add("添加角色【"+role.getName()+"】");
  70. 		return Result.success(true);
  71. 	}
  72. 	
  73. 	/**
  74. 	 * 角色编辑页面
  75. 	 * @param id
  76. 	 * @param model
  77. 	 * @return
  78. 	 */
  79. 	@RequestMapping(value="/edit",method=RequestMethod.GET)
  80. 	public String edit(@RequestParam(name="id",required=true)Long id,Model model){
  81. 		List<Menu> findAll = menuService.findAll();
  82. 		model.addAttribute("topMenus",MenuUtil.getTopMenus(findAll));
  83. 		model.addAttribute("secondMenus",MenuUtil.getSecondMenus(findAll));
  84. 		model.addAttribute("thirdMenus",MenuUtil.getThirdMenus(findAll));
  85. 		Role role = roleService.find(id);
  86. 		model.addAttribute("role", role);
  87. 		model.addAttribute("authorities",JSONArray.toJSON(role.getAuthorities()).toString());
  88. 		return "admin/role/edit";
  89. 	}
  90. 	
  91. 	/**
  92. 	 * 角色修改表单提交处理
  93. 	 * @param request
  94. 	 * @param role
  95. 	 * @return
  96. 	 */
  97. 	@RequestMapping(value="/edit",method=RequestMethod.POST)
  98. 	@ResponseBody
  99. 	public Result<Boolean> edit(Role role){
  100. 		//用统一验证实体方法验证是否合法
  101. 		CodeMsg validate = ValidateEntityUtil.validate(role);
  102. 		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
  103. 			return Result.error(validate);
  104. 		}
  105. 		Role existRole = roleService.find(role.getId());
  106. 		if(existRole == null){
  107. 			return Result.error(CodeMsg.ADMIN_ROLE_NO_EXIST);
  108. 		}
  109. 		existRole.setName(role.getName());
  110. 		existRole.setRemark(role.getRemark());
  111. 		existRole.setStatus(role.getStatus());
  112. 		existRole.setAuthorities(role.getAuthorities());
  113. 		if(roleService.save(existRole) == null){
  114. 			return Result.error(CodeMsg.ADMIN_ROLE_EDIT_ERROR);
  115. 		}
  116. 		log.info("编辑角色【"+role+"】");
  117. 		operaterLogService.add("编辑角色【"+role.getName()+"】");
  118. 		return Result.success(true);
  119. 	}
  120. 	
  121. 	/**
  122. 	 * 删除角色
  123. 	 * @param request
  124. 	 * @param id
  125. 	 * @return
  126. 	 */
  127. 	@RequestMapping(value="delete",method=RequestMethod.POST)
  128. 	@ResponseBody
  129. 	public Result<Boolean> delete(@RequestParam(name="id",required=true)Long id){
  130. 		try {
  131. 			roleService.delete(id);
  132. 		} catch (Exception e) {
  133. 			// TODO: handle exception
  134. 			return Result.error(CodeMsg.ADMIN_ROLE_DELETE_ERROR);
  135. 		}
  136. 		log.info("编辑角色ID【"+id+"】");
  137. 		operaterLogService.add("删除角色ID【"+id+"】");
  138. 		return Result.success(true);
  139. 	}
  140. }

源码获取：俺的博客首页 "资源" 里下载！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小舞很执着/article/detail/858085
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号