【项目分享~写给应届生的一篇文章】基于Web电影院购票系统 ~~ 选座模块

其他 2021-03-07 21:39:54 阅读次数: 0

背景

适合人群： 应届生
推荐：可直接做为毕业设计项目，开发架构简单，按照统一的规范开发，容易上少
原因：这个项目涉及到SSM三大框架，对于刚刚入门JavaWeb的同学缺少太多必备的知识，导致学习这个项目事倍功半。如果你已经是有一两年工作经验开发者，这个项目对你的level太低了，也不推荐哦

每年都会指导一些应届生答辩计算机毕业设计，

针 对 以 往 应 届 生 常 问 的 一 些 问 题   如 何 去 设 计 一 个 电 影 院 购 票 选 座 的 模 块 \color{red}针对以往应届生常问的一些问题 ~ 如何去设计一个电影院购票选座的模块 针对以往应届生常问的一些问题 如何去设计一个电影院购票选座的模块
以 “ 基 于 W e b 电 影 院 购 票 系 统 ” \color{red}“基于Web电影院购票系统” “基于Web电影院购票系统”这篇文章为例，今天给大家讲讲这个：登录注册是如何实现的

小总结

你还在为大学最后的毕业设计而苦恼吗？
你还在面对毕业设计而无从下手吗？
你还在实习，但苦于没有时间做毕业设计吗？
适合应届生当做项目经验、或者毕设作品
小作者的随手之作，实现难度不难~~
这个项目，你值得拥有

项目演示视频分享

链接：https://pan.baidu.com/s/1gbC3i-FBp6-JfGRzmsfZgQ
提取码：9lkr
想要源码的可以私聊我，
亦或是加我qq：924155240
可指导毕设，稳过

项目截图

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

电影院购票模块的设计

最简单的二维数组来存储座位信息

1 		2		3		4		5
6		7		8		9		10

分别对应坐标：
[0][0] [0][1] [0][2] [0][3] [0][4]
[1][0] [1][1] [1][2] [1][3] [1][4]

基于以上的设计，定出表结构信息

CREATE TABLE `selected_seat` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '选座主键',
  `my_x` int(11) DEFAULT NULL COMMENT '一维度数组',
  `my_y` int(11) DEFAULT NULL COMMENT '二位度数组',
  `is_select` varchar(256) DEFAULT NULL COMMENT '是否选中',
  `u_id` int(11) DEFAULT NULL COMMENT '用户编号',
  `u_name` varchar(256) DEFAULT NULL COMMENT '用户信息',
  `s_id` int(11) DEFAULT NULL COMMENT '电影次的主键',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1114 DEFAULT CHARSET=utf8;

添加电影播映的时候，根据放映厅的X与Y的值，生成选座信息

 @Override
    public boolean add(MovieSchedule movieSchedule) {
    
    


        Integer vId = movieSchedule.getvId();
        VideoHall videoHall = videoHallMapper.selectByPrimaryKey(vId);
        Integer cId = videoHall.getcId();
        Integer mId = movieSchedule.getmId();
        CheckUtil.notNull(movieSchedule,"电影放映安排为空");
        CheckUtil.notNull(cId,"电影院ID为空");
        CheckUtil.notNull(vId,"电影院放映厅ID为空");
        CheckUtil.notNull(mId,"电影ID为空");
        CheckUtil.notNull(movieSchedule.getHallStatrTime(),"电影放映安排开始时间为空");
        CheckUtil.notNull(movieSchedule.getHallEndTime(),"电影放映安排结束时间为空");
        CheckUtil.notNull(movieSchedule.getSellMoney(),"影片售价为空");

        // 判断电影放映安排名称是否存在
        MovieScheduleExample movieScheduleExample = new MovieScheduleExample();
        MovieScheduleExample.Criteria criteria = movieScheduleExample.createCriteria();
        criteria.andCIdEqualTo(cId);
        criteria.andVIdEqualTo(vId);
        criteria.andHallStatrTimeLessThanOrEqualTo(movieSchedule.getHallStatrTime());
        criteria.andHallEndTimeGreaterThanOrEqualTo(movieSchedule.getHallStatrTime());

        List<MovieSchedule> lists = movieScheduleMapper.selectByExample(movieScheduleExample);
        if(CollectionUtils.isNotEmpty(lists)){
    
    
            throw new CheckException(ResultBean.CHECK_FAIL, "该时间段已经有电影正在播放，不能安排在改时间段，请检查！");
        }


        MovieScheduleExample movieScheduleExample2 = new MovieScheduleExample();
        MovieScheduleExample.Criteria criteria2 = movieScheduleExample2.createCriteria();
        criteria2.andCIdEqualTo(cId);
        criteria2.andVIdEqualTo(vId);
        criteria2.andHallStatrTimeLessThanOrEqualTo(movieSchedule.getHallEndTime());
        criteria2.andHallEndTimeGreaterThanOrEqualTo(movieSchedule.getHallEndTime());
        List<MovieSchedule> lists2 = movieScheduleMapper.selectByExample(movieScheduleExample2);
        if(CollectionUtils.isNotEmpty(lists2)){
    
    
            throw new CheckException(ResultBean.CHECK_FAIL, "该时间段已经有电影正在播放，不能安排在改时间段，请检查！");
        }


        // 补充其他信息
        Cinema cinema = cinemaMapper.selectByPrimaryKey(cId);
        movieSchedule.setUpdateTime(new Date());
        movieSchedule.setCreateTime(new Date());
        movieSchedule.setcId(cinema.getCinemaId());
        movieSchedule.setcNo(cinema.getCinemaNo());
        movieSchedule.setcName(cinema.getCinemaName());
        movieSchedule.setcAddress(cinema.getAddress());


        movieSchedule.setvName(videoHall.getScreensName());
        movieSchedule.setvNo(videoHall.getScreensNo());
        movieSchedule.setvType(videoHall.getType());

        Movie movie = movieMapper.selectByPrimaryKey(mId);
        movieSchedule.setmName(movie.getMovieName());
        movieSchedule.setmEnglishName(movie.getMovieEnglishName());
        movieSchedule.setMinuteLength(movie.getMinuteLength());
        movieSchedule.setRemainingSeatNumber(videoHall.getSeatNumber() * videoHall.getRowNumber());
        movieSchedule.setStandy2(movie.getMovieFile());

        int i =  movieScheduleMapper.insert(movieSchedule);

        // 生成座位信息
        selectedSeatService.add(videoHall.getSeatNumber(), videoHall.getRowNumber(), movieSchedule.getId());
        return this.returnBoolean(i);
    }

