• 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.数据库：MySql 5.7版本；

    6.是否Maven项目：是；

    技术栈

    1. 后端：Spring+SpringMVC+Mybatis

    2. 前端：HTML+CSS+JavaScript+jquery+bootstrap

    使用说明

    1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件；

    2. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;

    若为maven项目，导入成功后请执行maven clean;maven install命令，然后运行；

    3. 将项目中db.properties配置文件中的数据库配置改为自己的配置;

    4. 运行项目，输入localhost:8080/ssm_xueyeyujing_sys 登录

    运行截图

     

     

     

     

     

     

     

     

     

     代码相关

    出勤控制器

    1. package com.learn.controller;
    2.  
    3. import java.util.List;
    4. import java.util.Map;
    5.  
    6. import org.apache.shiro.authz.annotation.RequiresPermissions;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.web.bind.annotation.PathVariable;
    9. import org.springframework.web.bind.annotation.RequestBody;
    10. import org.springframework.web.bind.annotation.RequestMapping;
    11. import org.springframework.web.bind.annotation.RequestParam;
    12. import org.springframework.web.bind.annotation.RestController;
    13.  
    14. import com.learn.entity.ChuqinEntity;
    15. import com.learn.service.ChuqinService;
    16. import com.learn.utils.PageUtils;
    17. import com.learn.utils.Query;
    18. import com.learn.utils.R;
    19.  
    20.  
    21. /**
    22.  * 出勤信息
    23.  * 
    24.  * @author chenshun
    25.  * @email sunlightcs@gmail.com
    26.  * @date 2020-04-01 16:42:55
    27.  */
    28. @RestController
    29. @RequestMapping("chuqin")
    30. public class ChuqinController extends AbstractController {
    31. 	@Autowired
    32. 	private ChuqinService chuqinService;
    33. 	
    34. 	/**
    35. 	 * 列表
    36. 	 */
    37. 	@RequestMapping("/list")
    38. 	public R list(@RequestParam Map params){
    39.  
    40. 															                if (super.getUserId() > 1)
    41.                     params.put("user", super.getUserId());
    42. 																				
    43.  
    44. 		//查询列表数据
    45.         Query query = new Query(params);
    46.  
    47. 		List chuqinList = chuqinService.queryList(query);
    48. 		int total = chuqinService.queryTotal(query);
    49. 		
    50. 		PageUtils pageUtil = new PageUtils(chuqinList, total, query.getLimit(), query.getPage());
    51. 		
    52. 		return R.ok().put("page", pageUtil);
    53. 	}
    54. 	
    55.  
    56. 	/**
    57. 	 * 列表
    58. 	 */
    59. 	@RequestMapping("/list2")
    60. 	public R list2(@RequestParam Map params){
    61.         Query query = new Query(params);
    62. 		List chuqinList = chuqinService.queryList(query);
    63. 		return R.ok().put("list", chuqinList );
    64. 	}
    65.  
    66.  
    67. 	/**
    68. 	 * 信息
    69. 	 */
    70. 	@RequestMapping("/info/{id}")
    71. 	public R info(@PathVariable("id") Long id){
    72. 		ChuqinEntity chuqin = chuqinService.queryObject(id);
    73. 		
    74. 		return R.ok().put("chuqin", chuqin);
    75. 	}
    76. 	
    77. 	/**
    78. 	 * 保存
    79. 	 */
    80. 	@RequestMapping("/save")
    81. 	public R save(@RequestBody ChuqinEntity chuqin){
    82.  
    83. 															                if (chuqin.getUser() == null)
    84.                     chuqin.setUser(super.getUserId());
    85. 																				
    86.  
    87.         chuqinService.save(chuqin);
    88. 		
    89. 		return R.ok();
    90. 	}
    91. 	
    92. 	/**
    93. 	 * 修改
    94. 	 */
    95. 	@RequestMapping("/update")
    96. 	public R update(@RequestBody ChuqinEntity chuqin){
    97. 		chuqinService.update(chuqin);
    98. 		
    99. 		return R.ok();
    100. 	}
    101. 	
    102. 	/**
    103. 	 * 删除
    104. 	 */
    105. 	@RequestMapping("/delete")
    106. 	public R delete(@RequestBody Long[] ids){
    107. 		chuqinService.deleteBatch(ids);
    108. 		
    109. 		return R.ok();
    110. 	}
    111. 	
    112. }

    课程控制器

    1. package com.learn.controller;
    2.  
    3. import java.util.List;
    4. import java.util.Map;
    5.  
    6. import org.apache.shiro.authz.annotation.RequiresPermissions;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.web.bind.annotation.PathVariable;
    9. import org.springframework.web.bind.annotation.RequestBody;
    10. import org.springframework.web.bind.annotation.RequestMapping;
    11. import org.springframework.web.bind.annotation.RequestParam;
    12. import org.springframework.web.bind.annotation.RestController;
    13.  
    14. import com.learn.entity.CourseEntity;
    15. import com.learn.service.CourseService;
    16. import com.learn.utils.PageUtils;
    17. import com.learn.utils.Query;
    18. import com.learn.utils.R;
    19.  
    20.  
    21. /**
    22.  * 课程信息
    23.  * 
    24.  * @author chenshun
    25.  * @email sunlightcs@gmail.com
    26.  * @date 2020-04-01 16:42:55
    27.  */
    28. @RestController
    29. @RequestMapping("course")
    30. public class CourseController extends AbstractController {
    31. 	@Autowired
    32. 	private CourseService courseService;
    33. 	
    34. 	/**
    35. 	 * 列表
    36. 	 */
    37. 	@RequestMapping("/list")
    38. 	public R list(@RequestParam Map params){
    39.  
    40. 																																
    41.  
    42. 		//查询列表数据
    43.         Query query = new Query(params);
    44.  
    45. 		List courseList = courseService.queryList(query);
    46. 		int total = courseService.queryTotal(query);
    47. 		
    48. 		PageUtils pageUtil = new PageUtils(courseList, total, query.getLimit(), query.getPage());
    49. 		
    50. 		return R.ok().put("page", pageUtil);
    51. 	}
    52. 	
    53.  
    54. 	/**
    55. 	 * 列表
    56. 	 */
    57. 	@RequestMapping("/list2")
    58. 	public R list2(@RequestParam Map params){
    59.         Query query = new Query(params);
    60. 		List courseList = courseService.queryList(query);
    61. 		return R.ok().put("list", courseList );
    62. 	}
    63.  
    64.  
    65. 	/**
    66. 	 * 信息
    67. 	 */
    68. 	@RequestMapping("/info/{id}")
    69. 	public R info(@PathVariable("id") Long id){
    70. 		CourseEntity course = courseService.queryObject(id);
    71. 		
    72. 		return R.ok().put("course", course);
    73. 	}
    74. 	
    75. 	/**
    76. 	 * 保存
    77. 	 */
    78. 	@RequestMapping("/save")
    79. 	public R save(@RequestBody CourseEntity course){
    80.  
    81. 																																
    82.  
    83.         courseService.save(course);
    84. 		
    85. 		return R.ok();
    86. 	}
    87. 	
    88. 	/**
    89. 	 * 修改
    90. 	 */
    91. 	@RequestMapping("/update")
    92. 	public R update(@RequestBody CourseEntity course){
    93. 		courseService.update(course);
    94. 		
    95. 		return R.ok();
    96. 	}
    97. 	
    98. 	/**
    99. 	 * 删除
    100. 	 */
    101. 	@RequestMapping("/delete")
    102. 	public R delete(@RequestBody Long[] ids){
    103. 		courseService.deleteBatch(ids);
    104. 		
    105. 		return R.ok();
    106. 	}
    107. 	
    108. }

    登录控制器

    1. package com.learn.controller;
    2.  
    3. import com.learn.entity.SysUserEntity;
    4. import com.learn.service.SysUserService;
    5. import com.learn.utils.R;
    6. import com.learn.utils.ShiroUtils;
    7.  
    8. import java.awt.image.BufferedImage;
    9. import java.io.IOException;
    10. import java.util.ArrayList;
    11. import java.util.List;
    12.  
    13. import javax.imageio.ImageIO;
    14. import javax.servlet.ServletException;
    15. import javax.servlet.ServletOutputStream;
    16. import javax.servlet.http.HttpServletResponse;
    17.  
    18. import org.apache.shiro.authc.AuthenticationException;
    19. import org.apache.shiro.authc.IncorrectCredentialsException;
    20. import org.apache.shiro.authc.LockedAccountException;
    21. import org.apache.shiro.authc.UnknownAccountException;
    22. import org.apache.shiro.authc.UsernamePasswordToken;
    23. import org.apache.shiro.crypto.hash.Sha256Hash;
    24. import org.apache.shiro.subject.Subject;
    25. import org.springframework.beans.factory.annotation.Autowired;
    26. import org.springframework.stereotype.Controller;
    27. import org.springframework.web.bind.annotation.RequestMapping;
    28. import org.springframework.web.bind.annotation.RequestMethod;
    29. import org.springframework.web.bind.annotation.ResponseBody;
    30.  
    31. import com.google.code.kaptcha.Constants;
    32. import com.google.code.kaptcha.Producer;
    33.  
    34. /**
    35.  * 登录相关
    36.  *
    37.  * @author chenshun
    38.  * @email sunlightcs@gmail.com
    39.  * @date 2018年11月10日 下午1:15:31
    40.  */
    41. @Controller
    42. public class SysLoginController {
    43.     @Autowired
    44.     private Producer producer;
    45.  
    46.     @Autowired
    47.     private SysUserService sysUserService;
    48.  
    49.     @RequestMapping("captcha.jpg")
    50.     public void captcha(HttpServletResponse response) throws ServletException, IOException {
    51.         response.setHeader("Cache-Control", "no-store, no-cache");
    52.         response.setContentType("image/jpeg");
    53.  
    54.         //生成文字验证码
    55.         String text = producer.createText();
    56.         //生成图片验证码
    57.         BufferedImage image = producer.createImage(text);
    58.         //保存到shiro session
    59.         ShiroUtils.setSessionAttribute(Constants.KAPTCHA_SESSION_KEY, text);
    60.  
    61.         ServletOutputStream out = response.getOutputStream();
    62.         ImageIO.write(image, "jpg", out);
    63.     }
    64.  
    65.     /**
    66.      * 登录
    67.      */
    68.     @ResponseBody
    69.     @RequestMapping(value = "/sys/login", method = RequestMethod.POST)
    70.     public R login(String username, String password, String captcha) throws IOException {
    71. //		String kaptcha = ShiroUtils.getKaptcha(Constants.KAPTCHA_SESSION_KEY);
    72. //		if(!captcha.equalsIgnoreCase(kaptcha)){
    73. //			return R.error("验证码不正确");
    74. //		}
    75.  
    76.         try {
    77.             Subject subject = ShiroUtils.getSubject();
    78.             //sha256加密
    79.             password = new Sha256Hash(password).toHex();
    80.             UsernamePasswordToken token = new UsernamePasswordToken(username, password);
    81.             subject.login(token);
    82.         } catch (UnknownAccountException e) {
    83.             return R.error(e.getMessage());
    84.         } catch (IncorrectCredentialsException e) {
    85.             return R.error(e.getMessage());
    86.         } catch (LockedAccountException e) {
    87.             return R.error(e.getMessage());
    88.         } catch (AuthenticationException e) {
    89.             return R.error("账户验证失败");
    90.         }
    91.  
    92.         return R.ok();
    93.     }
    94.  
    95.  
    96.     /**
    97.      */
    98.     @ResponseBody
    99.     @RequestMapping(value = "/sys/reg", method = RequestMethod.POST)
    100.     public R reg(String username, String password, String captcha) throws IOException {
    101. //		String kaptcha = ShiroUtils.getKaptcha(Constants.KAPTCHA_SESSION_KEY);
    102. //		if(!captcha.equalsIgnoreCase(kaptcha)){
    103. //			return R.error("验证码不正确");
    104. //		}
    105.  
    106.         //sha256加密
    107.         SysUserEntity user = new SysUserEntity();
    108.         user.setUsername(username);
    109.         user.setPassword(password);
    110.         user.setStatus(1);
    111.  
    112.         List roles = new ArrayList<>();
    113.         roles.add(1L);
    114.  
    115.         user.setRoleIdList(roles);
    116.  
    117.         this.sysUserService.save(user);
    118.  
    119.         return R.ok();
    120.     }
    121.  
    122.     /**
    123.      * 退出
    124.      */
    125.     @RequestMapping(value = "logout", method = RequestMethod.GET)
    126.     public String logout() {
    127.         ShiroUtils.logout();
    128.         return "redirect:login.html";
    129.     }
    130.  
    131. }

    用户控制器

    1. package com.learn.controller;
    2.  
    3. import com.learn.entity.SysUserEntity;
    4. import com.learn.service.SysUserRoleService;
    5. import com.learn.service.SysUserService;
    6. import com.learn.utils.PageUtils;
    7. import com.learn.utils.Query;
    8. import com.learn.utils.R;
    9. import com.learn.utils.ShiroUtils;
    10. import org.apache.commons.lang.ArrayUtils;
    11. import org.apache.shiro.crypto.hash.Sha256Hash;
    12. import org.springframework.beans.factory.annotation.Autowired;
    13. import org.springframework.web.bind.annotation.*;
    14.  
    15. import java.util.List;
    16. import java.util.Map;
    17.  
    18. /**
    19.  * 系统用户
    20.  *
    21.  * @author chenshun
    22.  * @email sunlightcs@gmail.com
    23.  * @date 2018年10月31日 上午10:40:10
    24.  */
    25. @RestController
    26. @RequestMapping("/sys/user")
    27. public class SysUserController extends AbstractController {
    28.     @Autowired
    29.     private SysUserService sysUserService;
    30.     @Autowired
    31.     private SysUserRoleService sysUserRoleService;
    32.  
    33.     /**
    34.      * 所有用户列表
    35.      */
    36.     @RequestMapping("/list")
    37.     public R list(@RequestParam Map params) {
    38.  
    39.         //查询列表数据
    40.         Query query = new Query(params);
    41.         List userList = sysUserService.queryList(query);
    42.         int total = sysUserService.queryTotal(query);
    43.  
    44.         PageUtils pageUtil = new PageUtils(userList, total, query.getLimit(), query.getPage());
    45.  
    46.         return R.ok().put("page", pageUtil);
    47.     }
    48.  
    49.     @RequestMapping("/list2")
    50.     public R list2(@RequestParam Map params) {
    51.  
    52.         //查询列表数据
    53.         Query query = new Query(params);
    54.         List userList = sysUserService.queryList(query);
    55.  
    56.         return R.ok().put("list", userList);
    57.     }
    58.  
    59.     /**
    60.      * 获取登录的用户信息
    61.      */
    62.     @RequestMapping("/info")
    63.     public R info() {
    64.         return R.ok().put("user", this.sysUserService.queryObject(getUser().getUserId()));
    65.     }
    66.  
    67.     /**
    68.      * 修改登录用户密码
    69.      */
    70.     @RequestMapping("/password")
    71.     public R password(String password, String newPassword) {
    72.  
    73.         //sha256加密
    74.         password = new Sha256Hash(password).toHex();
    75.         //sha256加密
    76.         newPassword = new Sha256Hash(newPassword).toHex();
    77.  
    78.         //更新密码
    79.         int count = sysUserService.updatePassword(getUserId(), password, newPassword);
    80.         if (count == 0) {
    81.             return R.error("原密码不正确");
    82.         }
    83.  
    84.         //退出
    85.         ShiroUtils.logout();
    86.  
    87.         return R.ok();
    88.     }
    89.  
    90.     @RequestMapping("/updateInfo")
    91.     public R updateInfo(@RequestBody SysUserEntity user) {
    92.         this.sysUserService.update(user);
    93.         return R.ok();
    94.     }
    95.  
    96.     /**
    97.      * 用户信息
    98.      */
    99.     @RequestMapping("/info/{userId}")
    100.     public R info(@PathVariable("userId") Long userId) {
    101.         SysUserEntity user = sysUserService.queryObject(userId);
    102.  
    103.         //获取用户所属的角色列表
    104.         List roleIdList = sysUserRoleService.queryRoleIdList(userId);
    105.         user.setRoleIdList(roleIdList);
    106.  
    107.         return R.ok().put("user", user);
    108.     }
    109.  
    110.     /**
    111.      * 保存用户
    112.      */
    113.     @RequestMapping("/save")
    114.     public R save(@RequestBody SysUserEntity user) {
    115.  
    116.         user.setCreateUserId(getUserId());
    117.         sysUserService.save(user);
    118.  
    119.         return R.ok();
    120.     }
    121.  
    122.     /**
    123.      * 修改用户
    124.      */
    125.     @RequestMapping("/update")
    126.     public R update(@RequestBody SysUserEntity user) {
    127.  
    128.         user.setCreateUserId(getUserId());
    129.         sysUserService.update(user);
    130.  
    131.         return R.ok();
    132.     }
    133.  
    134.     /**
    135.      * 删除用户
    136.      */
    137.     @RequestMapping("/delete")
    138.     public R delete(@RequestBody Long[] userIds) {
    139.         if (ArrayUtils.contains(userIds, 1L) || ArrayUtils.contains(userIds, -1L)) {
    140.             return R.error("系统管理员不能删除");
    141.         }
    142.  
    143.         if (ArrayUtils.contains(userIds, getUserId())) {
    144.             return R.error("当前用户不能删除");
    145.         }
    146.  
    147.         sysUserService.deleteBatch(userIds);
    148.  
    149.         return R.ok();
    150.     }
    151. }

    如果也想学习本系统，下面领取。关注并回复：156ssm

  • 相关阅读:
    woocommerce虚拟商品和可下载商品介绍
    MySQL字符串合并
    thingsboard IoT gateway OPC-UA 连接器配置
    TRIZ理论下攀爬机器人的创新设计与研究
    MT6701磁编码器使用指南，14Bit单圈绝对值，I2C stm32 HAL库读角度
    工控产线安全该如何进行系统加固
    一文详解GaussDB(DWS) 的并发管控和内存管控
    排序算法（一）
    【JAVA学习笔记】64 - 坦克大战1.4，限制坦克发射子弹，敌方击中我方坦克爆炸
    Docker常规操作命令（常用）
  • 原文地址：https://blog.csdn.net/hanyunlong1989/article/details/126474622