基于java+springboot+vue的体育馆使用预约平台

项目介绍

如今社会上各行各业，都在用属于自己专用的软件来进行工作，互联网发展到这个时候，人们已经发现离不开了互联网。互联网的发展，离不开一些新的技术，而新技术的产生往往是为了解决现有问题而产生的。针对于场地预约信息管理方面的不规范，容错率低，管理人员处理数据费工费时，采用新开发的体育馆使用预约平台可以从根源上规范整个数据处理流程的正规性和合法性。

体育馆使用预约平台能够实现场地管理，用户管理，论坛管理，公告管理，场地订单管理等功能。该系统采用了Mysql数据库，Java语言，Spring Boot框架等技术进行编程实现。

体育馆使用预约平台可以提高场地预约信息管理问题的解决效率，优化场地预约信息处理流程，并且能够保证存储数据的安全，它是一个非常可靠，非常安全的应用程序。

4.1.1 管理员模块功能
图4.1即为设计的管理员功能结构，管理员权限操作的功能包括对注册用户信息的管理，对场地，场地预约订单，公告，论坛帖子等信息的管理。
4.1.2 用户模块功能
图4.2即为设计的用户功能结构，用户权限操作的功能包括参与论坛帖子发布与评论，查看公告，预约场地，收藏场地等。

开发环境

编程语言：Java
数据库 ：Mysql
系统架构：B/S
后端框架：SpringBoot
编译工具：idea或者eclipse，jdk1.8，maven
支持定做：java/php/python/android/小程序vue/爬虫/c#/asp.net

系统实现

5.1 管理员后台功能实现
5.1.1 论坛管理
图5.1 即为编码实现的论坛管理界面，管理员在该界面中查看论坛回复信息，修改论坛帖子内容，可以删除论坛帖子。论坛信息包含帖子标题，用户姓名，用户手机号，用户身份证，查询的时候可以通过这些信息查询出来结果，添加内容的时候需要输入帖子类型，帖子标题，发布内容。

图5.1 论坛管理界面
管理员添加论坛：

@RequestMapping("/save")
public R save(@RequestBody ForumEntity forum, HttpServletRequest request){
    logger.debug("save方法:,,Controller:{},,forum:{}",this.getClass().getName(),forum.toString());

    String role = String.valueOf(request.getSession().getAttribute("role"));
    if(StringUtil.isEmpty(role))
        return R.error(511,"权限为空");
    else if("用户".equals(role))
        forum.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
    else if("管理员".equals(role))
        forum.setUsersId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));

    Wrapper<ForumEntity> queryWrapper = new EntityWrapper<ForumEntity>()
        .eq("forum_name", forum.getForumName())
        .eq("yonghu_id", forum.getYonghuId())
        .eq("users_id", forum.getUsersId())
        .eq("super_ids", forum.getSuperIds())
        .eq("forum_types", forum.getForumTypes())
        .eq("forum_state_types", forum.getForumStateTypes())
        ;

    logger.info("sql语句:"+queryWrapper.getSqlSegment());
    ForumEntity forumEntity = forumService.selectOne(queryWrapper);
    if(forumEntity==null){
        forum.setInsertTime(new Date());
        forum.setCreateTime(new Date());
        forumService.insert(forum);
        return R.ok();
    }else {
        return R.error(511,"表中有相同数据");
    }
}

5.1.2 用户管理
图5.2 即为编码实现的用户管理界面，管理员在该界面中为注册系统的用户重置密码，更改用户的头像，电子邮箱等基础信息，删除需要删除的用户。用户信息包含账号，密码，手机号，身份证，头像，性别，电子信箱，余额等。查询的时候只需要提供用户姓名，手机号，身份证就可以查询。

图5.2 用户管理界面
用户添加：

@RequestMapping("/save")
public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
    logger.debug("save方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString());

    String role = String.valueOf(request.getSession().getAttribute("role"));
    if(StringUtil.isEmpty(role))
        return R.error(511,"权限为空");

    Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
        .eq("username", yonghu.getUsername())
        .or()
        .eq("yonghu_phone", yonghu.getYonghuPhone())
        .or()
        .eq("yonghu_id_number", yonghu.getYonghuIdNumber())
        ;

    logger.info("sql语句:"+queryWrapper.getSqlSegment());
    YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper);
    if(yonghuEntity==null){
        yonghu.setCreateTime(new Date());
        yonghu.setPassword("123456");
        yonghuService.insert(yonghu);
        return R.ok();
    }else {
        return R.error(511,"账户或者用户手机号或者用户身份证号已经被使用");
    }
}