具体生成座位信息

@Override
    public boolean add(Integer myX, Integer myY, Integer sId) {
    
    

        CheckUtil.notNull(myX,"座位数不能为空");
        CheckUtil.notNull(myY,"排数为空");
        CheckUtil.notNull(sId,"放映安排为空");
        for(int i = 0; i < myX; i++){
    
    
            for(int j = 0; j < myY; j++){
    
    
                SelectedSeat selectedSeat = new SelectedSeat();
                selectedSeat.setMyX(i);
                selectedSeat.setMyY(j);
                selectedSeat.setsId(sId);
                selectedSeat.setIsSelect("否");
                selectedSeatMapper.insert(selectedSeat);
            }
        }
        SelectedSeatExample selectedSeatExample = new SelectedSeatExample();
        SelectedSeatExample.Criteria criteria = selectedSeatExample.createCriteria();
        criteria.andSIdEqualTo(sId);
        List<SelectedSeat> selectedSeats = selectedSeatMapper.selectByExample(selectedSeatExample);
        if(CollectionUtils.isNotEmpty(selectedSeats)){
    
    
            return myX * myY == selectedSeats.size();
        }
        return false;
    }

座位渲染前端

 /**
     * 初始化日期选择
     * */
    var price;
    function initDate() {
    
    
        var queryArgs = $tool.getQueryParam();//获取查询参数
        var id = queryArgs['id'];

        var req = {
    
    
            id:id
        };
        $("#id").val(id);
        $api.GetSeatMessageVo(req,function (res) {
    
    
            var data = res.data;
            console.log(data)
            console.log("-----------------");
            var seatArray = data.seatArray;
            var hadSelectedSeats = data.hadSelectedSeats;
            $("#mName").html(data.mName);
            $("#startTime").html(data.startTime);
            var $cart = $('#selected-seats'), //座位区
                $counter = $('#counter'), //票数
                $total = $('#total'); //总计金额
            price = data.price;
            var sc = $('#seat-map').seatCharts({
    
    
                map: seatArray,
                naming : {
    
    
                    top : false,
                    getLabel : function (character, row, column) {
    
    
                        return column;
                    }
                },
                legend : {
    
     //定义图例
                    node : $('#legend'),
                    items : [
                        [ 'a', 'available',   '可选座' ],
                        [ 'a', 'unavailable', '已售出']
                    ]
                },
                click: function () {
    
     //点击事件
                    if (this.status() == 'available') {
    
     //可选座
                        $('<li>'+(this.settings.row+1)+'排'+this.settings.label+'座</li>')
                            .attr('id', 'cart-item-'+this.settings.id)
                            .data('seatId', this.settings.id)
                            .appendTo($cart);

                        $counter.text(sc.find('selected').length+1);
                        $total.text(recalculateTotal(sc)+price);

                        return 'selected';
                    } else if (this.status() == 'selected') {
    
     //已选中
                        //更新数量
                        $counter.text(sc.find('selected').length-1);
                        //更新总计
                        $total.text(recalculateTotal(sc)-price);

                        //删除已预订座位
                        $('#cart-item-'+this.settings.id).remove();
                        //可选座
                        return 'available';
                    } else if (this.status() == 'unavailable') {
    
     //已售出
                        return 'unavailable';
                    } else {
    
    
                        return this.style();
                    }
                }
            });
            //已售出的座位
            //sc.get(['1_2', '4_4','4_5','6_6','6_7','8_5','8_6','8_7','8_8', '10_1', '10_2']).status('unavailable');
            sc.get(hadSelectedSeats).status('unavailable');
        });



    }

渲染座位信息

也就是把已经出售的组装成1_2的格式，前端就能渲染出来

