Java项目:少儿体能训练在线课程预约系统(java+SpringBoot+Mysql)

主要实现了以下功能：

分四个角色后台的管理员和教练，前台的用户以及普通的游客（未登录的用户为游客）：

1、管理员的功能脚手架之外的实现的有器材管理，教练管理，学员管理，课程管理，项目管理，课程班级管理，报名管理，训练计划管理，新闻管理，前台用户管理，关于我们管理，常见问题管理

（1）器材管理实现了对健身器材的管理，器材总类，数量等的管理；教练对器材的申请发放和报损的操作
（2）教练管理实现了对教练的增删改查的管理
（3）学员管理实现了前台用户报名的学员信息查看
（4）课程管理实现了不同课程的管理比如课程天数，学生年龄范围，可以安排不同的项目和教练等，
（5）项目管理实现了健身项目的管理，器材可以在分配给不同的项目
（6）课程班级管理实现了对课程进行发布班级，一次一个课程只能发布一个班级，发布前台用户可以进行报名，
课程会通过定时器在结束时间当天结束该班级课程，该班级课程学员报名未进行审核的会自动全部失败，
该课程安排的教练会自动清空，该班级课程教练器材申请的发放也会自动失效
（7）报名管理实现了前台用户对学员报名的审核
（8）训练计划管理实现了对不同课程类型的发布不同的训练计划，会在前台该类型的课程进行展示
（9）新闻管理实现了对新闻的发布和删除功能，会在前台新闻里面进行展示
（10）前台用户管理实现了对用户的信息查看和拉黑功能
（11）关于我们管理实现了健身房的信息管理，可以发布多条，只显示第一条。在前台关于我们展示
（12）网页设置管理实现了前台首页轮播图的管理
（13）常见问题实现了对常见问题的增删改查在，在前台首页展示

2、教练登录实现的功能有教练管理，密码修改，授课管理

（1）教练管理实现了个人信息的管理
（2）授课管理分为当前授课和授课记录
当前授课实现了当前教学的课程班级的管理，主要实现功能有对该班级课程的项目下的器材的申请数量和报损，
添加不同的测试，对该班级课程的测试对不同的学员进行打分，还有对不同学员的奖惩信息管理等
授课记录实现了以往的教学的课程，可以查看以往课程教学的学员

3.前台用户功能有注册登录，个人中心管理，学员管理，课程报名管理

（1）个人中心实现了个人信息的管理，修改密码
（2）学员管理实现了查看报名学员的信息
         主要实现了报名记录和上课记录两部分
         A、报名记录实现了该学员对课程班级报名过的状态成功或者失败
         B、上课记录实现了该学员对课程班级的测试成绩和奖惩信息的查看

（3）课程报名管理实现了对后台课程班级管理发布班级后可以报名的课程进行报名

4.前台游客（未登录的用户）实现了前台首页，课程，新闻咨询，教练团队，等等信息的浏览

特色功能：可在线预约课程，选教练，发布课程测试奖惩等。

运行环境：jdk1.8、eclipse/idea、Mysql5.7、Navicat/Sqlyog、Maven3.5/3.6

 

 

 

 

 

用户管理控制器：

/**
 * 用户管理控制器
 */
@RequestMapping("/user/")
@Controller
public class UserController {
    @Autowired
    private IUserService userService;
    @Autowired
    private IRoleService roleService;

    @Resource
    private ProcessEngineConfiguration configuration;
    @Resource
    private ProcessEngine engine;

    @GetMapping("/index")
    @ApiOperation("跳转用户页接口")
    @PreAuthorize("hasRole('管理员')")
    public String index(String menuid,Model model){
        List<Role> roles = queryAllRole();
        model.addAttribute("roles",roles);
        model.addAttribute("menuid",menuid);
        //用户首页
        return "views/user/user_list";
    }