5.1.3 场地管理
图5.3 即为编码实现的场地管理界面，管理员在该界面中可以更改场地信息，新增新的场地信息，删除需要删除的场地资料。场地搜索只需要输入场地名称，场地类型就可以查到结果。新增场地则需要输入场地编号，场地名称，照片，类型，原价，现价，时间段，半全场，推荐吃饭地点，场地介绍等。

图5.3 场地管理界面
场地修改：

@RequestMapping("/update")
public R update(@RequestBody ChangdiEntity changdi, HttpServletRequest request){
    logger.debug("update方法:,,Controller:{},,changdi:{}",this.getClass().getName(),changdi.toString());
    String role = String.valueOf(request.getSession().getAttribute("role"));
    Wrapper<ChangdiEntity> queryWrapper = new EntityWrapper<ChangdiEntity>()
        .notIn("id",changdi.getId())
        .andNew()
        .eq("changdi_uuid_number", changdi.getChangdiUuidNumber())
        .eq("changdi_name", changdi.getChangdiName())
        .eq("changdi_types", changdi.getChangdiTypes())
        .eq("shijianduan", changdi.getShijianduan())
        .eq("shijianduan_ren", changdi.getShijianduanRen())
        .eq("changdi_clicknum", changdi.getChangdiClicknum())
        .eq("banquan_types", changdi.getBanquanTypes())
        .eq("shangxia_types", changdi.getShangxiaTypes())
        .eq("tuijian", changdi.getTuijian())
        .eq("changdi_delete", changdi.getChangdiDelete())
        ;

    logger.info("sql语句:"+queryWrapper.getSqlSegment());
    ChangdiEntity changdiEntity = changdiService.selectOne(queryWrapper);
    if("".equals(changdi.getChangdiPhoto()) || "null".equals(changdi.getChangdiPhoto())){
            changdi.setChangdiPhoto(null);
    }
    if(changdiEntity==null){
       changdiService.updateById(changdi);//根据id更新
        return R.ok();
    }else {
        return R.error(511,"表中有相同数据");
    }
}

5.1.4 场地订单管理
图5.4 即为编码实现的场地订单管理界面，管理员在该界面中对用户预约的场地订单进行查询，更改等，查看场地预约订单的预约时间段信息以及订单类型等信息。可以通过输入场地名称，类型，用户姓名，用户手机号，用户身份证号来进行查询场地预约信息。

图5.4 场地订单管理界面
场地订单列表：

