基于springboot的健身管理系统微信小程序源码和论文

程序猿毕业分享网

已于 2022-12-18 19:45:23 修改

阅读量845

点赞数 2

分类专栏： java毕业设计文章标签：微信小程序小程序

于 2022-12-18 19:44:37 首次发布

本文链接：https://blog.csdn.net/weixin_46437112/article/details/128365017

版权

java毕业设计专栏收录该内容

69 篇文章 40 订阅

订阅专栏

健身房现在已经不是一个陌生的词汇了，对于广大的人民来说它是一种必然和必要的存在。而计算机的技术也在飞速的发展，在双重推力的促进之下，健身房不能只是单纯的传统企业闭门造车，而是要结合现今的技术和科技。无论从商家的角度还是从用户的角度来说，从商家的角度来讲商家可以通过信息化之后的系统更便捷方便准确地管理用户的诸多信息，从用户的角度来说，不仅仅可以提高时效性，更可以保证他的个人信息的安全。一开始的调研让我发现很多的企业已经开始重视健身房的系统管理方面的问题，这样的企业有很多比如飞跃，索易，他们的产品已经成型而且在投入市场。第二，健身房俱乐部毕竟是传统行业，和互联网包括计技术方面的接轨很少，在我们走访的诸多健身房中，中高端对于管理信息的方面还有一定的重视，像其他的中小型私人企业健身房就会很忽视这方面的内容，导致在会员来健身房使用的时候造成很大的不方便。第三，对于信息管理这方面的投入各个健身房还是比较吝啬的，他们的思维惯式就是不断地拓展，从没有想到在某一方面做精。实际在市场方面最需要“开盘子”的是互联网的行业，而不是传统行业，传统行业受限制于地点、资金、人流各个方面，如何在现在基础上通过二次开发产生更大的价值是传统行业最需要考虑的。就拿健身房举例，面积再大，也是有一个饱和率的，信息的把控不合时宜的话，很容易造成用户体验上的不系统不专业的感觉，在这种感觉的基础上会让整个产业良莠不齐，所以健身房的信息系统化并且电子化是势在必行的。我国健身事业一直在不停歇地推进，在这样的基础上，我认为此项目不仅仅是对于单个健身房甚至整个产业的意义，而且是促进我国健身事业重大意义。

演示视频：

基于微信小程序前端springboot的健身管理系统

现在的人们愈发忙碌生活节奏不断加快、科学技术各方面发展很迅速、还有人们对于锻炼身体上的认知，所以人们对于健身房以及健身房管理的要求相比过去增加许多。健身房的存在是为了帮助人们在工作生活之余为人们提供室内锻炼身体的场所。健身房不仅能为每一个人提供健身娱乐的场所，健身房还为我国的健身事业做出了突出的贡献，有着非同一般的意义。另外，健身房对于促进我国国民体质，在促进社会发展等各方面都有突出意义。现在社会中的各个领域都在广泛使用计算机网络和多媒体的技术，这就使得计算机网络和软件得到了很大的发展。不仅是体育健身，各式各样的比赛以及文体活动都在健身房里开展，所以在整个体育事业中健身房有着不可磨灭的重要地位，但是和这些并不相匹配的是，健身房对于信息的管理和建设的水平一直不高。为了更加好地提升健身房对于信息建设管理水平，响应我国对于体育精神各方面的号召，更好地完善健身房中信息化管理，对于健身房信息化的管理系统的开发，已经需要加紧步伐。

登录关键代码如下：

package cn.com.itcast.sport.controller;

import cn.com.itcast.sport.entry.CodeMsg;
import cn.com.itcast.sport.entry.Result;
import cn.com.itcast.sport.service.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpSession;

/**
 * @description:
 * @author: JIAWEI
 * @date: Created in 2023/3/16 14:45
 * @version: 1.0
 * @modified By:
 */
@Controller
public class LoginController {
    @Autowired
    private LoginService loginService;

    @RequestMapping("/loginPage")
    public String login(){
        return "web/login/loginPage";
    }
    @RequestMapping("/isLogin")
    @ResponseBody
    public Result isLogin(HttpSession session, String userName, String passWord){
        CodeMsg codeMsg = loginService.checkLogin(session, userName, passWord);
        Result<CodeMsg> resultMsf =  Result.success(codeMsg);;
        return resultMsf;
    }
    @RequestMapping("/outLogin")
    public Result outLogin(HttpSession session,String userCode){
        Boolean isOut = loginService.outLogin(session, userCode);
        Result resultMsf = null;
        if(isOut){
            resultMsf = Result.success("退出成功！");
        }else{
            resultMsf = Result.error(new CodeMsg(404,"未知用户！"));

        }
        return resultMsf;
    }
    @RequestMapping("/index")
    public String loginIndex(){
        return "web/login/index";
    }


}