    @GetMapping("/listpage")
    @ApiOperation("查询用户分页数据接口")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "UserQuery", value = "用户查询对象", defaultValue = "userQuery对象")
    })
    @ResponseBody
    @PreAuthorize("hasRole('管理员')")
    public PageList listpage(UserQuery userQuery){
        return  userService.listpage(userQuery);
    }

    //添加用户
    @PostMapping("/addUser")
    @ApiOperation("添加用户接口")
    @ResponseBody
    public Map<String,Object> addUser(User user){
        Map<String, Object> ret = new HashMap<>();
        ret.put("code",-1);
        if(StringUtils.isEmpty(user.getUsername())){
            ret.put("msg","请填写用户名");
            return ret;
        }
        if(StringUtils.isEmpty(user.getPassword())){
            ret.put("msg","请填写密码");
            return ret;
        }
        if(StringUtils.isEmpty(user.getEmail())){
            ret.put("msg","请填写邮箱");
            return ret;
        }
        if(StringUtils.isEmpty(user.getTel())){
            ret.put("msg","请填写手机号");
            return ret;
        }
        if(StringUtils.isEmpty(user.getHeadImg())){
            ret.put("msg","请上传头像");
            return ret;
        }
        if(userService.addUser(user)<=0) {
            ret.put("msg", "添加用户失败");
            return ret;
        }
        ret.put("code",0);
        ret.put("msg","添加用户成功");
        return ret;
    }

    /**
     * 修改用户信息操作
     * @param user
     * @return
     */
    @PostMapping("/editSaveUser")
    @ApiOperation("修改用户接口")
    @PreAuthorize("hasRole('管理员')")
    @ResponseBody
    public Message editSaveUser(User user){
        if(StringUtils.isEmpty(user.getUsername())){
          return Message.error("请填写用户名");
        }
        if(StringUtils.isEmpty(user.getEmail())){
            return Message.error("请填写邮箱");
        }
        if(StringUtils.isEmpty(user.getTel())){
            return Message.error("请填写手机号");
        }
        try {
            userService.editSaveUser(user);
            return Message.success();
        } catch (Exception e) {
            e.printStackTrace();
            return Message.error("修改用户信息失败");
        }

    }

    //添加用户
    @GetMapping("/deleteUser")
    @ApiOperation("删除用户接口")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "如:88",required = true)
    })
    @PreAuthorize("hasRole('管理员')")
    @ResponseBody
    public AjaxResult deleteUser(@RequestParam(required = true) Long id){
        AjaxResult ajaxResult = new AjaxResult();
        try {
            userService.deleteUser(id);
        } catch (Exception e) {
            e.printStackTrace();
            return new AjaxResult("删除失败");
        }

        return ajaxResult;
    }

    @PostMapping(value="/deleteBatchUser")
    @ApiOperation("批量删除用户接口")
    @PreAuthorize("hasRole('管理员')")
    @ResponseBody
    public AjaxResult deleteBatchUser(String ids){
        String[] idsArr = ids.split(",");
        List list = new ArrayList();
        for(int i=0;i<idsArr.length;i++){
            list.add(idsArr[i]);
        }
        try{
            userService.batchRemove(list);
            return new AjaxResult();
        }catch(Exception e){
           return new AjaxResult("批量删除失败");
        }
    }

    //查询所有角色
    public List<Role> queryAllRole(){
        return roleService.queryAll();
    }

    //添加用户的角色
    @PostMapping("/addUserRole")
    @ApiOperation("添加用户角色接口")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "paramMap", value = "如:{userId:1,[1,2,3,4]]}")
    })
    @ResponseBody
    public AjaxResult addUserRole(@RequestBody Map paramMap){
        AjaxResult ajaxResult = new AjaxResult();
        String userId = (String)paramMap.get("userId");
        List roleIds = (List) paramMap.get("roleIds");
        try {
            //添加用户对应的角色
            roleService.addUserRole(userId,roleIds);
            return ajaxResult;
        }catch (Exception e){
            e.printStackTrace();
            return new AjaxResult("保存角色失败");
        }

    }




    //添加用户
    @RequestMapping("/regSaveUser")
    @ResponseBody
    public Long addTeacher(User user){
        System.out.println("保存用户...."+user);
        userService.addUser(user);

        //保存工作流程操作
        IdentityService is = engine.getIdentityService();
        // 添加用户组
        org.activiti.engine.identity.User userInfo = userService.saveUser(is, user.getUsername());
        // 添加用户对应的组关系
        Group stuGroup = new GroupEntityImpl();
        stuGroup.setId("stuGroup");
        Group tGroup = new GroupEntityImpl();
        tGroup.setId("tGroup");
        if(user.getType() == 2) {
            //保存老师组
            userService.saveRel(is, userInfo, tGroup);
        }
        if(user.getType() == 3) {
            //保存学生组
            userService.saveRel(is, userInfo, stuGroup);
        }

        Long userId = user.getId();
        return userId;
    }

    /**
     * 修改密码页面
     * @return
     */
    @RequestMapping(value="/update_pwd",method=RequestMethod.GET)
    public String updatePwd(){
        return "views/user/update_pwd";
    }

    /**
     * 修改密码操作
     * @param oldPwd
     * @param newPwd
     * @return
     */
    @ResponseBody
    @PostMapping("/update_pwd")
    public Message updatePassword(@RequestParam(name="oldPwd",required=true)String oldPwd,
                                  @RequestParam(name="newPwd",required=true)String newPwd){
        String username = CommonUtils.getLoginUser().getUsername();
        User userByUserName = userService.findUserByUserName(username);
        if(userByUserName!=null){
            String password = userByUserName.getPassword();
            BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
            boolean matches = bCryptPasswordEncoder.matches(oldPwd, password);
            if(!matches){
                return Message.error("旧密码不正确");//true
            }
            userByUserName.setPassword(bCryptPasswordEncoder.encode(newPwd));

            if(userService.editUserPassword(userByUserName)<=0){
                return Message.error("密码修改失败");
            }
        }
        return Message.success();
    }

    /**
     * 清除缓存
     * @param request
     * @param response
     * @return
     */
    @ResponseBody
    @PostMapping("/clear_cache")
    public Message clearCache(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setHeader("Cache-Control","no-store");
        response.setHeader("Pragrma","no-cache");
        response.setDateHeader("Expires",0);
      return  Message.success();
    }
}