@Override
    public SeatMessageVo toGetSeatMessage(Integer id) {
    
    
        SeatMessageVo seatMessageVo = new SeatMessageVo();


        CheckUtil.notNull(id,"电影放映安排ID为空");
        // 获取到厅信息
        MovieSchedule movieSchedule = movieScheduleMapper.selectByPrimaryKey(id);
        VideoHall videoHall = videoHallMapper.selectByPrimaryKey(movieSchedule.getvId());
        // 获取X轴
        int myX = videoHall.getSeatNumber();
        int myY = videoHall.getRowNumber();
        String[] seatArray = new String[myY];
        for(int i = 0; i < myY; i++){
    
    
            StringBuffer sb = new StringBuffer();
            for(int j = 0; j < myX; j++){
    
    
                sb.append("a");
            }
            seatArray[i] = sb.toString();
        }

        // 获取当前已经选中的座位
        SelectedSeatExample selectedSeatExample = new SelectedSeatExample();
        SelectedSeatExample.Criteria criteria = selectedSeatExample.createCriteria();
        criteria.andSIdEqualTo(id);
        criteria.andIsSelectEqualTo("是");
        List<SelectedSeat> selectedSeats = selectedSeatMapper.selectByExample(selectedSeatExample);
        List<String> hadSelectedSeatsList = new ArrayList<>();
        if(CollectionUtils.isNotEmpty(selectedSeats)){
    
    
            for(SelectedSeat selectedSeat : selectedSeats){
    
    
                hadSelectedSeatsList.add((selectedSeat.getMyY() + 1) + "_" + (selectedSeat.getMyX() + 1));
            }
        }

        // 从redis获取座位信息

        Set<String> keys = redisTemplate.keys("seat_" + id + "_" + "*");
        for(String key : keys){
    
    
            String data = redisTemplate.opsForValue().get(key);
            hadSelectedSeatsList.add(data);
        }

        String[] strArray = new String[hadSelectedSeatsList.size()];
        hadSelectedSeatsList.toArray(strArray);

        seatMessageVo.setHadSelectedSeats(strArray);
        seatMessageVo.setSeatArray(seatArray);
        seatMessageVo.setStartTime(movieSchedule.getHallStatrTime());
        seatMessageVo.setmName(movieSchedule.getmName());
        seatMessageVo.setPrice(movieSchedule.getSellMoney());
        return seatMessageVo;

    }

使用redis缓存有效时间

package com.gameloft9.demo.controllers.business;

import com.gameloft9.demo.dataaccess.model.business.MovieOrder;
import com.gameloft9.demo.dataaccess.model.business.MovieSchedule;
import com.gameloft9.demo.dataaccess.model.business.SelectedSeat;
import com.gameloft9.demo.mgrframework.annotation.BizOperLog;
import com.gameloft9.demo.mgrframework.beans.constant.OperType;
import com.gameloft9.demo.mgrframework.beans.response.IResult;
import com.gameloft9.demo.mgrframework.beans.response.PageResultBean;
import com.gameloft9.demo.mgrframework.beans.response.ResultBean;
import com.gameloft9.demo.mgrframework.utils.CheckUtil;
import com.gameloft9.demo.service.api.business.MovieOrderService;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.validation.Valid;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * create by IntelliJ IDEA
 *
 * @author : xiaozheng
 * DATE: 2019/9/22 0022
 * TIME: 下午 12:49
 * Description:
 */