近些年，无论在科学技术水平还是在科学技术研究方面，我国都有非常大的提高，比以往更加成熟的计算机的技术，所有人对于它的认识也更上了一层楼，人类社会的诸多领域全部都需要它，它也发挥着不可替代的作用，用计算机管理健身房中的各类信息，比手工管理要好得多。主要体现如下：（1）计算机在体育运动领域的应用越来越深入，健身房的计算机管理是提1健身房管理系统设计与实现高健身房管理效率，推动体育事业的发展的重要手段。目前健身房的管理一般采用人工操作，这些事务人工处理起来费时费力，并且数据量大，易出差错，而健身房管理系统具有强大的信息处理功能，维护起来或者使用起来不用多少成本，更不需要什么专业的培训工作，就可以直接操作。（2）现在社会的信息发展特别的迅猛，无论身处在哪个行业都会用到信息的处理，信息管理系统应用的那些环境绝大多数使用计算机，使用计算机能够特别高效地处理信息。在信息控制上主要使用计算机的话，对于工作效率的提升非常大，而且安全性有大幅度提升。在比较复杂的信息管理上就更是这样了，计算机的优越性被发挥得淋漓尽致。

package cn.com.itcast.sport.controller;

import cn.com.itcast.sport.entry.*;
import cn.com.itcast.sport.service.ApiService;
import com.alibaba.fastjson.JSON;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import io.swagger.annotations.ApiOperation;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @description:
 * @author: JIAWEI
 * @date: Created in 2023/4/4 16:39
 * @version: 1.0
 * @modified By:
 */