角色控制层：

@Controller
public class RoleController {

    @Autowired
    private IRoleService roleService;

    @Autowired
    private IPermissionService permissionService;




    @PreAuthorize("hasRole('管理员')")
    @ResponseBody
    @RequestMapping("/role/doAdd")
    public String doAdd(Role role){
        //角色添加
        return "ok";
    }
    //添加角色
    @RequestMapping("/role/addRole")
    @PreAuthorize("hasRole('管理员')")
    @ResponseBody
    public AjaxResult addRole(Role role){
        System.out.println("保存角色...."+role);
        try {
            roleService.saveRole(role);
            return new AjaxResult();
        } catch (Exception e) {
            e.printStackTrace();
            return new AjaxResult("操作失败");
        }
    }

    @PreAuthorize("hasRole('管理员')")
    @RequestMapping("/role/index")
    public String index(Model model){
        List<Permission> permisisons = permissionService.findAllPermisisons();
        model.addAttribute("permissions",permisisons);
        //返回角色
        return "views/role/role_list";
    }

    @RequestMapping("/role/listpage")
    @ResponseBody
    public PageList listpage(RoleQuery roleQuery){
        System.out.println("传递参数:"+roleQuery);
        return  roleService.listpage(roleQuery);
    }


    //修改用户editSaveUser
    @RequestMapping("/role/editSaveRole")
    @ResponseBody
    public AjaxResult editSaveRole(Role role){
        System.out.println("修改角色...."+role);
        try {
            roleService.editSaveRole(role);
            return new AjaxResult();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return new AjaxResult("修改失败");
    }

    //添加角色
    @RequestMapping("/role/deleteRole")
    @ResponseBody
    public AjaxResult deleteRole(Long id){
        System.out.println("删除角色...."+id);
        AjaxResult ajaxResult = new AjaxResult();
        try {
            roleService.deleteRole(id);
        } catch (Exception e) {
            e.printStackTrace();
            return new AjaxResult("删除失败");
        }
        return ajaxResult;
    }

    //添加角色权限 addRolePermission
    @RequestMapping("/role/addRolePermission")
    @ResponseBody
    public AjaxResult addRolePermission(@RequestBody Map paramMap){
        AjaxResult ajaxResult = new AjaxResult();
        String roleId = (String)paramMap.get("roleId");
        List permissionIds = (List) paramMap.get("permissionIds");
        try {
            //添加角色对应的权限
            roleService.addRolePermission(roleId,permissionIds);
            return ajaxResult;
        }catch (Exception e){
            e.printStackTrace();
            return new AjaxResult("保存权限失败");
        }

    }

}

课程管理接口：

@RequestMapping("/course")
@Controller
@Api(tags = "课程管理接口")
public class CourseController {
    @Autowired
    private ICourseService courseService;