@Slf4j
@Controller
@RequestMapping("/movieOrder")
public class MovieOrderController extends BaseController{
    
    
    @Autowired
    MovieOrderService movieOrderService;
    private static final String pd = "yy-MM-dd HH:mm:ss";
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pd);
    @Autowired
    private RedisTemplate<String, String> redisTemplate;


    @RequestMapping(value = "/test")
    @ResponseBody
    public IResult test(){
    
    
        for(int i = 0; i < 8; i++){
    
    
            MovieOrder movieOrder = new MovieOrder();
            movieOrder.setNumber(2);
            movieOrder.setSeatMessage("4排1座，4排2做");
            movieOrder.setsId(26);
            movieOrder.setuId(1);
            movieOrderService.add(movieOrder);
        }
        return new ResultBean<Boolean>(true);
    }
    /**
     * 获取所有影片订单列表 ~ 分页
     * @param page 页序
     * @param limit 分页大小
     * */
    @RequestMapping(value = "/getPageForAdmin")
    @ResponseBody
    public IResult getPage(String page, String limit, String orderNo,
                           String uName, String uPhone, String cName, String cNo,
                           String cAddress, String mName, String mEnglishName,
                           String startTime, String endTime,
                           String vType, String vName, String code, String status) throws Exception{
    
    
        Date hallStartTime = null;
        Date hallEndTime = null;
        if(StringUtils.isNotEmpty(startTime)){
    
    
            hallStartTime = simpleDateFormat.parse(startTime);
        }
        if(StringUtils.isNotEmpty(endTime)){
    
    
            hallEndTime = simpleDateFormat.parse(endTime);
        }
        //返回json至前端的均返回ResultBean或者PageResultBean
        PageInfo pageInfo = movieOrderService.getPage(page, limit, orderNo, uName, uPhone, cName, cNo,
                cAddress, mName,  mEnglishName, hallStartTime, hallEndTime, vType, vName, code, status);

        List<MovieOrder> pageInfoList = pageInfo.getList();

        List<MovieOrder> movieOrders = new ArrayList<>();
        for (MovieOrder movieOrder : pageInfoList){
    
    
            String images = movieOrder.getmFile();
            String a = "<img class=\"layui-upload-img\" src=\""+images+"\" style=\"width:50px; height:50px;\">";
            movieOrder.setmFile(a);
            movieOrders.add(movieOrder);
        }
        Integer total = new Long(pageInfo.getTotal()).intValue();




        return new PageResultBean<Collection<MovieOrder>>(movieOrders, total);
    }

    /**
     * 获取所有影片订单列表 ~ 分页
     * @param page 页序
     * @param limit 分页大小
     * */
    @RequestMapping(value = "/getPageForUser")
    @ResponseBody
    public IResult getPageForUser(String page, String limit, String orderNo,
                           String cName, String cAddress, String mName, String mEnglishName,
                                  String startTime, String endTime, String code, String status) throws Exception{
    
    
        Date hallStartTime = null;
        Date hallEndTime = null;
        if(StringUtils.isNotEmpty(startTime)){
    
    
            hallStartTime = simpleDateFormat.parse(startTime);
        }
        if(StringUtils.isNotEmpty(endTime)){
    
    
            hallEndTime = simpleDateFormat.parse(endTime);
        }
        //返回json至前端的均返回ResultBean或者PageResultBean
        PageInfo pageInfo = movieOrderService.getPageForUser(page, limit, orderNo, cName, cAddress, mName,  mEnglishName
                        , hallStartTime, hallEndTime, code, status);

        List<MovieOrder> pageInfoList = pageInfo.getList();

        List<MovieOrder> movieOrders = new ArrayList<>();
        for (MovieOrder movieOrder : pageInfoList){
    
    
            String images = movieOrder.getmFile();
            String a = "<img class=\"layui-upload-img\" src=\""+images+"\" style=\"width:50px; height:50px;\">";
            movieOrder.setmFile(a);
            movieOrders.add(movieOrder);
        }
        Integer total = new Long(pageInfo.getTotal()).intValue();
        return new PageResultBean<Collection<MovieOrder>>(movieOrders, total);
    }


    /**
     * 添加影片订单
     * */
    /*@RequestMapping(value = "/add")
    @ResponseBody
    @BizOperLog(operType = OperType.ADD,memo = "添加影片订单")
    public IResult add(@RequestBody MovieOrder movieOrder){

        //返回json至前端的均返回ResultBean或者PageResultBean
        return new ResultBean<Boolean>(movieOrderService.add(movieOrder));
    }*/
    @RequestMapping(value = "/add")
    @ResponseBody
    @BizOperLog(operType = OperType.ADD,memo = "添加影片订单")
    public IResult add(Integer number,
                       String seatMessage,
                        Integer sId) throws Exception{
    
    
        seatMessage = new String(seatMessage.getBytes("iso8859-1"), "utf-8");

        // 判断是否过期
        String[] sArr = seatMessage.split(" ");
        int i = 0;
        boolean aggress = true;
        for(String s : sArr){
    
    
            int myX = Integer.parseInt(s.split("排")[1].split("座")[0]);
            int myY = Integer.parseInt(s.split("排")[0]);
            String key = redisKeyForUser(sId, myX, myY);
            String s1 = redisTemplate.opsForValue().get(key);
            if(StringUtils.isEmpty(s1)){
    
    
                aggress = false;
            }
        }
        if(aggress){
    
    
            MovieOrder movieOrder = new MovieOrder();
            movieOrder.setsId(sId);
            movieOrder.setSeatMessage(seatMessage);
            movieOrder.setNumber(number);
            //返回json至前端的均返回ResultBean或者PageResultBean
            return new ResultBean<Boolean>(movieOrderService.add(movieOrder));
        }else {
    
    
            // 删除缓存
            for(String s : sArr){
    
    
                int myX = Integer.parseInt(s.split("排")[1].split("座")[0]);
                int myY = Integer.parseInt(s.split("排")[0]);
                redisTemplate.delete(redisKey(sId, myX, myY));
                redisTemplate.delete(redisKeyForUser(sId, myX, myY));
            }
            CheckUtil.notNull(null, "订单超时，无法支付请重新选择！");
            return new ResultBean<Boolean>(false);
        }

    }


    @RequestMapping(value = "/suoJia")
    @ResponseBody
    @BizOperLog(operType = OperType.ADD,memo = "添加影片订单")
    public IResult suoJia(Integer number,
                       String seatMessage,
                       Integer sId) throws Exception{
    
    
        seatMessage = new String(seatMessage.getBytes("iso8859-1"), "utf-8");
        CheckUtil.notNull(sId, "电影播放安排sId为空");
        CheckUtil.notNull(seatMessage, "座位信息为空");

        String[] sArr = seatMessage.split(" ");
        int i = 0;

        // 锁价之前先判断是否存在
        for(String s : sArr){
    
    
            int myX = Integer.parseInt(s.split("排")[1].split("座")[0]);
            int myY = Integer.parseInt(s.split("排")[0]);
            String s1 = redisTemplate.opsForValue().get(redisKey(sId, myX, myY));
            if(StringUtils.isNotEmpty(s1)){
    
    
                CheckUtil.notNull(null, "非常抱歉该订单已经被其他客户锁住了，请重新选择！");
            }
        }


        for(String s : sArr){
    
    
            int myX = Integer.parseInt(s.split("排")[1].split("座")[0]);
            int myY = Integer.parseInt(s.split("排")[0]);
            String redisDate = myY + "_" + myX;

            redisTemplate.opsForValue().set(redisKey(sId, myX, myY), redisDate, 60, TimeUnit.SECONDS);
            redisTemplate.opsForValue().set(redisKeyForUser(sId, myX, myY), redisDate, 60, TimeUnit.SECONDS);
        }
        //返回json至前端的均返回ResultBean或者PageResultBean
        return new ResultBean<Boolean>(true);
    }

    @RequestMapping(value = "/cancelOrder")
    @ResponseBody
    @BizOperLog(operType = OperType.ADD,memo = "删除影片订单")
    public IResult cancelOrder(Integer number,
                          String seatMessage,
                          Integer sId) throws Exception{
    
    
        seatMessage = new String(seatMessage.getBytes("iso8859-1"), "utf-8");

        CheckUtil.notNull(sId, "电影播放安排sId为空");
        CheckUtil.notNull(seatMessage, "座位信息为空");

        String[] sArr = seatMessage.split(" ");
        int i = 0;
        for(String s : sArr){
    
    
            int myX = Integer.parseInt(s.split("排")[1].split("座")[0]);
            int myY = Integer.parseInt(s.split("排")[0]);
            redisTemplate.delete(redisKey(sId, myX, myY));
            redisTemplate.delete(redisKeyForUser(sId, myX, myY));
        }
        //返回json至前端的均返回ResultBean或者PageResultBean
        return new ResultBean<Boolean>(true);
    }


    private String redisKey(Integer sId, int myX, int myY){
    
    
        return "seat_" + sId + "_" + myX + "_" + myY;
    }

    private String redisKeyForUser(Integer sId, int myX, int myY){
    
    
        return getUserId() + "_seat_" + sId + "_" + myX + "_" + myY;
    }

    /**
     * 删除影院
     * */
    @RequestMapping(value = "/delete")
    @ResponseBody
    @BizOperLog(operType = OperType.DELETE,memo = "删除影片订单")
    public IResult delete(Integer id){
    
    
        //返回json至前端的均返回ResultBean或者PageResultBean
        return new ResultBean<Boolean>(movieOrderService.deleteById(id));
    }

    @ResponseBody
    @RequestMapping("/getById")
    public IResult getById(Integer id) {
    
    

        return new ResultBean<MovieOrder>(movieOrderService.getById(id));
    }

    /**
     * 更新学院
     * */
    @RequestMapping(value = "/update")
    @ResponseBody
    @BizOperLog(operType = OperType.UPDATE,memo = "更新影院")
    public IResult update(@RequestBody @Valid MovieOrder movieOrder){
    
    
        //传递了数组，前台放在payload里面了，后台通过@RequestBody获取
        //返回json至前端的均返回ResultBean或者PageResultBean
        if("退票完成".equals(movieOrder.getStatus())){
    
    
            return new ResultBean<Boolean>(movieOrderService.toRemitAmount(movieOrder));
        }else{
    
    
            return new ResultBean<Boolean>(movieOrderService.updateById(movieOrder));

        }
    }

    /**
     * 更新学院
     * */
    @RequestMapping(value = "/remitOperator")
    @ResponseBody
    @BizOperLog(operType = OperType.UPDATE,memo = "退款操作")
    public IResult remitOperator(@RequestBody @Valid MovieOrder movieOrder){
    
    
        //传递了数组，前台放在payload里面了，后台通过@RequestBody获取
        //返回json至前端的均返回ResultBean或者PageResultBean
        return new ResultBean<Boolean>(movieOrderService.remitAmount(movieOrder));
    }


}