@Controller
@RequestMapping("/api")
public class ApiController {
    @Autowired
    private ApiService apiService;
    public static String DATA_HM = "yyyy-MM-dd HH:mm";
    public static String DATA_DAY = "yyyy-MM-dd";
    public Date changeData(String date,String dataType) {
        if(dataType.equals(DATA_HM) ){
            date = date+":00";
            dataType = dataType+":ss";
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat(dataType);
        Date parse = null;
        try {
            parse = dateFormat.parse(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return parse;
    }

    @RequestMapping(path = "/login")
    @ApiOperation("登录校验账号密码")

    @ResponseBody
    public Result login(@Param("userName") String userName, @Param("password") String password){
        return apiService.checkLogin(userName,password);
    }
    @RequestMapping(path = "/getPic")
    @ApiOperation("获取轮播图")
    @ResponseBody
    public Result getPic(){
        List<String> pic = new ArrayList<>();
        pic.add("https://qq2118119173.oss-cn-beijing.aliyuncs.com/pics/logo1.jpg");
        pic.add("https://qq2118119173.oss-cn-beijing.aliyuncs.com/pics/logo2.jpg");
        pic.add("https://qq2118119173.oss-cn-beijing.aliyuncs.com/pics/logo3.jpg");
        return Result.success(pic);
    }


    @RequestMapping(path = "/course/queryCourses")
    @ApiOperation("查询全部课程，带参数则返回相应条件的数据，不带则返回全部")
    @ResponseBody
    public String queryCourses(@Param("courseName") String courseName, @Param("typeCode")String typeCode,
                               @RequestParam(required=false,defaultValue="1") int page,
                               @RequestParam(required=false,defaultValue="10") int limit){
        PageHelper.startPage(page, limit);
        List<CourseMain> courseMains = apiService.queryCourses(courseName, typeCode);
        //用PageInfo对结果进行包装,传入连续显示的页数
        PageInfo pageInfo = new PageInfo(courseMains,limit);
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("code","200");
        map.put("msg", "操作成功！");
        map.put("maxPage",pageInfo.getPages());
        map.put("data",pageInfo.getList());
        String json= JSON.toJSONString(map);
        //将map转换为json格式
        return json;
    }
    @RequestMapping(path = "/course/queryTeacherCourses")
    @ApiOperation("查询教练个人的课程，必须带userCode参数")
    @ResponseBody
    public String queryTeacherCourses(@Param("courseName") String courseName, @Param("typeCode")String typeCode,
                                      @Param("userCode")String userCode,
                               @RequestParam(required=false,defaultValue="1") int page,
                               @RequestParam(required=false,defaultValue="10") int limit){
        PageHelper.startPage(page, limit);
        List<CourseMain> courseMains = apiService.queryTeacherCourses(courseName, typeCode,userCode);
        //用PageInfo对结果进行包装,传入连续显示的页数
        PageInfo pageInfo = new PageInfo(courseMains,limit);
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("code","200");
        map.put("msg", "操作成功！");
        map.put("maxPage",pageInfo.getPages());
        map.put("data",pageInfo.getList());
        String json= JSON.toJSONString(map);
        //将map转换为json格式
        return json;
    }

    @RequestMapping(path = "/course/queryRecommendedCourses")
    @ApiOperation("查询推荐课程，带参数则返回相应条件的数据，不带则返回全部")
    @ResponseBody
    public Result queryRecommendedCourses(@Param("courseName") String courseName){
        List<CourseMain> courseMains = apiService.queryRecommendedCourses(courseName);
        return Result.success(courseMains);
    }

    @RequestMapping(path = "/course/queryCourse")
    @ApiOperation("查看具体课程，必须带参数courseCode")
    @ResponseBody
    public Result queryCourse(@Param("userCode") String userCode,@Param("courseCode") String courseCode){
        CourseMain courseMain = apiService.queryCourse(userCode,courseCode);
        return Result.success(courseMain);
    }

    @RequestMapping(path = "/course/addCourse")
    @ApiOperation("添加课程，必须带参数")
    @ResponseBody
    public Result addCourse(@Param("courseName") String courseName, @Param("coursePic") String coursePic,
                            @Param("courseVideo") String courseVideo,@Param("courseDesc") String courseDesc, @Param("coursePrice") BigDecimal coursePrice,
                            @Param("startTime") String startTime, @Param("endTime") String endTime,
                            @Param("coueseTypeName") String coueseTypeName, @Param("courseTypeCode") String courseTypeCode,
                            @Param("userCode") String userCode, @Param("userName") String userName){

        CourseMain courseMain = new CourseMain();
        courseMain.setCourseName(courseName);
        courseMain.setCoursePic(coursePic);
        courseMain.setCourseVideo(courseVideo);
        courseMain.setCourseDesc(courseDesc);
        courseMain.setCoursePrice(coursePrice);
        courseMain.setCourseName(courseName);
        if(startTime !=null){
            courseMain.setStartTime(changeData(startTime, DATA_DAY));
        }
        if(endTime !=null){
            courseMain.setEndTime(changeData(endTime, DATA_DAY));
        }
        courseMain.setCoueseTypeName(coueseTypeName);
        courseMain.setCourseTypeCode(courseTypeCode);
        courseMain.setUserCode(userCode);
        courseMain.setUserName(userName);
        int addCourse = apiService.addCourse(courseMain);
        if(addCourse == -1){
            return Result.error(new CodeMsg(500,"插入失败"));
        }
        return Result.success("操作成功！");
    }

    @RequestMapping(path = "/course/editCourse")
    @ApiOperation("修改课程，必须带courseCode，只修改参数不为空的，状态status：'0未开课，1正在开课，2结束，3下架（教练离职）")
    @ResponseBody
    public Result editCourse(@Param("courseName") String courseName, @Param("courseCode") String courseCode,
                             @Param("coursePic") String coursePic,@Param("courseVideo") String courseVideo,
                             @Param("coursePrice") BigDecimal coursePrice,
                             @Param("startTime") String startTime, @Param("endTime") String endTime,
                            @Param("coueseTypeName") String coueseTypeName, @Param("courseTypeCode") String courseTypeCode,
                            @Param("status") String status,
                            @Param("userCode") String userCode, @Param("userName") String userName){
        CourseMain courseMain = new CourseMain();
        if(startTime !=null && !"''".equals(startTime)){
            courseMain.setStartTime(changeData(startTime, DATA_DAY));
        }
        if(endTime !=null&& !"''".equals(endTime)){
            courseMain.setEndTime(changeData(endTime, DATA_DAY));
        }
        courseMain.setCourseName(courseName);
        courseMain.setCourseCode(courseCode);
        courseMain.setCoursePic(coursePic);
        courseMain.setCourseVideo(courseVideo);
        courseMain.setCoursePrice(coursePrice);
        courseMain.setStatus(status);
        courseMain.setCoueseTypeName(coueseTypeName);
        courseMain.setCourseTypeCode(courseTypeCode);
        courseMain.setUserCode(userCode);
        courseMain.setUserName(userName);
        int editCourse = apiService.editCourse(courseMain);
        if(editCourse == -1){
            return Result.error(new CodeMsg(500,"更新失败"));
        }
        return Result.success("操作成功！");
    }
    @RequestMapping(path = "/course/openOrEndCourse")
    @ApiOperation("教练课程开课或下课，必须带courseCode和状态status：'0未开课，1正在开课，2结束，3下架（教练离职） ")
    @ResponseBody
    public Result openOrEndCourse( @Param("courseCode") String courseCode,@Param("status") String status){

        int editCourse = apiService.openOrEndCourse(courseCode,status);
        if(editCourse == -1){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success("操作成功！");
    }
    @RequestMapping(path = "/course/applyEnd")
    @ApiOperation("教练课程申请下架，必须带courseCode")
    @ResponseBody
    public Result applyEnd( @Param("courseCode") String courseCode){

        int editCourse = apiService.applyEnd(courseCode);
        if(editCourse == -1){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success("操作成功！");
    }

    @RequestMapping(path = "/course/courseCommend")
    @ApiOperation("学生课程评价，必须带用户userCode,课程courseCode，评价courseComment")
    @ResponseBody
    public Result courseCommend( @Param("userCode") String userCode,
                                 @Param("courseCode") String courseCode,
                                 @Param("courseComment") String courseComment){

        int commend = apiService.courseCommend(userCode, courseCode, courseComment);
        if(commend == -1){
            return Result.error(new CodeMsg(500,"参数不能为空"));
        }else if(commend == -0){
            return Result.error(new CodeMsg(500,"该学生没有此课程，不能评价！"));
        }
        return Result.success("操作成功！");
    }

    @RequestMapping(path = "/course/addClickNum")
    @ApiOperation("添加点击人数，必须带参数")
    @ResponseBody
    public Result addClickNum(@Param("courseCode") String courseCode){
        int clickNum = apiService.addClickNum(courseCode);
        if(clickNum == -1){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success("操作成功");
    }
    @RequestMapping(path = "/course/queryCourseTypes")
    @ApiOperation("查看课程分类")
    @ResponseBody
    public Result queryCourseTypes(){
        List<CourseType> courseTypes = apiService.queryCourseTypes();
        return Result.success(courseTypes);
    }
    @RequestMapping(path = "/course/queryCourseTypeByCode")
    @ApiOperation("查看某一课程分类信息，必须带参数")
    @ResponseBody
    public Result queryCourseTypeByCode(@Param("typeCode") String typeCode){
        CourseType courseType = apiService.queryCourseTypeByCode(typeCode);
        return Result.success(courseType);
    }

    @RequestMapping(path = "/course/queryPackages")
    @ApiOperation("查询课程全部小节，必须带参数")
    @ResponseBody
    public Result queryPackages(@Param("courseCode") String courseCode){
        List<CoursePackage> coursePackages = apiService.queryPackages(courseCode);
        return Result.success(coursePackages);
    }
    @RequestMapping(path = "/course/queryNearPackages")
    @ApiOperation("查询教练近期课程小节，必须带参数")
    @ResponseBody
    public String queryNearPackages(@Param("userCode") String userCode,@RequestParam(required=false,defaultValue="1") int page,
    @RequestParam(required=false,defaultValue="10") int limit){
        Page<Object> page1 = PageHelper.startPage(page, limit);
        List<CoursePackage> coursePackages = apiService.queryNearPackages(userCode);
        PageInfo pageInfo = new PageInfo(coursePackages,limit);
        pageInfo.setPages(page1.getPages());//总页数
        pageInfo.setTotal(page1.getTotal());//总条数
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("code","200");
        map.put("msg", "操作成功！");
        map.put("maxPage",pageInfo.getPages());
        map.put("data",pageInfo.getList());
        String json= JSON.toJSONString(map);
        //将map转换为json格式
        return json;
    }
    @RequestMapping(path = "/course/queryPackage")
    @ApiOperation("查询具体小节的信息，必须带参数")
    @ResponseBody
    public Result queryPackage(@Param("packageCode") String packageCode){
        CoursePackage coursePackage = apiService.queryPackage(packageCode);
        return Result.success(coursePackage);
    }
    @RequestMapping(path = "/course/addPackage")
    @ApiOperation("添加小节，必须带参数")
    @ResponseBody
    public Result addPackage(@Param("packageNum") String packageNum,@Param("packageName") String packageName,
                             @Param("timeLong") String timeLong,@Param("startTime") String startTime,
                             @Param("endTime") String endTime, @Param("courseCode") String courseCode){
        CoursePackage coursePackage = new CoursePackage();
        coursePackage.setPackageName(packageName);
        coursePackage.setPackageNum(packageNum);
        coursePackage.setTimeLong(timeLong);
        coursePackage.setCourseCode(courseCode);
        if(startTime !=null){
            coursePackage.setStartTime(changeData(startTime, DATA_HM));
        }
        if(endTime !=null){
            coursePackage.setEndTime(changeData(endTime, DATA_HM));
        }

        int i = apiService.addPackage(coursePackage);
        if(i == -1){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success("操作成功");
    }
    @RequestMapping(path = "/course/editPackage")
    @ApiOperation("修改小节，必须带packageCode参数,其他参数带则修改")
    @ResponseBody
    public Result editPackage(@Param("packageNum") String packageNum,@Param("packageName") String packageName,
                             @Param("timeLong") String timeLong,@Param("startTime") String startTime,
                             @Param("endTime") String endTime, @Param("courseCode") String courseCode,
                             @Param("packageCode") String packageCode,@Param("status") String status){
        CoursePackage coursePackage = new CoursePackage();
        coursePackage.setPackageName(packageName);
        coursePackage.setPackageNum(packageNum);
        coursePackage.setTimeLong(timeLong);
        if(startTime !=null && !"''".equals(startTime)){
            coursePackage.setStartTime(changeData(startTime, DATA_HM));
        }
        if(endTime !=null && !"''".equals(endTime)){
            coursePackage.setEndTime(changeData(endTime, DATA_HM));
        }
        coursePackage.setCourseCode(courseCode);
        coursePackage.setStatus(status);
        int i = apiService.editPackage(coursePackage);
        if(i == -1){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success("操作成功");
    }
    //detail
    @RequestMapping(path = "/course/openOrEndPackage")
    @ApiOperation("教练小节开课或下课，必须带packageCode和状态status：'0未解锁，1正在进行已解锁，2已完成")
    @ResponseBody
    public Result openOrEndPackage( @Param("packageCode") String packageCode,@Param("status") String status){
        int editPackage = apiService.openOrEndPackage(packageCode,status);
        if(editPackage == -1){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success("操作成功！");
    }
    @RequestMapping(path = "/course/delPackage")
    @ApiOperation("教练删除小节，必须带packageCode")
    @ResponseBody
    public Result delPackage( @Param("packageCode") String packageCode){

        int delPackage = apiService.delPackage(packageCode);
        if(delPackage == -1){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success("操作成功！");
    }

    @RequestMapping(path = "/course/queryShopChart")
    @ApiOperation("查看购物车，必须带参数")
    @ResponseBody
    public String queryShopChart(@Param("userCode") String userCode,
                                 @RequestParam(required=false,defaultValue="1") int page,
                                 @RequestParam(required=false,defaultValue="10") int limit){
        PageHelper.startPage(page, limit);
        List<ShopCart> shopCarts = apiService.queryShopChart(userCode);
        PageInfo pageInfo = new PageInfo(shopCarts,limit);
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("code","200");
        map.put("msg", "操作成功！");
        map.put("maxPage",pageInfo.getPages());
        map.put("data",pageInfo.getList());
        String json= JSON.toJSONString(map);
        //将map转换为json格式
        return json;
    }

    @RequestMapping(path = "/course/addShopChart")
    @ApiOperation("添加购物车，必须带参数")
    @ResponseBody
    public Result addShopChart(@Param("userCode") String userCode,@Param("courseName") String courseName,
                               @Param("courseCode") String courseCode){
        ShopCart shopCart = new ShopCart();
        shopCart.setCourseName(courseName);
        shopCart.setCourseCode(courseCode);
        shopCart.setUserCode(userCode);
        int i = apiService.addShopChart(shopCart);
        if(i == -1){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success("操作成功");
    }

    @RequestMapping(path = "/course/editShopChart")
    @ApiOperation("批量删除购物车，必须带数组ids")
    @ResponseBody
    public Result delShopChart(Integer[] ids){
        int i = apiService.delShopChart(ids);
        if(i == -1){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success("操作成功");
    }
    @RequestMapping(path = "/course/createOrderByShopChartIds")
    @ApiOperation("通过购物车创建订单，必须带购物车的数组ids")
    @ResponseBody
    public Result createOrderByShopChartIds(Integer[] ids){
        Map<String, Object> order = apiService.createOrderByShopChartIds(ids);
        if(order == null || order.size() == 0){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success(order);
    }
    @RequestMapping(path = "/course/payOrder")
    @ApiOperation("支付或者取消订单，必须带参数orderCode和status，其中状态：-1,已取消，0未付款，1已付款，")
    @ResponseBody
    public Result payOrder(String orderCode,String status){
        int i = apiService.payOrder(orderCode, status);
        if(i == -1){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success("操作成功！");
    }

    @RequestMapping(path = "/course/queryShopOrders")
    @ApiOperation("查看个人所有订单，必须带参数userCode")
    @ResponseBody
    public String queryShopOrders(String userCode,
                                  @RequestParam(required=false,defaultValue="1") int page,
                                  @RequestParam(required=false,defaultValue="10") int limit){
        Page<Object> page1 = PageHelper.startPage(page, limit);
        List<Map<String, Object>> maps = apiService.queryShopOrders(userCode);
        PageInfo pageInfo = new PageInfo(maps,limit);
        pageInfo.setPages(page1.getPages());//总页数
        pageInfo.setTotal(page1.getTotal());//总条数
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("code","200");
        map.put("msg", "操作成功！");
        map.put("maxPage",pageInfo.getPages());
        map.put("data",pageInfo.getList());
        String json= JSON.toJSONString(map);
        //将map转换为json格式
        return json;
    }

    @RequestMapping(path = "/course/queryUserCourse")
    @ApiOperation("查看学员个人课程，必须带参数userCode")
    @ResponseBody
    public String queryUserCourse(String userCode,
                                  @RequestParam(required=false,defaultValue="1") int page,
                                  @RequestParam(required=false,defaultValue="10") int limit){
        PageHelper.startPage(page, limit);
        List<CourseMain> courseMains = apiService.queryUserCourse(userCode);
        PageInfo pageInfo = new PageInfo(courseMains,limit);
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("code","200");
        map.put("msg", "操作成功！");
        map.put("maxPage",pageInfo.getPages());
        map.put("data",pageInfo.getList());
        String json= JSON.toJSONString(map);
        //将map转换为json格式
        return json;
    }

    @RequestMapping(path = "/course/putCard")
    @ApiOperation("学员小节打卡，必须带参数packageCode和userCode")
    @ResponseBody
    public Result putCard(String packageCode,String userCode){
        int i = apiService.putCard(packageCode, userCode);
        if(i == -1){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success("操作成功！");
    }

    @RequestMapping(path = "/course/queryUserInfo")
    @ApiOperation("查看个人信息，必须带参数userCode")
    @ResponseBody
    public Result queryUserInfo(String userCode){
        User user = apiService.queryUserInfo(userCode);
        if(user == null){
            return Result.error(new CodeMsg(500,"个人信息为空！"));
        }
        return Result.success(user);
    }

    @RequestMapping(path = "/course/querySalarys")
    @ApiOperation("查看个人工资，必须带参数userCode")
    @ResponseBody
    public Result querySalarys(String userCode){
        List<SalaryMonth> salaryMonths = apiService.querySalarys(userCode);
        return Result.success(salaryMonths);
    }

    @RequestMapping(path = "/course/queryLeaveMains")
    @ApiOperation("查看教练请假列表，必须带参数")
    @ResponseBody
    public String queryLeaveMains(String userCode,
                                  @RequestParam(required=false,defaultValue="1") int page,
                                  @RequestParam(required=false,defaultValue="10") int limit){
        PageHelper.startPage(page, limit);
        List<LeaveMain> leaveMains = apiService.queryLeaveMains(userCode);
        PageInfo pageInfo = new PageInfo(leaveMains,limit);
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("code","200");
        map.put("msg", "操作成功！");
        map.put("maxPage",pageInfo.getPages());
        map.put("data",pageInfo.getList());
        String json= JSON.toJSONString(map);
        //将map转换为json格式
        return json;
    }

    @RequestMapping(path = "/course/addLeaveMain")
    @ApiOperation("教练请假，必须带参数")
    @ResponseBody
    public Result addLeaveMain(String packageCode,String packageAdjustStartTime,String packageAdjustEndTime,
                               String startUserName,String startUserCode){
        LeaveMain leaveMain = new LeaveMain();
        if(packageAdjustStartTime !=null){
            leaveMain.setPackageAdjustStartTime(changeData(packageAdjustStartTime, DATA_HM));
        }
        if(packageAdjustEndTime !=null){
            leaveMain.setPackageAdjustEndTime(changeData(packageAdjustEndTime, DATA_HM));
        }
        leaveMain.setPackageCode(packageCode);
        leaveMain.setStartUserName(startUserName);
        leaveMain.setStartUserCode(startUserCode);
        int i = apiService.addLeaveMain(leaveMain);
        if(i == -1){
            return Result.error(new CodeMsg(500,"操作失败，参数异常！"));
        }else if(i == -2){
            return Result.error(new CodeMsg(500,"课程已开始，不能请假！"));
        }
        return Result.success("操作成功！");
    }

    @RequestMapping(path = "/course/cancelLeaveMain")
    @ApiOperation("教练撤销请假，必须带小节的code参数")
    @ResponseBody
    public Result cancelLeaveMain(String packageCode){
        int i = apiService.cancelLeaveMain(packageCode);
        if(i == -1){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success("操作成功！");
    }
    @RequestMapping(path = "/course/querySiteMsgs")
    @ApiOperation("查询站内消息，必须带接收人code参数")
    @ResponseBody
    public String querySiteMsgs(String acceptCode,
                                @RequestParam(required=false,defaultValue="1") int page,
                                @RequestParam(required=false,defaultValue="10") int limit){
        PageHelper.startPage(page, limit);
        List<SiteMsg> siteMsgs = apiService.querySiteMsgs(acceptCode);
        PageInfo pageInfo = new PageInfo(siteMsgs,limit);
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("code","200");
        map.put("msg", "操作成功！");
        map.put("maxPage",pageInfo.getPages());
        map.put("data",pageInfo.getList());
        String json= JSON.toJSONString(map);
        //将map转换为json格式
        return json;
    }
    @RequestMapping(path = "/course/querySiteMsgNum")
    @ApiOperation("查询站内消息数量，必须带接收人code参数")
    @ResponseBody
    public Result querySiteMsgNum(String acceptCode){
        List<SiteMsg> siteMsgs = apiService.querySiteMsgs(acceptCode);
        int msgNum = 0;
        if(siteMsgs!=null &&siteMsgs.size() > 0){
            List<SiteMsg> collect = siteMsgs.stream().filter(siteMsg -> siteMsg.getIsRead() != null && "0".equals(siteMsg.getIsRead())).collect(Collectors.toList());
            msgNum = collect == null ? 0: collect.size();
        }
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("msgNum",msgNum);
        return Result.success(map);
    }
    @RequestMapping(path = "/course/readSiteMsg")
    @ApiOperation("站内消息变为已读，必须带消息id")
    @ResponseBody
    public Result readSiteMsg(Integer id){
        int i = apiService.readSiteMsg(id);
        if(i == -1){
            return Result.error(new CodeMsg(500,"操作失败"));
        }
        return Result.success("操作成功！");
    }


}

项目的可行性研究1.经济可行性经济可行性研究的目的是使新系统能达到以最小的开发成本取得最佳的经济效益。需要作投资估算，对开发中所需人员、硬软件支持以及其它费用进行估算，并对系统投入使用后带来的经济效益进行估计。由于该健身房硬件基础设施较好，具备开发的基本条件，资金到位，而且开发是从大处着眼，从小处实施，开发费用相对比较透明，易与控制，系统开发完成后将给健身房带来的经济效益是明显的。因此在经济上是可行的。2.技术可行性技术可行性研究就是弄清现有技术条件能否顺利完成开发工作，硬软件配置能否满足开发的需要，开发的风险等。通过对专业技术的学习，目前技术上是可行的。3.社会可行性该系统使用人员学历相对较高、经验丰富、素质较高，因此在管理上，人员素质上都是可行的。可行性分析的最后成果是写出可行性分析报告。可行性分析报告包括下列内容：1)健身房的战略目标，新系统的总体目标及主要功能；2)拟定新系统的总体方案；3)从技术、经济、社会等方面论证技术方案的可行性；4)制定投资规划和开发计划5健身房管理系统设计与实现在系统初步调查的基础上，明确了存在的主要问题和建立新系统的初步设想，进一步对系统目标、范围等因素进行分析研究。

非功能需求 X为了达成系统的总体目标，我们提出本系统的非功能需求如下：（1）系统的实用性和经济性相结合建设健身房管理系统的价值在于为健身房提供应用，而应用就必须切合实际。所以系统的设计要深入研究分析健身房现有管理流程和特点，结合实际情况，提供一个高性价比的方案。（2）系统的先进性和成熟性相结合计算机技术发展是日新月异，系统的更新换代非常快，为此，要求在方案设计过程中，尽量选用先进并且相对成熟的技术，确保系统不但易于开发和使用，也很容易的升级换代。（3）系统的可靠性和稳定性相结合运用先进的计算机程序开发技术和网络技术，并根据健身房管理的特点，要求将系统的可靠性设计亦视为一个重点，以保证数据的安全和系统的稳定运行。（4）系统的可扩展性和易维护性相结合为了适应系统变化的要求，在方案设计过程尽量选用扩充性强的软硬件系统，同时要求开发的应用系统，可扩展、易维护，以便系统建成后，用户可以用最简便的方法、最低的投资，实现系统的扩展和维护。（5）系统的用户积极参与原则用户是系统功能要求的提出者，同时也是系统的最终使用和管理者，用户的积极参与是项目得以成功实施的前提。

package cn.com.itcast.sport.controller;

import cn.com.itcast.sport.entry.*;
import cn.com.itcast.sport.service.UserService;
import com.alibaba.fastjson.JSON;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @description:
 * @author: JIAWEI
 * @date: Created in 2023/3/15 22:36
 * @version: 1.0
 * @modified By:
 */
@Controller
public class UserController {

    @Autowired
    private UserService userService;
    /*学员管理*/
    @RequestMapping("/student/init")
    public String studentInit() {
        return "web/user-manage/studentManage";
    }
    @RequestMapping("/student/findAll")
    @ResponseBody
    public String studentManage(String name, @RequestParam(required=false,defaultValue="1") int page,
                                @RequestParam(required=false,defaultValue="10") int limit) {
        //分页初始化
        PageHelper.startPage(page, limit);
        List<User> users = userService.findUsers(name,"0");
        //用PageInfo对结果进行包装,传入连续显示的页数
        PageInfo pageInfo = new PageInfo(users,limit);
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("code","0");
        map.put("msg", "");
        map.put("count",pageInfo.getTotal());
        map.put("data",pageInfo.getList());
        String json= JSON.toJSONString(map);
        //将map转换为json格式
        // return JsonConversion.writeMapJSON(map);
        return json;
    }
    /*教师管理*/
    @RequestMapping("/teacher/init")
    public String teacherInit() {
        return "web/user-manage/teacherManage";
    }
    @RequestMapping("/teacher/findAll")
    @ResponseBody
    public String teacherManage(String name, @RequestParam(required=false,defaultValue="1") int page,
                                @RequestParam(required=false,defaultValue="10") int limit) {
        PageHelper.startPage(page, limit);
        List<User> users = userService.findUsers(name,"1");
        //用PageInfo对结果进行包装,传入连续显示的页数
        PageInfo pageInfo = new PageInfo(users,limit);
        String msg = null;
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("code","0");
        map.put("msg", msg);
        map.put("count",pageInfo.getTotal());
        map.put("data",pageInfo.getList());
        String json= JSON.toJSONString(map);
        //将map转换为json格式
        // return JsonConversion.writeMapJSON(map);
        return json;
    }
    /*添加教练，学员*/
    @RequestMapping("/user/addInit")
    public String userAddInit(Model model ,String type) {
        model.addAttribute("type",type);
        return "web/user-manage/addUser";
    }
    @RequestMapping("/user/addUser")
    @ResponseBody
    public Result addUser(User user){
        CodeMsg codeMsg = userService.addUser(user);
        Result<CodeMsg> success = Result.success(codeMsg);
        return success;
    }
    @RequestMapping("/user/editInit")
    public String
    userEditInit(Model model ,Integer id){
        User user = userService.findUserById(id);
        model.addAttribute("user",user);
        return "web/user-manage/editUser";
    }

    @RequestMapping("/user/editUser")
    @ResponseBody
    public Result editUser(User user){
        CodeMsg codeMsg = userService.editUser(user);
        Result<CodeMsg> success = Result.success(codeMsg);
        return success;
    }
    /*账号管理*/
    @RequestMapping("/account/init")
    public String accountInit(Model model, HttpSession httpSession) {
        return "web/user-manage/accountManage";
    }
    @RequestMapping("/account/findAll")
    @ResponseBody
    public String accountManage(String userName, @RequestParam(required=false,defaultValue="1") int page,
                                @RequestParam(required=false,defaultValue="10") int limit) {
        PageHelper.startPage(page, limit);
        List<UserAndAccountAndRole> allUserInfo = userService.findAllUserInfo(userName);
        //用PageInfo对结果进行包装,传入连续显示的页数
        PageInfo pageInfo = new PageInfo(allUserInfo,limit);

        Map<String,Object> map = new HashMap<String, Object>();
        map.put("code","0");
        map.put("msg", "");
        map.put("count",pageInfo.getTotal());
        map.put("data",pageInfo.getList());
        String json= JSON.toJSONString(map);
        //将map转换为json格式
        // return JsonConversion.writeMapJSON(map);
        return json;
    }
    /*添加账号*/
    @RequestMapping("/account/addInit")
    public String accountAddInit(Model model) {
        List<User> users = userService.findHasNoAccountUsers();
        List<Role> roles = userService.findRoles(null);
        List<Account> accounts = userService.findAccounts(null);
        model.addAttribute("users",users);
        model.addAttribute("roles",roles);
        return "web/user-manage/addAccount";
    }
    @RequestMapping("/account/addAccount")
    @ResponseBody
    public Result addAccount(Account account){
        CodeMsg codeMsg = userService.addAccounts(account);
        Result<CodeMsg> success = Result.success(codeMsg);
        return success;
    }
    /*修改账号*/
    @RequestMapping("/account/editInit")
    public String accountEditInit(Model model,Integer id) {
        Account account = userService.findAccountById(id);
        List<Role> roles = userService.findRoles(null);
        model.addAttribute("account",account);
        model.addAttribute("roles",roles);
        return "web/user-manage/editAccount";
    }

    @RequestMapping("/account/editAccount")
    @ResponseBody
    public Result editAccount(Account account){
        CodeMsg codeMsg = userService.editAccount(account);
        Result<CodeMsg> success = Result.success(codeMsg);
        return success;
    }

    @RequestMapping("/role/findAll")
    @ResponseBody
    public String roleManage(String roleName, @RequestParam(required=false,defaultValue="1") int page,
                             @RequestParam(required=false,defaultValue="10") int limit) {
        PageHelper.startPage(page, limit);
        List<Role> roles = userService.findRoles(roleName);
        //用PageInfo对结果进行包装,传入连续显示的页数
        PageInfo pageInfo = new PageInfo(roles,limit);

        Map<String,Object> map = new HashMap<String, Object>();
        map.put("code","0");
        map.put("msg", "");
        map.put("count",pageInfo.getTotal());
        map.put("data",pageInfo.getList());
        String json= JSON.toJSONString(map);
        //将map转换为json格式
        // return JsonConversion.writeMapJSON(map);
        return json;
    }
    /*添加账号*/
    @RequestMapping("/role/addInit")
    public String roleAddInit(Model model) {
        return "web/user-manage/addRole";
    }
    @RequestMapping("/role/addRole")
    @ResponseBody
    public Result addRole(Role role){
        CodeMsg codeMsg = userService.addRole(role);
        Result<CodeMsg> success = Result.success(codeMsg);
        return success;
    }
    @RequestMapping("/role/editInit")
    public String editRoleInit(Model model,Integer id){
        Role role = userService.findRoleById(id);
        model.addAttribute("role",role);
        return "web/user-manage/editRole";
    }
    @RequestMapping("/role/editRole")
    @ResponseBody
    public Result editRole(Role role){
        CodeMsg codeMsg = userService.editRole(role);
        Result<CodeMsg> success = Result.success(codeMsg);
        return success;
    }

    /*更改密码页面*/
    @RequestMapping("/editAccountPwd")
    public String editAccountPwd(Model model, HttpSession httpSession){
        Account account = userService.findUserInfo(httpSession);
        model.addAttribute("account",account);
        return "web/login/editAccountPwd";
    }
    /*更改密码*/
    @RequestMapping("/submitAccountPwd")
    @ResponseBody
    public Result submitAccountPwd(EditAccountPwd editAccount){
        CodeMsg codeMsg = userService.editAccountPwd(editAccount);
        Result<CodeMsg> success = Result.success(codeMsg);
        return success;
    }

}