/**
* 后端列表
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
    logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
    String role = String.valueOf(request.getSession().getAttribute("role"));
    if(StringUtil.isEmpty(role))
        return R.error(511,"权限为空");
    else if("用户".equals(role))
        params.put("yonghuId",request.getSession().getAttribute("userId"));
    if(params.get("orderBy")==null || params.get("orderBy")==""){
        params.put("orderBy","id");
    }
    PageUtils page = changdiOrderService.queryPage(params);

    //字典表数据转换
    List<ChangdiOrderView> list =(List<ChangdiOrderView>)page.getList();
    for(ChangdiOrderView c:list){
        //修改对应字典表字段
        dictionaryService.dictionaryConvert(c, request);
    }
    return R.ok().put("data", page);
}

5.1.5 公告信息管理
图5.5 即为编码实现的公告信息管理界面，管理员在该界面中负责发布公告信息，更改公告信息的部分信息，删除需要删除的公告。

图5.5 公告信息管理界面

5.2 用户前台功能实现
5.2.1 场地信息
图5.6 即为编码实现的场地信息界面，用户在该界面中对场地进行预定，或收藏场地方便下次查看场地信息。可以看到的场地名称，类型，原价，现价，人数，点击次数，半全场，推荐吃饭地点，订购日期，订购时间段详情介绍。

图5.6 场地信息界面
场地预约：

@RequestMapping("/add")
public R add(@RequestBody ChangdiOrderEntity changdiOrder, HttpServletRequest request){
    logger.debug("add方法:,,Controller:{},,changdiOrder:{}",this.getClass().getName(),changdiOrder.toString());
    String role = String.valueOf(request.getSession().getAttribute("role"));
    if("用户".equals(role)){
        ChangdiEntity changdiEntity = changdiService.selectById(changdiOrder.getChangdiId());
        if(changdiEntity == null){
            return R.error(511,"查不到该场地");
        }
        if(changdiEntity.getChangdiNewMoney() == null){
            return R.error(511,"场地价格不能为空");
        }

        Integer userId = (Integer) request.getSession().getAttribute("userId");
        YonghuEntity yonghuEntity = yonghuService.selectById(userId);
        if(yonghuEntity == null)
            return R.error(511,"用户不能为空");
        if(yonghuEntity.getNewMoney() == null)
            return R.error(511,"用户金额不能为空");
        double balance = yonghuEntity.getNewMoney() - changdiEntity.getChangdiNewMoney();//余额
        if(balance<0)
            return R.error(511,"余额不够支付");

        List<Integer> changdiOrderTypes = new ArrayList<>();
        changdiOrderTypes.add(2);
        String buyTime = new SimpleDateFormat("yyyy-MM-dd").format(changdiOrder.getBuyTime());
        List<ChangdiOrderEntity> changdiOrderEntities = changdiOrderService.selectList(new EntityWrapper<ChangdiOrderEntity>().notIn("changdi_order_types", changdiOrderTypes).eq("shijianduan", changdiOrder.getShijianduan()).eq("buy_time",buyTime));

        if(changdiOrderEntities != null && changdiOrderEntities.size()>0)
            return R.error(511,buyTime+" 那天的 "+changdiOrder.getShijianduan()+" 的时间段已经被预约了");

        changdiOrder.setYonghuId(userId); //设置订单支付人id
        changdiOrder.setInsertTime(new Date());
        changdiOrder.setCreateTime(new Date());
        changdiOrder.setChangdiOrderTypes(1);
        changdiOrder.setChangdiOrderTruePrice(changdiEntity.getChangdiNewMoney());
        changdiOrder.setChangdiOrderUuidNumber(String.valueOf(new Date().getTime()));
        changdiOrderService.insert(changdiOrder);//新增订单
        yonghuEntity.setNewMoney(balance);//设置金额
        yonghuService.updateById(yonghuEntity);
        return R.ok();
    }else{
        return R.error(511,"您没有权限支付订单");
    }
}

5.2.2 在线论坛
图5.7 即为编码实现的在线论坛界面，用户在该界面中对论坛所有帖子进行查看，查看帖子之后可以发布帖子评论，用户也能点击发布帖子链接进入新界面发布自己的帖子。主要可以看到帖子标题，发布人权限，发布时间，可以对这些帖子进行回复操作。

图5.7 在线论坛界面

5.2.3 场地预约
图5.8 即为编码实现的场地预约界面，用户在该界面中浏览已经预约的场地。如果存在误操作，用户可以取消预约的场地。在个人中心我的场地预约里面，有全部场地预约，已使用，取消预约，已预约这几个状态的预约信息，已经取消预约的不能再取消，已预约尚未取消预约的才可以取消预约。

图5.8 场地预约界面
我的预约:

/**
* 前端列表
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
    logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));

    // 没有指定排序字段就默认id倒序
    if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
        params.put("orderBy","id");
    }
    PageUtils page = changdiOrderService.queryPage(params);

    //字典表数据转换
    List<ChangdiOrderView> list =(List<ChangdiOrderView>)page.getList();
    for(ChangdiOrderView c:list)
        dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
    return R.ok().put("data", page);
}

核心代码

package com.controller;

import java.io.File;
import java.math.BigDecimal;
import java.net.URL;
import java.text.SimpleDateFormat;
import com.alibaba.fastjson.JSONObject;
import java.util.*;
import org.springframework.beans.BeanUtils;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.context.ContextLoader;
import javax.servlet.ServletContext;
import com.service.TokenService;
import com.utils.*;
import java.lang.reflect.InvocationTargetException;

import com.service.DictionaryService;
import org.apache.commons.lang3.StringUtils;
import com.annotation.IgnoreAuth;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.entity.*;
import com.entity.view.*;
import com.service.*;
import com.utils.PageUtils;
import com.utils.R;
import com.alibaba.fastjson.*;

/**
 * 场地
 * 后端接口
 * @author
 * @email
*/
@RestController
@Controller
@RequestMapping("/changdi")
public class ChangdiController {
    private static final Logger logger = LoggerFactory.getLogger(ChangdiController.class);