代码All

dao层

package com.gameloft9.demo.dataaccess.dao.business;

import com.gameloft9.demo.dataaccess.model.business.SelectedSeat;
import com.gameloft9.demo.dataaccess.model.business.SelectedSeatExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;

public interface SelectedSeatMapper {
    
    
    int countByExample(SelectedSeatExample example);

    int deleteByExample(SelectedSeatExample example);

    int deleteByPrimaryKey(Integer id);

    int insert(SelectedSeat record);

    int insertSelective(SelectedSeat record);

    List<SelectedSeat> selectByExample(SelectedSeatExample example);

    SelectedSeat selectByPrimaryKey(Integer id);

    int updateByExampleSelective(@Param("record") SelectedSeat record, @Param("example") SelectedSeatExample example);

    int updateByExample(@Param("record") SelectedSeat record, @Param("example") SelectedSeatExample example);

    int updateByPrimaryKeySelective(SelectedSeat record);

    int updateByPrimaryKey(SelectedSeat record);

    int deleteBySid(Integer sId);



}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.gameloft9.demo.dataaccess.dao.business.SelectedSeatMapper" >
  <resultMap id="BaseResultMap" type="com.gameloft9.demo.dataaccess.model.business.SelectedSeat" >
    <id column="id" property="id" jdbcType="INTEGER" />
    <result column="my_x" property="myX" jdbcType="INTEGER" />
    <result column="my_y" property="myY" jdbcType="INTEGER" />
    <result column="is_select" property="isSelect" jdbcType="VARCHAR" />
    <result column="u_id" property="uId" jdbcType="INTEGER" />
    <result column="u_name" property="uName" jdbcType="VARCHAR" />
    <result column="s_id" property="sId" jdbcType="INTEGER" />
  </resultMap>
  <sql id="Example_Where_Clause" >
    <where >
      <foreach collection="oredCriteria" item="criteria" separator="or" >
        <if test="criteria.valid" >
          <trim prefix="(" suffix=")" prefixOverrides="and" >
            <foreach collection="criteria.criteria" item="criterion" >
              <choose >
                <when test="criterion.noValue" >
                  and ${
    
    criterion.condition}
                </when>
                <when test="criterion.singleValue" >
                  and ${
    
    criterion.condition} #{
    
    criterion.value}
                </when>
                <when test="criterion.betweenValue" >
                  and ${
    
    criterion.condition} #{
    
    criterion.value} and #{
    
    criterion.secondValue}
                </when>
                <when test="criterion.listValue" >
                  and ${
    
    criterion.condition}
                  <foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
                    #{
    
    listItem}
                  </foreach>
                </when>
              </choose>
            </foreach>
          </trim>
        </if>
      </foreach>
    </where>
  </sql>
  <sql id="Update_By_Example_Where_Clause" >
    <where >
      <foreach collection="example.oredCriteria" item="criteria" separator="or" >
        <if test="criteria.valid" >
          <trim prefix="(" suffix=")" prefixOverrides="and" >
            <foreach collection="criteria.criteria" item="criterion" >
              <choose >
                <when test="criterion.noValue" >
                  and ${
    
    criterion.condition}
                </when>
                <when test="criterion.singleValue" >
                  and ${
    
    criterion.condition} #{
    
    criterion.value}
                </when>
                <when test="criterion.betweenValue" >
                  and ${
    
    criterion.condition} #{
    
    criterion.value} and #{
    
    criterion.secondValue}
                </when>
                <when test="criterion.listValue" >
                  and ${
    
    criterion.condition}
                  <foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
                    #{
    
    listItem}
                  </foreach>
                </when>
              </choose>
            </foreach>
          </trim>
        </if>
      </foreach>
    </where>
  </sql>
  <sql id="Base_Column_List" >
    id, my_x, my_y, is_select, u_id, u_name, s_id
  </sql>
  <select id="selectByExample" resultMap="BaseResultMap" parameterType="com.gameloft9.demo.dataaccess.model.business.SelectedSeatExample" >
    select
    <if test="distinct" >
      distinct
    </if>
    <include refid="Base_Column_List" />
    from selected_seat
    <if test="_parameter != null" >
      <include refid="Example_Where_Clause" />
    </if>
    <if test="orderByClause != null" >
      order by ${
    
    orderByClause}
    </if>
  </select>
  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
    select 
    <include refid="Base_Column_List" />
    from selected_seat
    where id = #{
    
    id,jdbcType=INTEGER}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
    delete from selected_seat
    where id = #{
    
    id,jdbcType=INTEGER}
  </delete>
  <delete id="deleteByExample" parameterType="com.gameloft9.demo.dataaccess.model.business.SelectedSeatExample" >
    delete from selected_seat
    <if test="_parameter != null" >
      <include refid="Example_Where_Clause" />
    </if>
  </delete>
  <insert id="insert" parameterType="com.gameloft9.demo.dataaccess.model.business.SelectedSeat" >
    insert into selected_seat (id, my_x, my_y, 
      is_select, u_id, u_name, 
      s_id)
    values (#{
    
    id,jdbcType=INTEGER}, #{
    
    myX,jdbcType=INTEGER}, #{
    
    myY,jdbcType=INTEGER}, 
      #{
    
    isSelect,jdbcType=VARCHAR}, #{
    
    uId,jdbcType=INTEGER}, #{
    
    uName,jdbcType=VARCHAR}, 
      #{
    
    sId,jdbcType=INTEGER})
  </insert>
  <insert id="insertSelective" parameterType="com.gameloft9.demo.dataaccess.model.business.SelectedSeat" >
    insert into selected_seat
    <trim prefix="(" suffix=")" suffixOverrides="," >
      <if test="id != null" >
        id,
      </if>
      <if test="myX != null" >
        my_x,
      </if>
      <if test="myY != null" >
        my_y,
      </if>
      <if test="isSelect != null" >
        is_select,
      </if>
      <if test="uId != null" >
        u_id,
      </if>
      <if test="uName != null" >
        u_name,
      </if>
      <if test="sId != null" >
        s_id,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides="," >
      <if test="id != null" >
        #{
    
    id,jdbcType=INTEGER},
      </if>
      <if test="myX != null" >
        #{
    
    myX,jdbcType=INTEGER},
      </if>
      <if test="myY != null" >
        #{
    
    myY,jdbcType=INTEGER},
      </if>
      <if test="isSelect != null" >
        #{
    
    isSelect,jdbcType=VARCHAR},
      </if>
      <if test="uId != null" >
        #{
    
    uId,jdbcType=INTEGER},
      </if>
      <if test="uName != null" >
        #{
    
    uName,jdbcType=VARCHAR},
      </if>
      <if test="sId != null" >
        #{
    
    sId,jdbcType=INTEGER},
      </if>
    </trim>
  </insert>
  <select id="countByExample" parameterType="com.gameloft9.demo.dataaccess.model.business.SelectedSeatExample" resultType="java.lang.Integer" >
    select count(*) from selected_seat
    <if test="_parameter != null" >
      <include refid="Example_Where_Clause" />
    </if>
  </select>
  <update id="updateByExampleSelective" parameterType="map" >
    update selected_seat
    <set >
      <if test="record.id != null" >
        id = #{
    
    record.id,jdbcType=INTEGER},
      </if>
      <if test="record.myX != null" >
        my_x = #{
    
    record.myX,jdbcType=INTEGER},
      </if>
      <if test="record.myY != null" >
        my_y = #{
    
    record.myY,jdbcType=INTEGER},
      </if>
      <if test="record.isSelect != null" >
        is_select = #{
    
    record.isSelect,jdbcType=VARCHAR},
      </if>
      <if test="record.uId != null" >
        u_id = #{
    
    record.uId,jdbcType=INTEGER},
      </if>
      <if test="record.uName != null" >
        u_name = #{
    
    record.uName,jdbcType=VARCHAR},
      </if>
      <if test="record.sId != null" >
        s_id = #{
    
    record.sId,jdbcType=INTEGER},
      </if>
    </set>
    <if test="_parameter != null" >
      <include refid="Update_By_Example_Where_Clause" />
    </if>
  </update>
  <update id="updateByExample" parameterType="map" >
    update selected_seat
    set id = #{
    
    record.id,jdbcType=INTEGER},
      my_x = #{
    
    record.myX,jdbcType=INTEGER},
      my_y = #{
    
    record.myY,jdbcType=INTEGER},
      is_select = #{
    
    record.isSelect,jdbcType=VARCHAR},
      u_id = #{
    
    record.uId,jdbcType=INTEGER},
      u_name = #{
    
    record.uName,jdbcType=VARCHAR},
      s_id = #{
    
    record.sId,jdbcType=INTEGER}
    <if test="_parameter != null" >
      <include refid="Update_By_Example_Where_Clause" />
    </if>
  </update>
  <update id="updateByPrimaryKeySelective" parameterType="com.gameloft9.demo.dataaccess.model.business.SelectedSeat" >
    update selected_seat
    <set >
      <if test="myX != null" >
        my_x = #{
    
    myX,jdbcType=INTEGER},
      </if>
      <if test="myY != null" >
        my_y = #{
    
    myY,jdbcType=INTEGER},
      </if>
      <if test="isSelect != null" >
        is_select = #{
    
    isSelect,jdbcType=VARCHAR},
      </if>
      <if test="uId != null" >
        u_id = #{
    
    uId,jdbcType=INTEGER},
      </if>
      <if test="uName != null" >
        u_name = #{
    
    uName,jdbcType=VARCHAR},
      </if>
      <if test="sId != null" >
        s_id = #{
    
    sId,jdbcType=INTEGER},
      </if>
    </set>
    where id = #{
    
    id,jdbcType=INTEGER}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.gameloft9.demo.dataaccess.model.business.SelectedSeat" >
    update selected_seat
    set my_x = #{
    
    myX,jdbcType=INTEGER},
      my_y = #{
    
    myY,jdbcType=INTEGER},
      is_select = #{
    
    isSelect,jdbcType=VARCHAR},
      u_id = #{
    
    uId,jdbcType=INTEGER},
      u_name = #{
    
    uName,jdbcType=VARCHAR},
      s_id = #{
    
    sId,jdbcType=INTEGER}
    where id = #{
    
    id,jdbcType=INTEGER}
  </update>

  <!--以下是我自己开发的代码-->
  <delete id="deleteBySid" parameterType="java.lang.Integer">
    delete from selected_seat
    where s_id = #{
    
    sId,jdbcType=INTEGER}
  </delete>