    @Autowired
    private IUserService userService;

    @Autowired
    private IOperaterLogService operaterLogService;


    /***
     * 课程列表
     * @param model
     * @return
     */
    @GetMapping("/index")
    @ApiOperation("跳转课程页接口")
    public String index(Model model){
        //查询所有的老师
        List<User> allTeacher = userService.findAllTeacher();
        model.addAttribute("teachers",allTeacher);
        return "views/course/course_list";
    }

    /**
     * 分页查询课程列表
     * @param courseQuery
     * @return
     */
    @GetMapping("/listpage")
    @ApiOperation("查询课程分页数据接口")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "CourseQuery", value = "课程查询对象", defaultValue = "courseQuery对象")
    })
    @ResponseBody
    public PageList listpage(CourseQuery courseQuery){
        return  courseService.listpage(courseQuery);
    }

    /**
     * 添加课程信息操作
     * @param course
     * @return
     */
    @PostMapping("/addCourse")
    @ApiOperation("添加课程接口")
    @ResponseBody
    public Message addCourse(Course course){
        if(StringUtils.isEmpty(course.getName())){
            return Message.error("请填写课程名称");
        }
        Map<String, Object> queryMap = new HashMap<>();
        queryMap.put("name",course.getName());
        queryMap.put("tid",course.getTid());
        if(courseService.findByNameAndUser(queryMap)!=null){
            return Message.error("该教师课程名已存在");
        }
        if(courseService.addCourse(course)<=0){
            return Message.error("课程信息添加失败");
        }
        operaterLogService.add("添加课程成功，课程名称："+course.getName());
        return Message.success();
    }

    /**
     * 修改课程信息操作
     * @param course
     * @return
     */
    @PostMapping("/editSaveCourse")
    @ApiOperation("修改课程接口")
    @PreAuthorize("hasRole('管理员')")
    @ResponseBody
    public Message editSaveCourse(Course course){
        if(StringUtils.isEmpty(course.getName())){
            return Message.error("请填写课程名称");
        }
        Map<String, Object> queryMap = new HashMap<>();
        queryMap.put("name",course.getName());
        queryMap.put("tid",course.getTid());
        Course byNameAndUser = courseService.findByNameAndUser(queryMap);
        if(byNameAndUser!=null){
            if(!byNameAndUser.getId().equals(course.getId())){
                return Message.error("该教师课程名已存在");
            }
        }
        try {
            courseService.editSaveCourse(course);
            operaterLogService.add("编辑课程成功，课程名称："+course.getName());
            return Message.success();
        } catch (Exception e) {
            return Message.error("课程信息修改失败");
        }

    }

    //添加课程
    @GetMapping("/deleteCourse")
    @ApiOperation("删除课程接口")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "如:88",required = true)
    })
    @PreAuthorize("hasRole('管理员')")
    @ResponseBody
    public AjaxResult deleteCourse(@RequestParam(required = true) Long id){
        AjaxResult ajaxResult = new AjaxResult();
        try {
            courseService.deleteCourse(id);
            operaterLogService.add("删除课程成功");
        } catch (Exception e) {
            e.printStackTrace();
            return new AjaxResult("删除失败");
        }

        return ajaxResult;
    }

    @PostMapping(value="/deleteBatchCourse")
    @ApiOperation("批量课程接口")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "ids", value = "如:88,89,99")
    })
    @PreAuthorize("hasRole('管理员')")
    @ResponseBody
    public AjaxResult deleteBatchCourse(String ids){
        String[] idsArr = ids.split(",");
        List list = new ArrayList();
        for(int i=0;i<idsArr.length;i++){
            list.add(idsArr[i]);
        }
        try{
            courseService.batchRemove(list);
            operaterLogService.add("删除课程成功");
            return new AjaxResult();
        }catch(Exception e){
           return new AjaxResult("批量删除失败");
        }
    }



}