    @Autowired
    private ChangdiService changdiService;


    @Autowired
    private TokenService tokenService;
    @Autowired
    private DictionaryService dictionaryService;

    //级联表service

    @Autowired
    private YonghuService yonghuService;


    /**
    * 后端列表
    */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(StringUtil.isEmpty(role))
            return R.error(511,"权限为空");
        else if("用户".equals(role))
            params.put("yonghuId",request.getSession().getAttribute("userId"));
        params.put("changdiDeleteStart",1);params.put("changdiDeleteEnd",1);
        if(params.get("orderBy")==null || params.get("orderBy")==""){
            params.put("orderBy","id");
        }
        PageUtils page = changdiService.queryPage(params);

        //字典表数据转换
        List<ChangdiView> list =(List<ChangdiView>)page.getList();
        for(ChangdiView c:list){
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(c, request);
        }
        return R.ok().put("data", page);
    }

    /**
    * 后端详情
    */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id, HttpServletRequest request){
        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        ChangdiEntity changdi = changdiService.selectById(id);
        if(changdi !=null){
            //entity转view
            ChangdiView view = new ChangdiView();
            BeanUtils.copyProperties( changdi , view );//把实体数据重构到view中

            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }

    }

    /**
    * 后端保存
    */
    @RequestMapping("/save")
    public R save(@RequestBody ChangdiEntity changdi, HttpServletRequest request){
        logger.debug("save方法:,,Controller:{},,changdi:{}",this.getClass().getName(),changdi.toString());

        changdi.setShijianduanRen(1);
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(StringUtil.isEmpty(role))
            return R.error(511,"权限为空");

        Wrapper<ChangdiEntity> queryWrapper = new EntityWrapper<ChangdiEntity>()
            .eq("changdi_uuid_number", changdi.getChangdiUuidNumber())
            .eq("changdi_name", changdi.getChangdiName())
            .eq("changdi_types", changdi.getChangdiTypes())
            .eq("shijianduan", changdi.getShijianduan())
            .eq("shijianduan_ren", changdi.getShijianduanRen())
            .eq("changdi_clicknum", changdi.getChangdiClicknum())
            .eq("banquan_types", changdi.getBanquanTypes())
            .eq("shangxia_types", changdi.getShangxiaTypes())
            .eq("tuijian", changdi.getTuijian())
            .eq("changdi_delete", changdi.getChangdiDelete())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ChangdiEntity changdiEntity = changdiService.selectOne(queryWrapper);
        if(changdiEntity==null){
            changdi.setChangdiClicknum(1);
            changdi.setShangxiaTypes(1);
            changdi.setChangdiDelete(1);
            changdi.setCreateTime(new Date());
            changdiService.insert(changdi);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody ChangdiEntity changdi, HttpServletRequest request){
        logger.debug("update方法:,,Controller:{},,changdi:{}",this.getClass().getName(),changdi.toString());

        String role = String.valueOf(request.getSession().getAttribute("role"));
//        if(StringUtil.isEmpty(role))
//            return R.error(511,"权限为空");
        //根据字段查询是否有相同数据
        Wrapper<ChangdiEntity> queryWrapper = new EntityWrapper<ChangdiEntity>()
            .notIn("id",changdi.getId())
            .andNew()
            .eq("changdi_uuid_number", changdi.getChangdiUuidNumber())
            .eq("changdi_name", changdi.getChangdiName())
            .eq("changdi_types", changdi.getChangdiTypes())
            .eq("shijianduan", changdi.getShijianduan())
            .eq("shijianduan_ren", changdi.getShijianduanRen())
            .eq("changdi_clicknum", changdi.getChangdiClicknum())
            .eq("banquan_types", changdi.getBanquanTypes())
            .eq("shangxia_types", changdi.getShangxiaTypes())
            .eq("tuijian", changdi.getTuijian())
            .eq("changdi_delete", changdi.getChangdiDelete())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ChangdiEntity changdiEntity = changdiService.selectOne(queryWrapper);
        if("".equals(changdi.getChangdiPhoto()) || "null".equals(changdi.getChangdiPhoto())){
                changdi.setChangdiPhoto(null);
        }
        if(changdiEntity==null){
            //  String role = String.valueOf(request.getSession().getAttribute("role"));
            //  if("".equals(role)){
            //      changdi.set
            //  }
            changdiService.updateById(changdi);//根据id更新
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        ArrayList<ChangdiEntity> list = new ArrayList<>();
        for(Integer id:ids){
            ChangdiEntity changdiEntity = new ChangdiEntity();
            changdiEntity.setId(id);
            changdiEntity.setChangdiDelete(2);
            list.add(changdiEntity);
        }
        if(list != null && list.size() >0){
            changdiService.updateBatchById(list);
        }
        return R.ok();
    }

    /**
     * 批量上传
     */
    @RequestMapping("/batchInsert")
    public R save( String fileName){
        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
        try {
            List<ChangdiEntity> changdiList = new ArrayList<>();//上传的东西
            Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
            Date date = new Date();
            int lastIndexOf = fileName.lastIndexOf(".");
            if(lastIndexOf == -1){
                return R.error(511,"该文件没有后缀");
            }else{
                String suffix = fileName.substring(lastIndexOf);
                if(!".xls".equals(suffix)){
                    return R.error(511,"只支持后缀为xls的excel文件");
                }else{
                    URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
                    File file = new File(resource.getFile());
                    if(!file.exists()){
                        return R.error(511,"找不到上传文件，请联系管理员");
                    }else{
                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
                        dataList.remove(0);//删除第一行，因为第一行是提示
                        for(List<String> data:dataList){
                            //循环
                            ChangdiEntity changdiEntity = new ChangdiEntity();
//                            changdiEntity.setChangdiUuidNumber(data.get(0));                    //场地编号 要改的
//                            changdiEntity.setChangdiName(data.get(0));                    //场地名称 要改的
//                            changdiEntity.setChangdiPhoto("");//照片
//                            changdiEntity.setChangdiTypes(Integer.valueOf(data.get(0)));   //场地类型 要改的
//                            changdiEntity.setChangdiOldMoney(data.get(0));                    //场地原价 要改的
//                            changdiEntity.setChangdiNewMoney(data.get(0));                    //场地现价 要改的
//                            changdiEntity.setShijianduan(data.get(0));                    //时间段 要改的
//                            changdiEntity.setShijianduanRen(Integer.valueOf(data.get(0)));   //人数 要改的
//                            changdiEntity.setChangdiClicknum(Integer.valueOf(data.get(0)));   //点击次数 要改的
//                            changdiEntity.setBanquanTypes(Integer.valueOf(data.get(0)));   //半全场 要改的
//                            changdiEntity.setShangxiaTypes(Integer.valueOf(data.get(0)));   //是否上架 要改的
//                            changdiEntity.setTuijian(data.get(0));                    //推荐吃饭地点 要改的
//                            changdiEntity.setChangdiDelete(1);//逻辑删除字段
//                            changdiEntity.setChangdiContent("");//照片
//                            changdiEntity.setCreateTime(date);//时间
                            changdiList.add(changdiEntity);


                            //把要查询是否重复的字段放入map中
                                //场地编号
                                if(seachFields.containsKey("changdiUuidNumber")){
                                    List<String> changdiUuidNumber = seachFields.get("changdiUuidNumber");
                                    changdiUuidNumber.add(data.get(0));//要改的
                                }else{
                                    List<String> changdiUuidNumber = new ArrayList<>();
                                    changdiUuidNumber.add(data.get(0));//要改的
                                    seachFields.put("changdiUuidNumber",changdiUuidNumber);
                                }
                        }

                        //查询是否重复
                         //场地编号
                        List<ChangdiEntity> changdiEntities_changdiUuidNumber = changdiService.selectList(new EntityWrapper<ChangdiEntity>().in("changdi_uuid_number", seachFields.get("changdiUuidNumber")).eq("changdi_delete", 1));
                        if(changdiEntities_changdiUuidNumber.size() >0 ){
                            ArrayList<String> repeatFields = new ArrayList<>();
                            for(ChangdiEntity s:changdiEntities_changdiUuidNumber){
                                repeatFields.add(s.getChangdiUuidNumber());
                            }
                            return R.error(511,"数据库的该表中的 [场地编号] 字段已经存在 存在数据为:"+repeatFields.toString());
                        }
                        changdiService.insertBatch(changdiList);
                        return R.ok();
                    }
                }
            }
        }catch (Exception e){
            return R.error(511,"批量插入数据异常，请联系管理员");
        }
    }





    /**
    * 前端列表
    */
    @IgnoreAuth
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));

        // 没有指定排序字段就默认id倒序
        if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
            params.put("orderBy","id");
        }
        PageUtils page = changdiService.queryPage(params);

        //字典表数据转换
        List<ChangdiView> list =(List<ChangdiView>)page.getList();
        for(ChangdiView c:list)
            dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
        return R.ok().put("data", page);
    }

    /**
    * 前端详情
    */
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") Long id, HttpServletRequest request){
        logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        ChangdiEntity changdi = changdiService.selectById(id);
            if(changdi !=null){

                //点击数量加1
                changdi.setChangdiClicknum(changdi.getChangdiClicknum()+1);
                changdiService.updateById(changdi);

                //entity转view
                ChangdiView view = new ChangdiView();
                BeanUtils.copyProperties( changdi , view );//把实体数据重构到view中

                //修改对应字典表字段
                dictionaryService.dictionaryConvert(view, request);
                return R.ok().put("data", view);
            }else {
                return R.error(511,"查不到数据");
            }
    }


    /**
    * 前端保存
    */
    @RequestMapping("/add")
    public R add(@RequestBody ChangdiEntity changdi, HttpServletRequest request){
        logger.debug("add方法:,,Controller:{},,changdi:{}",this.getClass().getName(),changdi.toString());
        Wrapper<ChangdiEntity> queryWrapper = new EntityWrapper<ChangdiEntity>()
            .eq("changdi_uuid_number", changdi.getChangdiUuidNumber())
            .eq("changdi_name", changdi.getChangdiName())
            .eq("changdi_types", changdi.getChangdiTypes())
            .eq("shijianduan", changdi.getShijianduan())
            .eq("shijianduan_ren", changdi.getShijianduanRen())
            .eq("changdi_clicknum", changdi.getChangdiClicknum())
            .eq("banquan_types", changdi.getBanquanTypes())
            .eq("shangxia_types", changdi.getShangxiaTypes())
            .eq("tuijian", changdi.getTuijian())
            .eq("changdi_delete", changdi.getChangdiDelete())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ChangdiEntity changdiEntity = changdiService.selectOne(queryWrapper);
        if(changdiEntity==null){
            changdi.setChangdiDelete(1);
            changdi.setCreateTime(new Date());
        //  String role = String.valueOf(request.getSession().getAttribute("role"));
        //  if("".equals(role)){
        //      changdi.set
        //  }
        changdiService.insert(changdi);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }


}