</mapper>

Service 层

package com.gameloft9.demo.service.api.business;

import com.gameloft9.demo.dataaccess.model.business.VideoHall;
import com.github.pagehelper.PageInfo;

import java.util.*;

/**
 * create by IntelliJ IDEA
 *
 * @author : xiaozheng
 * DATE: 2019/9/22 0022
 * TIME: 下午 12:38
 * Description:
 */
public interface SelectedSeatService {
    
    

    /**
     * 生成座位信息
     * @param
     * @return
     */
    boolean add(Integer myX, Integer myY, Integer sId);

    /**
     * 根据主键删除电影院厅信息
     * @param sId
     * @return
     */
    boolean deleteBySId(Integer sId);

    /**
     * 根据主键更新电影院厅信息
     * @param seatMessage
     * @param sId
     * @return
     */
    boolean updateByMyXAndMyYAndSid(String seatMessage, Integer sId, String isSelected);




}


package com.gameloft9.demo.service.impl.business;

import com.gameloft9.demo.dataaccess.dao.business.SelectedSeatMapper;
import com.gameloft9.demo.dataaccess.model.business.SelectedSeat;
import com.gameloft9.demo.dataaccess.model.business.SelectedSeatExample;
import com.gameloft9.demo.mgrframework.utils.CheckUtil;
import com.gameloft9.demo.service.api.business.SelectedSeatService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.ibatis.annotations.Select;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;
/**
 * create by IntelliJ IDEA
 *
 * @author : xiaozheng
 * DATE: 2019/9/22 0022
 * TIME: 下午 12:43
 * Description:
 */
@Slf4j
@Service
public class SelectedSeatServiceImpl implements SelectedSeatService {
    
    

    @Autowired
    private SelectedSeatMapper selectedSeatMapper;


    @Override
    public boolean add(Integer myX, Integer myY, Integer sId) {
    
    

        CheckUtil.notNull(myX,"座位数不能为空");
        CheckUtil.notNull(myY,"排数为空");
        CheckUtil.notNull(sId,"放映安排为空");
        for(int i = 0; i < myX; i++){
    
    
            for(int j = 0; j < myY; j++){
    
    
                SelectedSeat selectedSeat = new SelectedSeat();
                selectedSeat.setMyX(i);
                selectedSeat.setMyY(j);
                selectedSeat.setsId(sId);
                selectedSeat.setIsSelect("否");
                selectedSeatMapper.insert(selectedSeat);
            }
        }
        SelectedSeatExample selectedSeatExample = new SelectedSeatExample();
        SelectedSeatExample.Criteria criteria = selectedSeatExample.createCriteria();
        criteria.andSIdEqualTo(sId);
        List<SelectedSeat> selectedSeats = selectedSeatMapper.selectByExample(selectedSeatExample);
        if(CollectionUtils.isNotEmpty(selectedSeats)){
    
    
            return myX * myY == selectedSeats.size();
        }
        return false;
    }