论文参考

目 录
第1章 绪论 1
1.1 课题背景 1
1.2 课题意义 1
1.3 研究内容 2
第2章 开发环境与技术 3
2.1 Java语言 3
2.2 MYSQL数据库 3
2.3 IDEA开发工具 4
2.4 Spring Boot框架 4
第3章 需求分析 5
3.1 可行性分析 5
3.1.1 技术可行性 5
3.1.2 经济可行性 5
3.1.3 操作可行性 5
3.2 系统流程分析 6
3.3 系统性能需求 8
3.4 系统功能需求 8
第4章 系统设计 11
4.1 功能模块划分 11
4.1.1 管理员模块功能 11
4.1.2 用户模块功能 12
4.2 数据库设计 12
4.2.1 E-R图 13
4.2.2 数据库表设计 15
第5章 系统设计与实现 19
5.1 管理员后台功能实现 19
5.1.1 论坛管理 19
5.1.2 用户管理 20
5.1.3 场地管理 22
5.1.4 场地订单管理 23
5.1.5 公告信息管理 24
5.2 用户前台功能实现 25
5.2.1 场地信息 25
5.2.2 在线论坛 27
5.2.3 场地预约 27
第6章 软件测试 29
6.1 测试用例 29
6.2 测试结果 33
结 论 34
参考文献 36
致 谢 37