    @Override
    public boolean deleteBySId(Integer sId) {
    
    
        CheckUtil.notNull(sId, "删除电影播放安排ID为空");
        int i = selectedSeatMapper.deleteBySid(sId);
        return this.returnBoolean(i);
    }

    @Override
    public boolean updateByMyXAndMyYAndSid(String seatMessage, Integer sId, String isSelected) {
    
    
        CheckUtil.notNull(sId, "电影播放安排sId为空");
        CheckUtil.notNull(sId, "座位信息为空");
        String[] sArr = seatMessage.split(" ");
        int i = 0;
        for(String s : sArr){
    
    

            int myX = Integer.parseInt(s.split("排")[1].split("座")[0]);
            int myY = Integer.parseInt(s.split("排")[0]);

            SelectedSeat oldSelectedSeat = this.getByMyXAndMyYAndSid(myX - 1, myY - 1, sId);
            oldSelectedSeat.setIsSelect(isSelected);
            i = selectedSeatMapper.updateByPrimaryKey(oldSelectedSeat);
        }
        return this.returnBoolean(i);
    }

    private SelectedSeat getByMyXAndMyYAndSid(Integer myX, Integer myY, Integer sId){
    
    
        SelectedSeatExample selectedSeatExample = new SelectedSeatExample();
        SelectedSeatExample.Criteria criteria = selectedSeatExample.createCriteria();
        criteria.andMyXEqualTo(myX);
        criteria.andMyYEqualTo(myY);
        criteria.andSIdEqualTo(sId);
        return selectedSeatMapper.selectByExample(selectedSeatExample).get(0);
    }

    private boolean returnBoolean(int i ){
    
    
        if( i > 0) {
    
    
            return true;
        }else{
    
    
            return false;
        }
    }

    public static void main(String[] args) {
    
    
        String s = "3排6座";
        int myX = Integer.parseInt(s.substring(2,3));
        int myY = Integer.parseInt(s.substring(0,1));
        System.out.println(myX);
        System.out.println(myY);
    }
}

小总结

知 道 的 越 多 ， 不 知 道 的 越 多 ， 希 望 对 你 有 帮 助 ！ \color{red}知道的越多，不知道的越多，希望对你有帮助！ 知道的越多，不知道的越多，希望对你有帮助！
想 要 源 码 ， 想 要 指 导 毕 业 设 计 ， 加 我 Q Q ： 924155240 \color{red}想要源码，想要指导毕业设计，加我QQ：924155240 想要源码，想要指导毕业设计，加我QQ：924155240

猜你喜欢

转载自blog.csdn.net/xiaozhegaa/article/details/112363559
今日推荐
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
周排行
阿里云短信服务平台注册
Windows下的字符串处理(1)
sqoop: mysql导入数据到hdfs, hive, hbase
commons.lang中常用的工具类
离线安装PostgreSQL11.6
使用PyTorch简单实现卷积神经网络模型
一文彻底搞定谱聚类
一道面试题引发的血案
One Chat for Mac(聊天工具)
TCP/IP的底层队列是如何实现的？
每日归档
更多
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022